Como criar um programa com Auto-Update utilizando Python e Esky

Essa é a segunda parte da série de Posts Distribuir Programas em Python para Desktops Windows. Se quiser, veja o primeiro post: Como criar um executável com Instalador MSI em Python

Sempre que um programa precisa ser atualizado parece um parto. Lembre-se de todas as vezes você teve que baixar a versão atualizada do Java, lembra bem dessa raiva que você sentiu ao ter que fazer isso e imagine que seu usuário sinta a mesma raiva que você, então seja legal e faça um auto-update no seu programa para que ninguém precise baixar as versões novas. Para aprender como criar um programa com Auto-Update utilizando Python e Esky eu vou usar o aplicativo boneca criado na parte 1.

Até aqui tudo normal, o programa está feito, foi compilado mas não tem auto-update, você simplesmente gerou um instalador da boneca e nunca mais vai atualizar esse programa no cliente que o instalou, então você precisa fazer alterações e gerar um novo executável.

Bom, vamos ter que instalar um package chamado Esky:

pip install esky

Agora vamos fazer alterações no código, primeiro no script da Boneca.py precisamos importar o esky e pedir pra ele procurar por atualizações na internet quando estiverem disponíveis.

#Coloque abaixo de import win32con
import esky

if hasattr(sys,"frozen"):
    app = esky.Esky(sys.executable,"http://teenspirit.com.br/exemplo_boneca/")
    app.auto_update()

