Generating interfaces(CLI, Qt GUI, Dash web app) from a Python function.

Wrap a CLI program to a GUI/Web interface app.

Using a .yaml as config to specify the arguments:

# open_browser_oneface.yaml
name: open_browser

command: python -m webbrowser {is_tab} {url} 

arguments:

  is_tab:
    type: bool
    true_content: "-t"
    false_content: ""

  url:
    type: str

Launch the app with:

$ python -m onface.wrap_cli run open_browser_oneface.yaml qt_gui

It will get a GUI app.

Hello, i am Onur, i am a CTO of a community that develop Blockchain based Decentralized Application Network. This repository have a very good idea. All contributor of this project and me should develop this project and use in the other project. Let's not stop developing.

Onur Atakan ULUSOY - CTO of Decentra Network Community

Allow type annotation with python builtin types, for example:

from oneface import one, Arg

@one
def bmi(name: str,
        height: (float, [100, 250]) = 160,
        weight: (float, [0, 300]) = 50.0):
    BMI = weight / (height / 100) ** 2
    print(f"Hi {name}. Your BMI is: {BMI}")
    return BMI

# run cli
bmi.cli()

Let the annotation automatically convert to Arg when parse the parameters.

import sys
from oneface.qt import qt_window
from oneface import one
from qtpy import QtWidgets

app = QtWidgets.QApplication([])


@qt_window
@one
def add(a: int, b: int):
    return a + b

@qt_window
@one
def mul(a: int, b: int):
    return a * b


main_window = QtWidgets.QWidget()
main_window.setWindowTitle("MyApp")
main_window.setFixedSize(200, 100)
layout = QtWidgets.QVBoxLayout(main_window)
layout.addWidget(QtWidgets.QLabel("Apps:"))
btn_open_add = QtWidgets.QPushButton("add")
btn_open_mul = QtWidgets.QPushButton("mul")
btn_open_add.clicked.connect(add.show)
btn_open_mul.clicked.connect(mul.show)
layout.addWidget(btn_open_add)
layout.addWidget(btn_open_mul)
main_window.show()

sys.exit(app.exec())

Allow render the result with ploty. The wraped function return a plotly figure object:

from oneface import one, Arg
import plotly.express as px
import numpy as np

@one
def draw_random_points(n: Arg[int, [1, 10000]] = 100):
    x, y = np.random.random(n), np.random.random(n)
    fig = px.scatter(x=x, y=y)
    return fig

draw_random_points.dash_app(
    result_show_type='plotly',
    debug=True)

Embeding the generated dash app as a route of flask server.

# demo_flask_integrate.py
from flask import Flask
from oneface.dash_app import flask_route
from oneface.core import one

server = Flask("test_dash_app")

@flask_route(server, "/add")
@one
def add(a: int, b: int) -> int:
    return a + b

@flask_route(server, "/mul")
@one
def mul(a: int, b: int) -> int:
    return a * b

server.run("127.0.0.1", 8088)

Run this will launch a flask server support run multiple dash app from different route.

References:

• https://blog.finxter.com/dash-flask/

For example:

from oneface import one, Arg
from oneface.dash_app import App, InputItem
from dash import dcc, html

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age


def check_person_type(val, tp):
    return (
        isinstance(val, tp) and
        isinstance(val.name, str) and
        isinstance(val.age, int)
    )

Arg.register_type_check(Person, check_person_type)
Arg.register_range_check(Person, lambda val, range: range[0] <= val.age <= range[1])

class PersonInputItem(InputItem):
    def get_input(self):
        if self.default:
            default_val = f"Person('{self.default.name}', {self.default.age})"
        else:
            default_val = ""
        return dcc.Input(
            placeholder="example: Person('age', 20)",
            type="text",
            value=default_val,
            style={
                "width": "100%",
                "height": "40px",
                "margin": "5px",
                "font-size": "20px",
            }
        )


App.register_widget(Person, PersonInputItem)
App.register_type_convert(Person, lambda s: eval(s))


@one
def print_person(person: Arg(Person, [0, 100]) = Person("Tom", 10)):
    print(f"{person.name} is {person.age} years old.")


print_person.dash_app()

This code using the serialized input Person, how to define a "Composite components" in dash to support Person input? Just like in Qt: