def test_element_creation_modification_and_call():
page = Page()
page.start(open_browser=False)
subprocess.check_call([
'awe', 'new', '-o', 'Text: Hello World', '-p', 'props: {key1: value1}'
])
text1 = page.children[0]
assert isinstance(text1, view.Text)
assert text1.text == 'Hello World'
assert text1.props['key1'] == 'value1'
subprocess.check_call(['awe', 'new-prop', '-e', text1.id, '-n', 'prop1'])
assert 'prop1' in text1._prop_children
subprocess.check_call(
['awe', 'update-data', '-e', text1.id, '-d', 'text: New Text'])
assert text1.text == 'New Text'
subprocess.check_call(
['awe', 'update-props', '-e', text1.id, '-p', 'key1: value11'])
assert text1.props['key1'] == 'value11'
subprocess.check_call(
['awe', 'update-prop', '-e', text1.id, '-p', 'key1', '-v', 'value12'])
assert text1.props['key1'] == 'value12'
subprocess.check_call([
'awe', 'call', '-e', text1.id, '-m', 'update_props', '-k',
'props: {key1: value13}'
])
assert text1.props['key1'] == 'value13'
subprocess.check_call(['awe', 'remove', '-e', text1.id])
assert page.children == []
def test_parse_element_configuration_element_prop():
page = Page()
result = page.new('''
Divider:
- [prop1: Prop1 Value]
''')
assert result.props['prop1'] == 'Prop1 Value'
def test_variables():
page = Page()
input1 = page.new_input(id='input1')
page.start(open_browser=False)
output = subprocess.check_output(['awe', '-l', 'ls-variables'])
parsed_output = json.loads(output)
assert parsed_output[input1.id] == {
'id': input1.id,
'value': '',
'version': 0
}
output = subprocess.check_output(
['awe', '-l', 'get-variable', '-v', input1.id])
parsed_output = json.loads(output)
assert parsed_output == {'id': input1.id, 'value': '', 'version': 0}
subprocess.check_call(
['awe', 'new-variable', '-d', 'initial-value', '-v', 'variable1'])
assert page._registry.variables['variable1'].get_variable() == {
'id': 'variable1',
'value': 'initial-value',
'version': 0
}
subprocess.check_call(
['awe', 'update-variable', '-d', 'new-value', '-v', 'variable1'])
assert page._registry.variables['variable1'].get_variable() == {
'id': 'variable1',
'value': 'new-value',
'version': 1
}
def test_inputs():
page = Page()
fn = lambda: None
text1 = 'Text Input 1'
text2 = 'Text Input 2'
input3 = 'Input 3 Value'
inputs = {
'fn1': fn,
'text1': text1,
'text2': text2,
'input3': input3
}
layout = '''
- Button: [[button1, function: {$: fn1}]]
- Text: {$: text1}
- Inline:
- [text2]
- {$: text2}
- Inline:
- [text3]
- {$: [text3, default: {$: input3}]}
'''
top_level = page.new(layout, inputs=inputs)
ref = top_level.ref
assert top_level.children[1].text == text1
assert ref.button1._function is fn
assert ref.text2.children[0].text == text2
assert ref.text3.children[0].text == input3
def main():
now = time.time()
page = Page('Showcase')
grid = page.new_grid(columns=3, props={'gutter': 12})
grid.new_card('Card 1')
card = grid.new_card()
tabs = grid.new_tabs()
collapse = grid.new_collapse()
grid.new_chart([(now + i, -i) for i in range(100)], transform='numbers')
grid.new_table(['Header 1', 'Header 2', 'Header 3'], page_size=4).extend([[
'Value {}'.format(i), 'Value {}'.format(i + 1),
'Value {}'.format(i + 2)
] for i in range(1, 20, 3)])
grid.new_divider()
grid.new_button(lambda: None, 'Button 1', block=True)
grid.new_input()
grid.new_icon('heart', theme='twoTone', two_tone_color='red')
inline = grid.new_inline()
card.new_text('Card Text 1')
card.new_text('Card Text 2')
tabs.new_tab('Tab 1').new_text('Tab 1 Text')
tabs.new_tab('Tab 2').new_text('Tab 2 Text')
tabs.new_tab('Tab 3').new_text('Tab 3 Text')
tabs.new_tab('Tab 4').new_text('Tab 4 Text')
collapse.new_panel('Panel 1', active=True).new_text('Panel 1 Text')
collapse.new_panel('Panel 2').new_text('Panel 2 Text')
collapse.new_panel('Panel 3').new_text('Panel 3 Text')
collapse.new_panel('Panel 4').new_text('Panel 4 Text')
collapse.new_panel('Panel 5').new_text('Panel 5 Text')
inline.new_inline('inline 1')
inline.new_inline('inline 2')
inline.new_inline('inline 3')
page.start(True)
def test_parse_element_configuration_init_arg():
page = Page()
result = page.new('''
Text:
- [text: Hello Text]
''')
assert result.text == 'Hello Text'
def test_text_child():
page = Page()
result = page.new('''
Card:
- Card Text
''')
assert result.children[0].text == 'Card Text'
def test_parse_element_configuration_updater():
page = Page()
page.new('''
Text:
- [updater: {$: fn}]
''', inputs={'fn': lambda: None})
assert page._element_updater.threads
def test_parse_element_configuration_id():
page = Page()
result = page.new('''
Divider:
- [id: divider1]
''')
assert result.id == 'divider1'
def test_update_props():
page = Page()
class TestElement(view.Element):
pass
element = page._new_child(TestElement)
element.update_props({'key1': 'value1', 'key2': 'value2'})
assert element.props == {
'key1': 'value1',
'key2': 'value2',
'key': element.id
}
element.update_props({'key1': 'new_value1'})
assert element.props == {
'key1': 'new_value1',
'key2': 'value2',
'key': element.id
}
element.update_props({
'key1': 'newer_value1',
'key3': 'value3'
},
override=False)
assert element.props == {
'key1': 'new_value1',
'key2': 'value2',
'key': element.id,
'key3': 'value3'
}
def test_base():
page = Page()
test_data = {'data_key': 'value1'}
test_props = {'props_key': 'value2'}
style = {'s1': 'v1'}
test_id = 'test_id'
class TestElement(view.Element):
def _init(self):
self.update_data(test_data)
self.update_props(test_props)
class TestElement2(view.Element):
pass
class TestElement4(view.Element):
def _init(self, arg1, arg2):
self.arg1 = arg1
self.arg2 = arg2
assert page.index == 0
assert page._version == 0
test_element = page._new_child(TestElement, style=style)
assert page._version == 2
test_element2 = page._new_child(TestElement2)
test_element3 = page._new_child(TestElement, id=test_id)
test_element4 = test_element3._new_child(TestElement4,
arg1='val1',
arg2='val2')
assert page._registry.elements == {
t.id: t
for t in [test_element, test_element2, test_element3, test_element4]
}
assert page.children == [test_element, test_element2, test_element3]
assert test_element.id == str(id(test_element))
assert test_element.element_type == 'TestElement'
assert test_element.parent is page
assert test_element.index == 1
assert test_element.data == test_data
assert test_element.props == {
'key': test_element.id,
'props_key': 'value2',
'style': style
}
assert test_element.children == []
assert test_element2.index == 2
assert test_element2.data == {}
assert test_element2.props == {'key': test_element2.id}
assert test_element3.id == test_id
assert test_element3.children == [test_element4]
assert test_element4.arg1 == 'val1'
assert test_element4.arg2 == 'val2'
def test_parse_inline_text():
page = Page()
result = page.new('span: Hello There')
assert isinstance(result, view.Raw)
assert len(result.children) == 1
child = result.children[0]
assert isinstance(child, view.Inline)
assert child.text == 'Hello There'
def test_parse_children():
page = Page()
result = page.new(['Divider', 'Text'])
children = result.children
assert len(children) == 2
divider, text = children
assert isinstance(divider, view.Divider)
assert isinstance(text, view.Text)
def test_parse_element_configuration_variable_and_more():
page = Page()
result = page.new('''
Divider:
- [divider_var1, id: divider1]
''')
assert result.ref.divider_var1 is result
assert result.id == 'divider1'
def test_parse_element_configuration_cols():
page = Page()
result = page.new('''
Grid:
- [columns: 3]
- Text: [[cols: 2]]
''')
assert result.data['childColumns'] == [2]
def main():
page = Page()
data = generate_random_data(1)
chart = page.new_chart(data=data, transform='2to31', moving_window=3 * 60)
page.start()
while True:
time.sleep(5)
chart.add(generate_random_data(1))
def test_parse_element_configuration_element_value():
page = Page()
result = page.new('''
Divider:
- [prop1: {_: {Divider: [[inner_divider]]}}]
''')
assert isinstance(result.ref.inner_divider, view.Divider)
assert result._prop_children['prop1'] == result.ref.inner_divider.root_id
def main():
page = Page()
page.start()
page.new_text('Header', style={'fontSize': '1.5em', 'color': '#ff0000'})
for i in range(20):
page.new_text('{} hello {}'.format(i, i), style={'color': 'blue'})
time.sleep(2)
page.block()
def main():
page = Page()
popover = page.new(Popover, title='Some Title')
popover.new_button(lambda: None, 'Hover Me!')
content = popover.new_prop('content')
content.new_text('line 1')
content.new(Moment)
page.start(block=True)
def test_parser_yaml_string_input():
page = Page()
result = page.new('''
- Divider
- span: hello
''')
assert isinstance(result, view.Raw)
assert result.data['tag'] == 'div'
assert len(result.children) == 2
def test_no_allow_children():
page = Page()
class TestElement(view.Element):
allow_children = False
element = page._new_child(TestElement)
with pytest.raises(AssertionError):
element._new_child(TestElement)
def main():
args = (1, 3)
page = Page()
data = generate_random_data(*args)
chart = page.new_chart(data=data, transform='numbers')
page.start()
while True:
time.sleep(1)
chart.add(generate_random_data(*args))
def test_parse_element_configuration_element_value_init_arg():
page = Page()
result = page.new('''
Collapse:
- Panel: [[panel1, header: {_: {Text: Text 1}}]]
''')
panel1 = result.ref.panel1
assert panel1._prop_children
assert panel1.header.children[0].text == 'Text 1'
def wrapper(fn):
page = Page(**page_kwargs)
page.start(open_browser=False)
@retry()
def result():
driver.get('http://localhost:{}'.format(page._port))
fn()
return result
def main():
page = Page()
kitchen = Kitchen(page)
page.start()
try:
for i in range(1000):
kitchen.update(i)
time.sleep(5)
except KeyboardInterrupt:
pass
def main():
page = Page()
collapse = page.new_collapse()
panel1 = collapse.new_panel('Panel 1', active=True)
panel1.new_text('Hello From Panel 1')
panel2 = collapse.new_panel('Panel 2', active=False)
panel2.new_text('Hello From Panel2')
panel3 = collapse.new_panel('Panel 3')
panel3.new_text('Hello From Panel3')
page.start(block=True)
def test_parse_custom_element():
class TestElement(view.CustomElement):
@classmethod
def _js(cls):
pass
page = Page()
page.register(TestElement)
result = page.new('TestElement')
assert isinstance(result, TestElement)
def test_ls_and_get():
page = Page()
text1 = page.new_text()
page.start(open_browser=False)
output = subprocess.check_output(['awe', '-l', 'ls'])
parsed_output = json.loads(output)
assert parsed_output[text1.id]['id'] == text1.id
output = subprocess.check_output(['awe', '-l', 'get', '-e', text1.id])
parsed_output = json.loads(output)
assert parsed_output['id'] == text1.id
def test_parse_element_configuration_variables():
page = Page()
result = page.new('''
- Divider:
- [divider1]
- span:
- [span1]
- Inline: Hello There
''')
assert isinstance(result.ref.divider1, view.Divider)
assert isinstance(result.ref.span1, view.Raw)
def test_export_with_custom_element():
js_code = 'register((e) => <div {...e.props}>text</div>)'
class TestElement(CustomElement):
@classmethod
def _js(cls):
return js_code
page = Page()
page.new(TestElement)
assert js_code in page.export()