Toda vez que você iniciar o programa ele vai procurar no site se tem alguma atualização pra baixar. Ele conseguirá reconhecer pelo número da versão. Eu simplesmente deixei esse diretório (http://teenspirit.com.br/exemplo_boneca/) pra fazer listagem no Apache.

Agora vamos fazer alterações no programa, eu vou colocar outra imagem no lugar da boneca, nesse caso, usarei o chuck.jpg

chuck


#Troque o texto de boneca.jpg para chuck.jpg
os.startfile(os.path.join(os.path.realpath(os.path.dirname(sys.argv[0])),"chuck.jpg"))

 

Agora, vamos alterar o setup.py:

#setup.py
import esky.bdist_esky
from esky.bdist_esky import Executable as Executable_Esky
from cx_Freeze import setup, Executable

include_files = ['boneca.jpg','chuck.jpg']

setup(
    name = 'boneca',
    version = '1.0.1',
    options = {
        'build_exe': {
            'packages': ['os','sys','ctypes','win32con'],
            'excludes': ['tkinter','tcl','ttk'],
            'include_files': include_files,
            'include_msvcr': True,
        },
        'bdist_esky': {
            'freezer_module': 'cx_freeze',
        }
    },
    data_files = include_files,
    scripts = [
        Executable_Esky(
            "boneca.py",
            gui_only = True,
            #icon = XPTO #Coloque um icone aqui se quiser ,
            ),
    ],
    executables = [Executable('boneca.py',base='Win32GUI')]
    )

Reparem que eu mudei o número da Versão para 1.0.1, e a partir dessa versão o programa terá o auto-update. Esse arquivo ficou bem diferente, vou tentar explicar tudo que aconteceu nele:

1. Importei a opção de setup bdist_esky e um tipo de executável do próprio Esky

import esky.bdist_esky
from esky.bdist_esky import Executable as Executable_Esky

2. Coloquei as opções para o novo argumento bdist_esky:

        'bdist_esky': {
            'freezer_module': 'cx_freeze',
        }

3. Adicionei o data_files, porquê é isso que o Esky usa para ver quais arquivos também precisam ir para a pasta do programa

      data_files = include_files,

4. Coloquei o scripts porque é daí que o Esky vê quais scripts se tornaram os executáveis.

    scripts = [
        Executable_Esky(
            "boneca.py",
            gui_only = True,
            #icon = XPTO #Coloque um icone aqui se quiser ,
            ),
    ],

Agora para executar você precisa usar o setup.py com o argumento bdist_esky

python setup.py bdist_esky

Ele vai gerar um arquivo compactado que vai ficar na sua pasta dist:

boneca_esky
E dentro desse arquivo você tem isso aqui:

boneca-esky-conteudo

 

O que aconteceu? O Esky criou um programa, boneca.exe que vai ser responsável pela atualização do seu programa, inclusive dele mesmo. Quando ele for aberto ele vai buscar no endereço que eu coloquei (http://teenspirit.com.br/exemplo_boneca/) e se achar um outro arquivo compactado com uma versão mais recente ele vai baixar o arquivo e trocar o conteúdo, então na próxima vez que ele for aberto ele abrirá com a versão mais nova e limpará a versão mais antiga.

O bom é que se der algum problema no pacote, ou na internet ou na energia o Esky gerencia isso para que o programa sempre funcione. (só não pode subir uma versão bichada).

Então, quem de agora em diante for baixar o seu programa terá que baixar essa versão do Esky, que tem o arquivo zipado, aquele que geramos na Parte 1 não tem auto-update. E é por isso que vou mostrar na Parte 3 como fazer uma distribuição bem mais legal com o instalador do Inno Setup. Outra coisa que não é muito legal é que essa versão que criamos não tem o suporte ao MSVCR, mais um motivo para você ter um instalador customizado que vai incluir isso pra você.

Pra testar a atualização eu vou criar mais uma nova versão, que vou chamar de 1.0.2, nela vou trocar a foto, para isso mudo o boneca.py:

os.startfile(os.path.join(os.path.realpath(os.path.dirname(sys.argv[0])),"seu-boneco.jpg"))

e vou adicionar esse novo arquivo seu-boneco.jpg no include_files do setup.py:

include_files = ['boneca.jpg','chuck.jpg', 'seu-boneco.jpg']

Agora é só gerar o novo arquivo do Esky:

python setup.py bdist_esky

Na sua pasta dist vai aparecer o arquivo boneca-1.0.2.win32.zip. É só colocá-lo no link informado e na próxima vez que seus usuários abrirem o programa, ele será atualizado.

Se você quiser testar esse programa, faça o seguinte: baixe o boneca-1.0.1.win32.zip, descompacte o arquivo em uma pasta e abra o boneca.exe .

Quando você apertar o Print Screen ele vai mostrar a foto do Chuck, mas perceba que ele também já estará fazendo a atualização para a versão 1.0.2 e depois de fechado, na próxima vez que o programa rodar ele exibirá a foto do Seu Boneco.

seu-boneco

 

O código continua no Github.

E segura que em breve posto a Parte 3.

Como criar um executável com Instalador MSI em Python

Esse post é o primeiro da série Distribuir Programas em Python para Desktops Windows. Esse é o mais básico de todos, e esse assunto já foi bem discutido em diversos sites, mas a minha ideia aqui é apresentar como criei o programa de exemplo, mostrar como posso gerar um instalador bem simples já com as bibliotecas que o programa precisa pra rodar em outros Windows.

Toda vez que você gera um executável em Python, o windows precisa das DLLs de Runtime do C++, o tal do Microsoft Visual C++ Redistributable, você vai encontrar como MSVCR. A versão que será necessária depende de qual versão do Python você está usando.

Nós temos três coisas a fazer:

  1. Criar o script do programa
  2. Criar um arquivo de setup para gerar o executável.
  3. Gerar o Instalador MSI

Vou criar um script besta em python só pra ilustrar esses posts, isso é de uma brincadeira idiota que fiz com um amigo meu. Toda vez que o usuário apertar Print Screen o aplicativo vai abrir uma foto de uma boneca, como da foto abaixo:

baby-looking-like-his-doll

 


#boneca.py
import os
import sys
import ctypes
from ctypes import wintypes
import win32con

byref = ctypes.byref
user32 = ctypes.windll.user32

HOTKEYS = {
    1 : (win32con.VK_SNAPSHOT, 0), ####Essa Linha Pega a tecla "PRINT SCREEN"
    2 : (win32con.VK_F4, win32con.MOD_WIN)
}

def handle_win_f3 ():
    os.startfile(os.path.join(os.path.realpath(os.path.dirname(sys.argv[0])),"boneca.jpg"))

def handle_win_f4 ():
    user32.PostQuitMessage (0)

HOTKEY_ACTIONS = {
    1 : handle_win_f3,
    2 : handle_win_f4
}


# Registrando as chaves sem dar o print pra ficar escondido na tela.
for id, (vk, modifiers) in HOTKEYS.items ():
    #print "Registering id", id, "for key", vk
    pass
    if not user32.RegisterHotKey (None, id, modifiers, vk):
        #print "Unable to register id", id
        pass


# Executando as funções e tirando o registro das chaves depois do encerramento do programa.
try:
    msg = wintypes.MSG ()
    while user32.GetMessageA (byref (msg), None, 0, 0) != 0:
        if msg.message == win32con.WM_HOTKEY:
            action_to_take = HOTKEY_ACTIONS.get (msg.wParam)
            if action_to_take:
                action_to_take ()

        user32.TranslateMessage (byref (msg))
        user32.DispatchMessageA (byref (msg))

finally:
    for id in HOTKEYS.keys ():
        user32.UnregisterHotKey (None, id)

Como referência pra esse código eu usei o post do Tim Golden[1].

O código é simples, ele cria dois atalhos no windows, um é o Print Screen que quando pressionado roda a função handle_win_f3 que faz a chamada da foto da boneca.jpg

Já quando ele pressionar o atalho Win + F4 será executada a função handle_win_f4 que apenas encerra o programa. Ele não tem interface gráfica, o que faz sentido pra essa brincadeira.

Beleza, até aí só um script python fácil, agora nós precisamos fazer o Frozen dessa aplicação. Gerar um Frozen (um módulo congelado) é compilar o script e gerar um executável que contenha o interpretador python, suas bibliotecas, seu script e seus arquivos tudo em um lugar só e com um executável (ou mais executáveis). Para isso você precisa criar um arquivo de setup e escolher uma ferramenta para fazer o frozen, os mais usados são py2exe, py2app, cx_freeze, e o pyinstaller. Nesse caso eu vou usar o cx_freeze. Esse arquivo por convenção é chamado de setup.py e


#setup.py
from cx_Freeze import setup, Executable

setup(
    name = "boneca",
    version = "1.0.0",
    options = {"build_exe": {
        'packages': ["os","sys","ctypes","win32con"],
        'include_files': ['boneca.jpg'],
        'include_msvcr': True,
    }},
    executables = [Executable("boneca.py",base="Win32GUI")]
    )

O script também é simples, ele segue a mesma lógica do disutils , só quero chamar atenção para o include_msvcr que vai colocar as DLLs do Microsoft Visual C++ Redistributable no seu executável, dessa forma ele vai copiar as DLLs que já existem no seu sistema operacional. Esse é o único jeito do seu programa funcionar em outros windows, pois o Python precisa dessas dlls para ser executado. Você também pode baixar o próprio instalador do MSVCR da Microsoft e incorporar no seu instalador usando o Inno Setup, por exemplo, vou mostrar isso em um dos próximos posts da série.

Agora vamos gerar um MSI, ou seja, um instalador para windows. Só rodar na linha de comando:

python setup.py bdist_msi

Beleza, agora ele criou uma pasta chamada dist com um arquivo boneca-1.0.0-win32.msi (ou boneca-1.0.0-amd64.msi se seu sistema for 64) agora já dá pra instalar e usar. Então aqui mostrei Como criar um executável com Instalador MSI em Python e com Cx_freeze.

Os scripts estão no meu Github: https://github.com/ffreitasalves/boneca

[1]: http://timgolden.me.uk/python/win32_how_do_i/catch_system_wide_hotkeys.html

Distribuir Programas em Python para Desktops Windows

Comecei a escrever um post sobre como criar um programa com auto-update em Python e como vi que tinha muito assunto pra falar eu resolvi escrever 3 posts, em cada um vou tratar de um assunto mas o objetivo final é conseguir criar um executável em Python com auto-update e que tenha um instalador.

Então os posts estão divididos em 3 partes:

  1. Como criar um executável com Instalador MSI com Python e Cx_freeze
  2. Como criar um programa com Auto-Update utilizando Python e Esky
  3. Como criar um instalador MSI utilizando o Inno Setup

Durante esses 3 posts vou criar um programa bem simples (chamado boneca), mostrar como eu posso criar o instalador pelo próprio Cx_freeze, depois mostrar como posso criar o auto-update utilizando o Esky e por fim mostrar como posso usar o Inno Setup pra criar um instalador mais robusto e mais personalizado.

No final você poderá distribuir programas em python para desktops windows sem nenhum problema.

Muitas pessoas pensam que o Python serve só para fazer scripts e que não pode ser compilado e shipado. Mas não é bem assim, python também pode ser compilado e você pode distribuir software python sem o código-fonte.

Um grande exemplo disso é o Dropbox. O cliente do Dropbox foi escrito em Python para ser portável para Windows, Mac e Linux e a única diferença é que para Windows e Linux ele roda o wxPython no UI e no Mac ele usa Python-ObjC. As próprias palavras do Guido Van Rossum são muito legais falando sobre isso:

 

“Python plays an important role in Dropbox’s success: the Dropbox client, which runs on Windows, Mac and Linux (!), is written in Python. This is key to the portability: everything except the UI is cross-platform. (The UI uses a Python-ObjC bridge on Mac, and wxPython on the other platforms.) Performance has never been a problem — understanding that a small number of critical pieces were written in C, including a custom memory allocator used for a certain type of objects whose pattern of allocation involves allocating 100,000s of them and then releasing all but a few. Before you jump in to open up the Dropbox distro and learn all about how it works, beware that the source code is not included and the bytecode is obfuscated. Drew’s no fool. And he laughs at the poor competitors who are using Java.”

O texto original dele é esse aqui!