4 |
5 | oneFace is a Python library for automatically generating multiple interfaces(CLI, GUI, WebGUI) from a callable Python object or a command line program.
6 | 7 |
8 |
9 | 
10 |
11 |
12 | 
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
2 |
3 | oneFace is a Python library for automatically generating multiple interfaces(CLI, GUI, WebGUI) from a callable Python object.
4 |
5 | ## Features
6 |
7 | + Generate CLI, Qt GUI, Dash Web app from a python function or a command line.
8 | + Automatically check the type and range of input parameters and pretty print them.
9 | + Easy extension of parameter types and GUI widgets.
10 | + Support for embedding the generated interface into a parent application.
11 |
12 |
13 | ## Installation
14 |
15 | To install oneFace with complete dependency:
16 |
17 | ```
18 | $ pip install "oneface[all]"
19 | ```
20 |
21 | Or install with just qt or dash dependency:
22 |
23 | ```
24 | $ pip install "oneface[qt]" # qt
25 | $ pip install "oneface[dash]" # dash
26 | ```
27 |
28 | ### Qt bindings
29 |
30 | oneFace support different Qt bindings: PyQt6(default), PyQt5, PySide2, PySide6. It can be specified:
31 |
32 | ```
33 | $ pip install "oneface[pyside2]" # for example
34 | ```
35 |
36 | ## Example
37 |
38 | oneFace is an easy way to create interfaces in Python,
39 | just decorate your function and mark the **type** and **range** of the arguments:
40 |
41 | ```Python
42 | from oneface import one, Val
43 |
44 | @one
45 | def bmi(name: str,
46 | height: Val[float, [100, 250]] = 160,
47 | weight: Val[float, [0, 300]] = 50.0):
48 | BMI = weight / (height / 100) ** 2
49 | print(f"Hi {name}. Your BMI is: {BMI}")
50 | return BMI
51 |
52 |
53 | # run cli
54 | bmi.cli()
55 | # or run qt_gui
56 | bmi.qt_gui()
57 | # or run dash web app
58 | bmi.dash_app()
59 | ```
60 |
61 | These code will generate the following interfaces:
62 |
63 | | CLI | Qt | Dash |
64 | | ---- | -- | ---- |
65 | |  |  |  |
66 |
67 |
--------------------------------------------------------------------------------
/docs/qt_confs.md:
--------------------------------------------------------------------------------
1 | # Qt interface configs
2 |
3 | ## Window name
4 |
5 | By default the window name is the name of the function, but it can be changed by `name` parameter of `.qt_gui` method:
6 |
7 | ```Python
8 | from oneface import one, Val
9 |
10 | @one
11 | def bmi(name: str,
12 | height: Val[float, [100, 250]] = 160,
13 | weight: Val[float, [0, 300]] = 50.0):
14 | BMI = weight / (height / 100) ** 2
15 | print(f"Hi {name}. Your BMI is: {BMI}")
16 | return BMI
17 |
18 | bmi.qt_gui(name="BMI calculator")
19 | ```
20 |
21 | 
22 |
23 | ## Argument label
24 |
25 | By default, argument label is the variable name. But it can be explicitly set by `text` parameter:
26 |
27 | ```Python
28 | @one
29 | def bmi(name: Val(str, text="NAME"), # explicitly label setting
30 | height: Val[float, [100, 250]] = 160,
31 | weight: Val[float, [0, 300]] = 50.0):
32 | BMI = weight / (height / 100) ** 2
33 | print(f"Hi {name}. Your BMI is: {BMI}")
34 | return BMI
35 | ```
36 | 
37 |
38 | ## Run multiple times
39 |
40 | By default, oneface Qt interface run only once then exit, when click the run button.
41 |
42 | 
43 |
44 | You can use the `run_once=False` to make it run multiple times:
45 |
46 | ```Python
47 | bmi.qt_gui(run_once=False)
48 | ```
49 |
50 | 
51 |
52 | ## Window size
53 |
54 | The `size` parameter is used to explicitly specify the window size:
55 |
56 | ```Python
57 | bmi.qt_gui(size=(400, 600)) # width and height
58 | ```
59 |
--------------------------------------------------------------------------------
/docs/qt_embed.md:
--------------------------------------------------------------------------------
1 | # Embeding generated window to a PyQt app
2 |
3 | You can integrate oneFace generated Qt windows by embedding them in a Qt application:
4 |
5 | ```Python
6 | # demo_qt_embed.py
7 | import sys
8 | from oneface.qt import gui
9 | from oneface import one
10 | from qtpy import QtWidgets
11 |
12 | app = QtWidgets.QApplication([])
13 |
14 |
15 | @gui
16 | @one
17 | def add(a: int, b: int):
18 | res = a + b
19 | print(res)
20 |
21 | @gui
22 | @one
23 | def mul(a: int, b: int):
24 | res = a * b
25 | print(res)
26 |
27 |
28 | main_window = QtWidgets.QWidget()
29 | main_window.setWindowTitle("MyApp")
30 | main_window.setFixedSize(200, 100)
31 | layout = QtWidgets.QVBoxLayout(main_window)
32 | layout.addWidget(QtWidgets.QLabel("Apps:"))
33 | btn_open_add = QtWidgets.QPushButton("add")
34 | btn_open_mul = QtWidgets.QPushButton("mul")
35 | btn_open_add.clicked.connect(add.window.show)
36 | btn_open_mul.clicked.connect(mul.window.show)
37 | layout.addWidget(btn_open_add)
38 | layout.addWidget(btn_open_mul)
39 | main_window.show()
40 |
41 | sys.exit(app.exec())
42 | ```
43 |
44 | Run it:
45 |
46 | 
47 |
--------------------------------------------------------------------------------
/docs/requirements.txt:
--------------------------------------------------------------------------------
1 | mkdocs
2 | mkdocs-material
3 |
--------------------------------------------------------------------------------
/docs/type_extension.md:
--------------------------------------------------------------------------------
1 | # Type Extension
2 |
3 | You can easily extend the argument types in oneFace.
4 |
5 | ## Registration of type and range check
6 |
7 | For example you have a custom `Person` class:
8 |
9 | ```Python
10 | class Person:
11 | def __init__(self, name, age):
12 | self.name = name
13 | self.age = age
14 | ```
15 |
16 | ### Register type check
17 |
18 | ```Python
19 | Val.register_type_check(Person)
20 | ```
21 |
22 | This will allow oneface to check the type of the input parameter to make sure it is an instance of `Person`:
23 |
24 | ```Python
25 | @one
26 | def print_person(person: Person):
27 | print(f"{person.name} is {person.age} years old.")
28 |
29 | >>> print_person(["Tom", 10]) # Incorrect input type
30 | Run: print_person
31 | Arguments table:
32 |
33 | Argument Type Range InputVal InputType
34 | person