Download remi - download do código-fonte remi

Biblioteca GUI para seus aplicativos Python

Remi é uma biblioteca GUI para aplicativos Python que é renderizada em navegadores da web. Isso permite que você acesse sua interface local e remotamente.

Orgulho de ser patrocinado por

Você precisa de suporte?

Reddit - (subreddit RemiGUI)

Há também um editor GUI de arrastar e soltar . Veja a subpasta Editor para baixar sua cópia.

Um vídeo demonstrativo dos grandes laboratórios REVVEN

Começando

Para uma versão estável :

 pip install remi

Para a versão experimental mais atualizada Baixe ou verifique Remi no git e instale

 python setup.py install

ou instale diretamente usando pip

 pip install git+https://github.com/rawpython/remi.git

Em seguida, inicie o script de teste (baixe-o no github https://github.com/rawpython/remi/blob/master/examples/widgets_overview_app.py):

 python widgets_overview_app.py

Remi

Biblioteca Python GUI independente de plataforma. Em menos de 100 Kbytes de código-fonte, perfeito para sua dieta.

Remi permite que os desenvolvedores criem GUI independente de plataforma com Python. Toda a GUI é renderizada em seu navegador. Nenhum HTML é necessário, Remi traduz automaticamente seu código Python em HTML. Quando seu aplicativo é iniciado, ele inicia um servidor web que estará acessível em sua rede.

Um aplicativo básico aparece assim:

 import remi . gui as gui
from remi import start , App

class MyApp ( App ):
    def __init__ ( self , * args ):
        super ( MyApp , self ). __init__ ( * args )

    def main ( self ):
        container = gui . VBox ( width = 120 , height = 100 )
        self . lbl = gui . Label ( 'Hello world!' )
        self . bt = gui . Button ( 'Press me!' )

        # setting the listener for the onclick event of the button
        self . bt . onclick . do ( self . on_button_pressed )

        # appending a widget to another, the first argument is a string key
        container . append ( self . lbl )
        container . append ( self . bt )

        # returning the root widget
        return container

    # listener function
    def on_button_pressed ( self , widget ):
        self . lbl . set_text ( 'Button pressed!' )
        self . bt . set_text ( 'Hi!' )

# starts the web server
start ( MyApp , port = 8081 )

Para ver a interface do usuário, abra o navegador de sua preferência e digite "http://127.0.0.1:8081". Você pode alterar o endereço URL por **kwargs específicos no start da chamada de função. Isso será discutido mais tarde.

Testado em Android, Linux, Windows. Útil no Raspberry Pi para desenvolvimento de scripts Python. Permite interagir com seu Raspberry Pi remotamente a partir de seu dispositivo móvel.

Perguntas frequentes

Por que outra biblioteca GUI? Kivy, PyQT e PyGObject requerem código nativo para o sistema operacional host, o que significa instalar ou compilar grandes dependências. Remi precisa apenas de um navegador da web para mostrar sua GUI.
Preciso saber HTML? NÃO, não é obrigatório, você deve codificar apenas em Python.
É código aberto? Claro que sim! Remi é lançado sob a licença Apache. Consulte o arquivo LICENSE para obter mais detalhes.
Preciso de algum tipo de servidor web? Não, está incluído.

Breve tutorial

Importe a biblioteca Remi e algumas outras coisas úteis.

 import remi . gui as gui
from remi import start , App

Subclasse a classe App e declare uma função main que será o ponto de entrada do aplicativo. Dentro da função principal você deve return o widget raiz.

 class MyApp ( App ):
    def __init__ ( self , * args ):
        super ( MyApp , self ). __init__ ( * args )

    def main ( self ):
        lbl = gui . Label ( "Hello world!" , width = 100 , height = 30 )

        # return of the root widget
        return lbl

Fora da classe principal, inicie a aplicação chamando a função start e passando como parâmetro o nome da classe que você declarou anteriormente:

 # starts the webserver
start ( MyApp , port = 8081 )

Execute o script. Se estiver tudo bem a GUI será aberta automaticamente no seu navegador, caso contrário, você deverá digitar na barra de endereço "http://127.0.0.1:8081".

Você pode personalizar parâmetros opcionais na chamada start , como:

 start ( MyApp , address = '127.0.0.1' , port = 8081 , multiple_instance = False , enable_file_cache = True , update_interval = 0.1 , start_browser = True )

Parâmetros:

endereço: IP da interface de rede
porta: porta de escuta
multiple_instance: booleano, se True vários clientes que se conectam ao seu script têm instâncias de aplicativo diferentes (identificadas por um identificador de sessão de cookie exclusivo)
enable_file_cache: booleano, se True habilita o cache de recursos
update_interval: intervalo de atualização da GUI em segundos. Se for zero, a atualização acontece a cada alteração. Se for zero, o método App.idle não será chamado.
start_browser: booleano que define se o navegador deve ser aberto automaticamente na inicialização
autônomo: booleano, indica onde executar o aplicativo como um aplicativo Desktop padrão com janela própria. Se for falso, a interface será mostrada na página do navegador.

Parâmetros Adicionais:

nome de usuário: para uma autenticação HTTP básica
senha: para uma autenticação HTTP básica
certfile: nome do arquivo do certificado SSL
arquivo-chave: arquivo de chave SSL
ssl_version: versão de autenticação (ou seja, ssl.PROTOCOL_TLSv1_2). Se Nenhum desabilita a criptografia SSL

Todos os construtores de widgets aceitam dois padrões**kwargs que são:

largura: pode ser expressa como int (e é interpretada como um pixel) ou como str (e você pode especificar a unidade de medida como '10%')
height: pode ser expresso como int (e é interpretado como um pixel) ou como str (e você pode especificar a unidade de medida como '10%')

Eventos e retornos de chamada

Os widgets expõem um conjunto de eventos que acontecem durante a interação do usuário. Tais eventos são uma forma conveniente de definir o comportamento do aplicativo. Cada widget possui seus próprios retornos de chamada, dependendo do tipo de interação do usuário que permite. Os retornos de chamada específicos para os widgets serão ilustrados posteriormente.

Para registrar uma função como ouvinte de evento você deve chamar uma função como eventname.do (ou seja, onclick.do) passando como parâmetros o callback que irá gerenciar o evento. Segue um exemplo:

 import remi . gui as gui
from remi import start , App

class MyApp ( App ):
    def __init__ ( self , * args ):
        super ( MyApp , self ). __init__ ( * args )

    def main ( self ):
        container = gui . VBox ( width = 120 , height = 100 )
        self . lbl = gui . Label ( 'Hello world!' )
        self . bt = gui . Button ( 'Press me!' )

        # setting the listener for the onclick event of the button
        self . bt . onclick . do ( self . on_button_pressed )

        # appending a widget to another, the first argument is a string key
        container . append ( self . lbl )
        container . append ( self . bt )

        # returning the root widget
        return container

    # listener function
    def on_button_pressed ( self , widget ):
        self . lbl . set_text ( 'Button pressed!' )
        self . bt . set_text ( 'Hi!' )

# starts the web server
start ( MyApp )

No exemplo mostrado, self.bt.onclick.do(self.on_button_pressed) registra a função on_button_pressed do self como um ouvinte para o evento onclick exposto pelo widget Button. Simples, fácil.

Os retornos de chamada do ouvinte receberão primeiro a instância do emissor e depois todos os outros parâmetros fornecidos pelo evento específico.

Além do registro de eventos padrão (conforme mencionado acima), é possível passar parâmetros do usuário para funções de ouvinte. Isso pode ser conseguido anexando parâmetros à chamada da função do .

 import remi . gui as gui
from remi import start , App

class MyApp ( App ):
    def __init__ ( self , * args ):
        super ( MyApp , self ). __init__ ( * args )

    def main ( self ):
        container = gui . VBox ( width = 120 , height = 100 )
        self . lbl = gui . Label ( 'Hello world!' )
        self . bt = gui . Button ( 'Hello name!' )
        self . bt2 = gui . Button ( 'Hello name surname!' )

        # setting the listener for the onclick event of the buttons
        self . bt . onclick . do ( self . on_button_pressed , "Name" )
        self . bt2 . onclick . do ( self . on_button_pressed , "Name" , "Surname" )

        # appending a widget to another
        container . append ( self . lbl )
        container . append ( self . bt )
        container . append ( self . bt2 )

        # returning the root widget
        return container

    # listener function
    def on_button_pressed ( self , widget , name = '' , surname = '' ):
        self . lbl . set_text ( 'Button pressed!' )
        widget . set_text ( 'Hello ' + name + ' ' + surname )

# starts the web server
start ( MyApp )

Isso permite grande flexibilidade, obtendo comportamentos diferentes com a mesma definição de ouvinte de evento.

Acessibilidade de atributos HTML

Às vezes é necessário acessar a representação HTML do Widget para manipular os atributos HTML. A biblioteca permite acessar essas informações facilmente.

Um exemplo simples: é o caso em que você deseja adicionar um texto instantâneo a um widget. Isso pode ser conseguido pelo atributo title de uma tag HTML. Para fazer isso:

    widget_instance . attributes [ 'title' ] = 'Your title content'

Um caso especial de atributo HTML é o estilo . Os atributos de estilo podem ser alterados desta forma:

    widget_instance . style [ 'color' ] = 'red'

A atribuição de um novo atributo o cria automaticamente.

Para obter uma lista de referência de atributos HTML, você pode consultar https://www.w3schools.com/tags/ref_attributes.asp

Para obter uma lista de referência de atributos de estilo, você pode consultar https://www.w3schools.com/cssref/default.asp

Tome cuidado com os atributos usados internamente. Estes são:

class : é usado para armazenar o nome da classe do widget para fins de estilo
id : é usado para armazenar o id da instância do widget para gerenciamento de retorno de chamada

Acesso remoto

Se você estiver usando seu aplicativo REMI remotamente, com DNS e protegido por firewall, poderá especificar parâmetros especiais na chamada start :

porta : porta do servidor HTTP. Não se esqueça de fazer NAT nesta porta no seu roteador;

 start ( MyApp , address = '0.0.0.0' , port = 8081 )

Execução autônoma

Sugiro usar o navegador como uma janela de interface padrão.

No entanto, você pode evitar usar o navegador. Isso pode ser obtido simplesmente juntando REMI e PyWebView. Aqui está um exemplo sobre este standalone_app.py.

Esteja ciente de que PyWebView usa qt, gtk e assim por diante para criar a janela. Uma versão desatualizada dessas bibliotecas pode causar problemas de interface do usuário. Se você tiver problemas de interface do usuário, atualize essas bibliotecas ou evite a execução autônoma.

Autenticação

Para limitar o acesso remoto à sua interface, você pode definir um nome de usuário e uma senha. Consiste em um processo de autenticação simples. Basta definir os parâmetros nome de usuário e senha na chamada inicial:

 start ( MyApp , username = 'myusername' , password = 'mypassword' )

Estilo

Para definir um novo estilo para seu aplicativo, você deve fazer o seguinte. Crie uma pasta res e passe-a para o construtor da classe App:

 class MyApp ( App ):
    def __init__ ( self , * args ):
        res_path = os . path . join ( os . path . dirname ( __file__ ), 'res' )
        super ( MyApp , self ). __init__ ( * args , static_file_path = { 'res' : res_path })

Copie o arquivo style.css padrão da pasta remi e cole-o na pasta res . Edite-o para personalizar. Dessa forma, o arquivo style.css padrão será substituído por aquele que você criou.

Compatibilidade

Remi foi feito para ser compatível de Python2.7 a Python3.X. Por favor, notifique problemas de compatibilidade.

Segurança

Remi deve ser concebido como uma estrutura GUI de desktop padrão. A biblioteca em si não implementa estratégias de segurança, por isso é aconselhável não expor o seu acesso a redes públicas inseguras.

Ao carregar dados de fontes externas, considere proteger o aplicativo contra possíveis injeções de javascript antes de exibir o conteúdo diretamente.

Projetos usando Remi

PySimpleGUI: lançado em 2018, desenvolvido e suportado ativamente. Suporta tkinter, Qt, WxPython, Remi (no navegador). Crie GUIs de layout personalizado de forma simples. Suporte para Python 2.7 e 3. Mais de 100 programas de demonstração e livro de receitas para início rápido. Documentação extensa.

Modelo de aplicativo para REMI: um modelo muito bem escrito para aplicativos multiview.

Reconfiguração dinâmica baseada na Web para robôs ROS

Razmq

Espresso-ARM

PiPresentes

A estrutura Python Banyan

Gerenciador de shows LightShowPi

rElectrum: Um poderoso e promissor gerenciador de carteira Electrum para transações seguras.