<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Wilson Martins on Medium]]></title>
        <description><![CDATA[Stories by Wilson Martins on Medium]]></description>
        <link>https://medium.com/@wilfilho?source=rss-71b7ac064dab------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*7N5QwI5mAWxUfMDkeTRhrg.jpeg</url>
            <title>Stories by Wilson Martins on Medium</title>
            <link>https://medium.com/@wilfilho?source=rss-71b7ac064dab------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 13:41:58 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@wilfilho/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Continuous Delivery com Fastlane e Android]]></title>
            <link>https://medium.com/android-dev-br/continuous-delivery-com-fastlane-e-android-6ccc8f12a336?source=rss-71b7ac064dab------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ccc8f12a336</guid>
            <category><![CDATA[fastlane]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[continuous-delivery]]></category>
            <category><![CDATA[automation]]></category>
            <dc:creator><![CDATA[Wilson Martins]]></dc:creator>
            <pubDate>Sat, 23 May 2020 01:19:12 GMT</pubDate>
            <atom:updated>2020-08-20T10:56:02.435Z</atom:updated>
            <content:encoded><![CDATA[<h4>Uma introdução sobre como a Fastlane pode ser útil em projetos Android</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*clK6pn73fpNukIoVSHUiWQ.jpeg" /><figcaption>Robôs autônomos da Amazon.</figcaption></figure><p>A medida que o <em>software</em> passou a ser mais importante na vida das pessoas e empresas, foi requerido cada vez que os desenvolvedores pudessem disponibilizá-lo o mais constante e rápido possível.</p><p>Muitas vezes durante o desenvolvimento de um projeto é necessário disponibilizar o entregável, ou seja o produto, para os mais variados tipos de pessoas: testadores, <em>stakeholders</em>, clientes finais, etc. Porém, mais importante aqui(no nosso contexto), é a necessidade de fazer isso várias vezes ao dia ou várias vezes na semana.</p><p>Independente de qual <em>stack</em> você atue, fazer esse processo manualmente sempre será um trabalho repetitivo e que obviamente consumirá o seu tempo, e isso provavelmente impactará na sua produtividade. Além do tempo gasto, provavelmente você não é a única pessoa no projeto em que trabalha e sendo assim, outras pessoas necessitarão fazer essas entregas também.</p><p>Consegue perceber como todo esse processo de várias pessoas entregando <em>software</em> várias vezes ao dia com várias versões diferentes e tentando fazer o mais rápido possível é um tanto complexo de entender e gerenciar? É realmente difícil garantir a qualidade e agilidade dessas entregas nesse cenário.</p><h3>Aqui entra o Continuous Delivery…</h3><p>Dentro desse contexto “caótico” surge o conceito de <em>Continuous Delivery</em>, ou traduzindo para o português <em>Entrega Contínua</em>. Esse termo se caracteriza exatamente pela prática de disponibilizar todos os tipos de alterações de forma rápida, segura e estável.</p><blockquote>Ao mencionar “todos tipos de alterações” me refiro a: correção de bugs, novas funcionalidades, mudanças em configurações, etc.</blockquote><p>Essa prática, por sua vez, nos fornece um conjunto de princípios que nos norteiam quanto a fazer entregas mais consistentes e eficientes. Segue abaixo a lista de princípios:</p><ul><li><strong>Builds de qualidade:</strong> esse princípio passa pela necessidade de serem realizados testes antes mesmo que as <em>builds</em> sejam disponibilizadas para uso. Isso garante a rapidez na detecção de <em>bugs</em> além de deixar o entregável menos suscetível a comportamentos inesperados para quem os usa.</li><li><strong>Poucas mudanças:</strong> trabalhar com pequenas alterações entre as versões caracteriza um dos princípios do <em>CD</em> pelo fato de que é muito mais fácil de descobrir onde estão os problemas e corrigi-los. Além claro, de poder receber <em>feedbacks</em> mais rápidos.</li><li><strong>O trabalho repetitivo fica para as máquinas:</strong> automatizar processos repetitivos nos ajuda a ganhar um tempo precioso, além claro de ser uma preocupação a menos. Dentro da entrega de <em>software</em> isso é útil pois nos possibilita manter a rapidez e estabilidade entre as diversas entregas que precisamos fazer.</li><li><strong>Melhoria contínua: </strong>o <em>software</em> muda rapidamente e todas as mudanças requerem pequenos ajustes. É necessário sempre reavaliar o processo para que as melhorias possam surgir e continuem a impulsionar o projeto.</li><li><strong>A responsabilidade é de todo mundo:</strong> no nosso mundo de devs somos todos inteiramente responsáveis pela qualidade das builds e estabilidade do <em>software</em> que estamos trabalhando. Ou seja, não existe: “esse <em>bug</em> não foi eu quem criei”.</li></ul><p>Como podemos notar, são princípios interessantes que enfatizam boas práticas durante a entrega de <em>software</em>, não podendo deixar de mencionar os diversos benefícios que isso traz para o nosso processo como um todo, sendo estes: menos riscos para disponibilizar o produto, uma melhora considerável na qualidade do entregável, etc.</p><p>Enfim, os benefícios para o nosso processo de desenvolvimento de <em>software</em> são os mais variados possíveis. Porém como isso tudo se relaciona ao <a href="https://fastlane.tools/">Fastlane</a>? E ainda mais, o que o <em>Android </em>tem a ver com isso?</p><h3>O papel da Fastlane</h3><p>Bom dentro do cenário que estamos descrevendo, a <em>Fastlane </em>entra como uma peça fundamental que nos ajudará a colocar tudo isso em prática, pois o propósito dela é justamente esse: <strong>ser uma ferramenta que nos ajude a automatizar o processo de deploy em aplicações <em>Android</em> e <em>iOS.</em></strong></p><blockquote><em>Sim, a </em>Fastlane<em> é uma ferramenta de </em>Continuous Delivery<em> focada no mundo </em>mobile<em>.</em></blockquote><p>Nós, enquanto desenvolvedores <em>mobile</em>, sabemos devidamente os diversos passos que temos que fazer para lançar uma aplicação para teste e até mesmo na loja. Entre essas etapas muitas das vezes temos que: tirar screenshots do app, alterar versão do app, alterar ícone de acordo com o tipo de <em>build</em>, avisar aos colegas no <em>Slack</em> que tem <em>build</em> nova, etc. São muitos passos que se fôssemos fazer manualmente daria um trabalho gigantesco todas as vezes.</p><p>Porém, como já sabemos, o <em>Fastlane</em> está aí para nos ajudar nisso. Dessa forma, uma das suas principais características que nos permite fazer os passos descritos anteriormente e muito mais, é sua grande quantidade de integrações e plugins. Caso queira saber quais plugins o <em>Fastlane</em> disponibiliza, basta <a href="https://docs.fastlane.tools/plugins/available-plugins/">abrir este link</a>.</p><p>Lembra que nos perguntamos como o <strong><em>Android</em></strong> se encaixaria nisso? Pois bem, nesse post vamos aprender um pouco como podemos utilizar a <em>Fastlane</em> para praticar a entrega contínua em projetos [Android] nativos.</p><h4>Instalando a Fastlane em um projeto Android</h4><p>O primeiro passo antes mesmo de colocarmos a Fastlane em um projeto Android é instalá-la na nossa máquina, uma vez que essa é uma ferramenta utilizada via linha de comando.</p><p>O pré-requisito para fazer essa instalação é possuir o xcode-tools instalado, pois até a última vez em que esse post foi editado a <em>Fastlane </em>oferecia suporte oficial apenas ao <em>macOS</em>. Caso deseje ler mais sobre, poderá encontrar informações <a href="https://github.com/fastlane/fastlane/issues/11687">neste link</a>. Tendo esse requisito pronto, podemos começar executando o seguinte comando:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e6028fbdcd037c3a21a33603f738fa10/href">https://medium.com/media/e6028fbdcd037c3a21a33603f738fa10/href</a></iframe><p>Após rodar o comando anterior, finalmente, vamos instalar a <em>Fastlane</em>. Você poderá escolher entre as duas opções abaixo, ambas produzirão o mesmo resultado. Segue as alternativas de comando para instalar a ferramenta:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a4edf8d81a0f5d33972cfcb98a7bb120/href">https://medium.com/media/a4edf8d81a0f5d33972cfcb98a7bb120/href</a></iframe><p>Caso prefira instalar via <a href="https://brew.sh/index_pt-br"><em>howebrew</em></a>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f6a655ec0499fc6f52481e0afcabecb8/href">https://medium.com/media/f6a655ec0499fc6f52481e0afcabecb8/href</a></iframe><p>Por fim, vamos rodar o comando para colocar o <em>Fastlane</em> dentro do nosso projeto <em>Android</em>. Uma coisa que vale ressaltar antes de executá-lo é que você deverá entrar no seu projeto, ou seja, o comando deverá ser executado no diretório onde fica os módulos do seu projeto <em>Android</em>. Resumindo: você precisa estar na raiz do projeto. Segue abaixo o comando:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2b4a9554da8cb7582453c8572fd6494a/href">https://medium.com/media/2b4a9554da8cb7582453c8572fd6494a/href</a></iframe><p>O resultado do comando acima será a instalação e configuração de algumas dependências <em>default</em> da <em>Fastlane</em>. Você também irá se deparar com 3 perguntas, são elas:</p><ul><li><strong>Primeira pergunta</strong>: perguntará qual é o namespace do seu projeto. A resposta, sendo assim, é óbvia. Você deverá colocar o <em>package name</em> do seu projeto <em>Android</em>. Segue abaixo um exemplo:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/995/1*jNz2V-R0k5kAY0Aih8wA2g.png" /></figure><ul><li><strong>Segunda pergunta: </strong>perguntará onde está o arquivo em json que possui uma chave de acesso às APIs da Google. Por agora, não vamos nos preocupar com isso e sua resposta deverá ser apenas um <strong>[enter]</strong>;</li><li><strong>Terceira pergunta</strong>: perguntará se deseja baixar os metadados já salvos dentro da pasta <em>Fastlane</em>. Apenas digite <strong><em>n</em></strong> e pressione <strong>[enter]</strong>;</li></ul><h3>Entendendo a Fastlane</h3><p>Ao executar o último comando citado perceberemos que uma pasta com o nome F<em>astlane</em> foi criada, mas além disso, dentro dela, outros arquivos foram criados. Cada um deles possuem funções importantes para a ferramenta, sendo assim, segue abaixo a utilidade de cada um:</p><ul><li><strong>Fastfile: </strong>local onde definimos todos os comandos e passos que a Fastlane em nosso projeto executará. Por exemplo, é lá que iremos dizer que nós queremos tirar <em>screenshots</em> do nosso <em>app</em>, que queremos executar os testes, que queremos buildar com determinado <em>build type</em>, etc.</li><li><strong>Appfile: </strong>local onde fica todas as configurações globais do nosso app Android;</li></ul><h4>Sintaxe no Fastfile</h4><p>Como já mencionado, no arquivo <em>Fastfile</em> ficarão todos os passos que poderão ser executados no nosso projeto através da <em>Fastlane</em>. Trazendo para o nosso contexto, quando falamos em criar &quot;passos&quot; estamos nos referindo a criar &quot;<em>lanes</em>&quot;. Este é o termo mais correto a ser utilizado.</p><p>A <em>Fastlane</em> é uma ferramenta escrita em <em>Ruby</em>, sendo assim, muito da sintaxe que usaremos dentro do <em>Fastfile</em> será bastante similar com essa sintaxe. Para entendermos sobre ela, iremos utilizar o código fornecido inicialmente no arquivo <em>Fastfile</em>. Sendo assim, código presente no seu arquivo se parecerá com algo assim:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6f2e8d042b895a4cf6b241fd66b27f12/href">https://medium.com/media/6f2e8d042b895a4cf6b241fd66b27f12/href</a></iframe><p>Ao olhar o código acima é possível, rapidamente, ver um certo padrão e realmente existe. Sempre que formos criar uma <em>lane</em> devemos primeiramente fornecer uma descrição. Sendo assim, usa-se a <em>keyword</em> <strong><em>desc</em></strong>, como é possível ver nas linhas 4, 9 e 18.</p><p>Para definir o bloco de código de uma <em>lane</em>, ou seja, tudo que ela pode fazer devemos fazer da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bcef0abf3c9353f9c5730f70279f5b9a/href">https://medium.com/media/bcef0abf3c9353f9c5730f70279f5b9a/href</a></iframe><p>É possível também criar <em>lanes </em>privadas. Para fazer isso basta substituir a <em>keyword</em> <em>lane </em>por <strong><em>private_lane</em></strong>. Exemplo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/88023939986fcd7cde353bc579935060/href">https://medium.com/media/88023939986fcd7cde353bc579935060/href</a></iframe><h4>Executando uma <em>lane</em></h4><p>Executar uma <em>lane</em> é bastante simples, basta rodar o comando no terminal:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a3d4914324846a35f5ae3b7e4e9a59ec/href">https://medium.com/media/a3d4914324846a35f5ae3b7e4e9a59ec/href</a></iframe><p>Todas as <em>lanes</em> declaradas no arquivo <em>Fastfile</em> estão disponíveis nesse comando. Sendo assim, utilizando o código que já está lá, podemos executar por exemplo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/de7ef6daab0f9b2319e5d7dd5839d2f1/href">https://medium.com/media/de7ef6daab0f9b2319e5d7dd5839d2f1/href</a></iframe><p>Caso tenha dado tudo certo, aparecerá um resultado similar ao da imagem abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/916/1*esgLArhvmaXWvMLc3Q8-jg.png" /></figure><h4>Executando uma lane a partir de outra</h4><p>Chamar uma <em>lane</em> a partir de outra acontece da mesma forma que chamamos uma função a partir de outra no código normal. Por exemplo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d7847a506c55de4c747ab456660c2108/href">https://medium.com/media/d7847a506c55de4c747ab456660c2108/href</a></iframe><p>Ao executar <strong><em>fastlane test_print</em></strong> veremos a mensagem impressa entre as outras mensagens que a <em>Fastlane </em>também exibe. Algo importante a ressaltar é que: quando uma função declarada em Ruby não possui parâmetro é possível chamá-la omitindo os parênteses. Por isso podemos escrever apenas <strong>print_msg </strong>para<strong> </strong>invocá-la.</p><h4>Passando parâmetros para uma lane</h4><p>Podemos incrementar o exemplo acima e ao invés de exibirmos uma mensagem pré-definida exibiremos qualquer mensagem que desejarmos. Para isso é preciso que na assinatura da <em>lane</em>, que desejamos receber o parâmetro, adicionemos o trecho|options|.</p><p>Utilizando o exemplo anterior, ficaria da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4c503a058d5c23f5b86024a41cef4653/href">https://medium.com/media/4c503a058d5c23f5b86024a41cef4653/href</a></iframe><p>Além da adição na assinatura da <em>lane</em>, também é necessário &quot;nomear&quot; os parâmetros. Na realidade, como já mencionado, a <em>Fastlane</em> utiliza a linguagem Ruby e nela existe um tipo chamado <em>hash</em>. Esse tipo nada mais é do “equivalente” um <em>Hash</em> que nós possuímos no Java/Kotlin, também é equivalente aos dicionários no Python. Dessa forma, a <em>Fastlane</em> só permite que sejam passados parâmetros de uma lane para outra através desse tipo.</p><p>Também é possível chamar uma lane e passar parâmetros a partir do terminal. Segue o exemplo abaixo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fea76871608f5e7e556d05c89b10a2df/href">https://medium.com/media/fea76871608f5e7e556d05c89b10a2df/href</a></iframe><h4>&quot;Ciclo de vida&quot; de uma <em>lane</em></h4><p>Basicamente, o ciclo de vida de uma <em>lane</em> se resume a: momento anterior a execução, momento da execução e posterior a execução. Em relação ao momento anterior a execução possuímos dois &quot;eventos&quot; que são chamados automaticamente, porém com condições diferentes. São eles:</p><ul><li><strong>before_all</strong></li><li><strong>before_each</strong></li></ul><p>A diferença entre eles é clara: o primeiro é chamado uma única vez antes da execução de qualquer <em>lane</em>, já o segundo é chamado antes de cada execução. Segue abaixo um exemplo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d67913dd239fb6fb38aa8c75b2f9f2e3/href">https://medium.com/media/d67913dd239fb6fb38aa8c75b2f9f2e3/href</a></iframe><p>Eventos similares também existe para a pós-execução, sendo elas respectivamente: <strong>after_all</strong> e <strong>after_each</strong>.</p><h4><strong>Identificando erros</strong></h4><p>Como o mundo não é perfeito e nem sempre as coisas dão certo, é bem provável que durante a execução de uma lane ocorra algum erro inesperado e seja preciso interromper a execução dela. Saber se a <em>lane</em> deu erro é um <em>feedback</em> muito importante para nós. Isso serve por exemplo para quando automatizarmos o <em>build</em> de Android e por algum motivo durante a execução da lane ela falha, ao saber que falhou podemos enviar uma mensagem para o Telegram ou Slack.</p><p>O &quot;evento&quot; responsável por nos dá essa informação é o <strong>error</strong>. Segue abaixo um exemplo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/347be52119eb2fb18be40120ff8a175b/href">https://medium.com/media/347be52119eb2fb18be40120ff8a175b/href</a></iframe><blockquote><strong>OBS</strong>: caso não tenha conseguido ver a mensagem &quot;Lane crashed&quot; à primeira vista devido ao volume de texto que a Fastlane mostra junto com o erro, basta olhar logo abaixo das mensagens destacadas na cor verde.</blockquote><h3>Automatizando processo de deploy no Android</h3><p>Bom, agora que sabemos o básico da <em>Fastlane</em> podemos brincar um pouco com exemplos que são utilizados no mundo real. Um dos mais recorrentes desses exemplos é a automatização no <em>deploy</em>. O que faremos será o seguinte:</p><ul><li>Rodar os testes do nosso projeto</li><li>Buildar nosso projeto em <em>release</em></li><li>Fazer <em>upload</em> do <em>apk</em> na loja do Android</li><li>Exibir mensagem no Slack que deu sucesso(ou talvez <em>falha</em>)</li></ul><p>Todas essas etapas serão automatizadas com o <em>Fastlane</em> e faremos isso tudo, ao final, executando apenas um comando: <strong>fastlane deploy</strong>.</p><h4>Criando lane e rodando testes</h4><p>Essa etapa é a mais simples dentre as descritas pelo fato de já termos visto antes. Sendo assim, nosso <em>Fastfile</em> ficará inicialmente assim:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/93588e2de992a9cd259518e53c318dbd/href">https://medium.com/media/93588e2de992a9cd259518e53c318dbd/href</a></iframe><h4>Compilando projeto em release</h4><p>A próxima etapa será gerar uma apk no modo <em>release</em> para que nós consigamos fazer <em>upload</em> dela na Google Play. Sendo assim, o <em>Fastfile</em> será atualizado para o código abaixo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/92c4774cb5bbf7d7995dc30a07cbab8b/href">https://medium.com/media/92c4774cb5bbf7d7995dc30a07cbab8b/href</a></iframe><h4>Integrando Fastlane à Google Play</h4><p>Agora que já estamos compilando e gerando uma <em>apk</em> que possa ser colocada na Google Play, vamos configurar a F<em>astlane</em> para que ela suba a <em>apk</em> automaticamente ao rodar a <em>lane</em>. Esse é um passo simples, porém poderá dar um pouco de trabalho.</p><p>A action que usaremos e que é recomendada pela F<em>astlane</em> é a <a href="https://docs.fastlane.tools/actions/supply/">supply</a>. Para utilizá-la é preciso recuperar um json de acesso nossa conta da Google. Isso é importante pois ela usa a API da Google Play para fazer o <em>upload</em> automaticamente. Sendo assim, segue os passos abaixo:</p><ul><li>Vá até a <a href="https://play.google.com/apps/publish/">Google Play Console</a>.</li><li>Ao chegar lá, clique em <em>Configurações</em>.</li><li>No menu lateral, selecione <em>Acesso à API</em>.</li><li>Após entrar no item anterior, clique em <em>Criar uma conta de serviço</em>.</li></ul><p>Ao clicar no botão sugerido anteriormente, você provavelmente verá o seguinte <em>dialog</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/614/1*szQMYCH08fsTIpo2qX2bPA.png" /></figure><p>Basta seguir os passos que são demonstrados pela Google e ao final baixar o <em>json</em> de acesso. Lembra que nós ignoramos a segunda pergunta que falava de um tal <em>json, </em>lá quando estávamos configurando a <em>Fastlane</em>? Pois bem, vamos voltar nisso agora.</p><p>O que precisamos fazer é dizer à <em>Fastlane</em> onde que está esse arquivo <em>json</em> que acabamos de baixar. A título de exemplo, vamos colocá-lo dentro da pasta do nosso projeto Android e chamá-lo de <em>app-key.json. </em>Por exemplo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6zFeGTH5q8xz6V7HvHWFMw.png" /></figure><p>Bom, o que devemos fazer agora é bem simples. Basta abrir o arquivo <em>Appfile</em> que está dentro da pasta <em>Fastlane </em>e substituir a primeira linha pela linha a seguir:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6df142bd93d6d30c037fd571b319b878/href">https://medium.com/media/6df142bd93d6d30c037fd571b319b878/href</a></iframe><p>Outra coisa que precisamos fazer nesse arquivo <em>Appfile</em> é verificar se está com o <em>package_name</em> correto. Ou seja, se o <em>package_name</em> que estamos referenciando corresponde à um app presente no nosso Google Play Console. Por exemplo, para este post estou usando um app com o pacote <em>com.wilson.fastlaneexample</em>. Segue abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/766/1*BjKxOLd9Aur82aD2eIAXng.png" /></figure><p>Sendo assim, o meu arquivo <em>Appfile</em> está da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/845838241985bfb01fb5b072dc6e0552/href">https://medium.com/media/845838241985bfb01fb5b072dc6e0552/href</a></iframe><p>Por fim, precisamos apenas rodar o comando abaixo para que a <em>Fastlane</em> baixe todos os dados do nosso <em>app</em>, tais como: <em>screenshoots</em>, nome, descrição, etc.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7e20499d17c331080678966be8940575/href">https://medium.com/media/7e20499d17c331080678966be8940575/href</a></iframe><h4>Fazendo upload automático do APK</h4><p>Agora que temos tudo configurando, precisamos apenas adicionar uma linha ao nosso <em>Fastfile</em>, que será o comando para fazer <em>upload</em> do <em>APK</em>. Ficará da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9a51e54a91ed4f67007415e09781cd9b/href">https://medium.com/media/9a51e54a91ed4f67007415e09781cd9b/href</a></iframe><p>O que fizemos acima foi apenas adicionar: <strong>upload_to_play_store</strong><em>. </em>Após isso precisamos apenas rodar nossa <em>lane</em> novamente para a <em>Fastlane</em> fazer <em>upload</em> do nosso APK para a <em>Faixa de Produção</em> no <em>Google Play Console</em>. Você perceberá algo similar à imagem abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/991/1*0Xzt0u3R_IVga9Xju5_4gg.png" /></figure><p>É possível também mudar a faixa que você deseja para fazer o <em>upload</em> da <em>APK</em>. Por exemplo, caso quiséssemos preparar a <em>APK</em> para disponibilizar aos usuários <strong><em>beta</em></strong>, faríamos a seguinte mudança:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/53eb5151e5ae2a6e90500c00e6f88fec/href">https://medium.com/media/53eb5151e5ae2a6e90500c00e6f88fec/href</a></iframe><p>Para saber mais sobre todas as customizações que você pode fazer, basta seguir a documentação: <a href="https://docs.fastlane.tools/actions/supply/">https://docs.fastlane.tools/actions/supply/</a>.</p><h4>Integrando Fastlane ao Slack</h4><p>Por fim, vamos aprender como fazer uma integração ao <em>Slack </em>para nos informar se o <em>APK</em> foi upado com sucesso ou deu algum problema durante esse processo<em>. </em>Essa é uma integração bem simples. A primeira coisa que devemos ter em mão é o <em>webhook</em> do seu canal no <em>Slack</em>.</p><p>Com o <em>webhook</em> em mãos, utilizaremos aquele &quot;evento&quot; que descrevemos mais acima, o <strong><em>before_all </em></strong>e<strong><em> error</em></strong><em>.</em> O que queremos aqui é setar o nosso <em>webhook</em> antes de executar qualquer <em>lane</em>. Em relação ao <strong><em>error</em></strong>, queremos enviar para o <em>Slack</em> uma mensagem diferente da mensagem de sucesso. Sendo assim, nosso <em>Fastfile</em> ficará da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/55801dffcdce5a71c738f7ec3c12a680/href">https://medium.com/media/55801dffcdce5a71c738f7ec3c12a680/href</a></iframe><p>Por padrão ao chamar o <strong><em>Slack</em></strong> o parâmetro <em>success</em> é definido como <em>true</em>. Sendo assim, para informarmos que deu erro precisamos setar ele como <em>false</em>. Para finalizar podemos rodar novamente a <em>lane</em> de <strong><em>deploy</em></strong> e poderemos ver as mensagens de erro ou sucesso, como segue a imagem abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/636/1*hNZOCxV3pRvVp_feb3PXzw.png" /></figure><h4>Problemas que você pode ter</h4><p>Ao tentar fazer upload automaticamente do <em>APK</em> a Fastlane pode te apresentar alguns erros. Sendo assim, segue a lista com alguns deles e suas possíveis soluções:</p><ul><li><strong>#1 — <em>Only releases with status draft may be created on draft app:</em> </strong>Significa que no seu projeto lá na Google Play Console ainda não foi lançado nenhum <em>APK</em> para a loja, sendo assim você não pode fazer <em>upload</em> de um <em>APK</em> com o <em>release_status</em> de <em>completed</em>, que é o <em>default</em> utilizado pela <em>Fastlane</em>. Para resolver isso basta alterá-lo para <strong><em>draft. </em></strong>Ficaria assim:</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/348b16b4c3cb342a11da4145f1bef738/href">https://medium.com/media/348b16b4c3cb342a11da4145f1bef738/href</a></iframe><ul><li><strong>#2 — Não consigo subir o primeiro APK <em>de todos</em> na Google Play automaticamente:</strong> Vamos supor que você acabou de criar o projeto na Google Play Console e quer upar o primeiro <em>APK</em> dele automaticamente. <strong>Isso não é possível</strong>, pois como nunca nenhum <em>APK</em> foi upado nesse projeto então ele não possui um <em>package name</em> associado. Sendo assim, quando a Fastlane tentar dar <em>match</em> em algum dos <em>apps</em> na Google Play Console não conseguirá encontrar nenhum. Ou seja, o primeiro APK de todos deve ser upado na mão, os posteriores podem ser upados automaticamente.</li></ul><h4>Concluindo</h4><p>Embora tenha sido um post um tanto longo, o objetivo era que este fosse um apanhado geral sobre a <em>Fastlane</em>, não apenas dando o código pronto mas também explicado alguns porquês importantes. Para explorar mais essa ferramenta incrível sugiro que entre em sua <a href="https://docs.fastlane.tools/getting-started/android/setup/">documentação oficial</a>.</p><p>Espero que tenha aproveitado a leitura, até mais.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ccc8f12a336" width="1" height="1" alt=""><hr><p><a href="https://medium.com/android-dev-br/continuous-delivery-com-fastlane-e-android-6ccc8f12a336">Continuous Delivery com Fastlane e Android</a> was originally published in <a href="https://medium.com/android-dev-br">Android Dev BR</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Porque os desenvolvedores Python devem usar o Pipenv]]></title>
            <link>https://medium.com/@wilfilho/porque-os-desenvolvedores-python-devem-usar-o-pipenv-ae3d3154c44?source=rss-71b7ac064dab------2</link>
            <guid isPermaLink="false">https://medium.com/p/ae3d3154c44</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[best-practices]]></category>
            <category><![CDATA[pipenv]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[pip]]></category>
            <dc:creator><![CDATA[Wilson Martins]]></dc:creator>
            <pubDate>Sun, 22 Jul 2018 23:06:13 GMT</pubDate>
            <atom:updated>2018-07-30T23:58:40.500Z</atom:updated>
            <content:encoded><![CDATA[<h4>Com apenas um ano de existência, o Pipenv se tornou o recurso oficial a ser utilizado para o gerenciamento de dependências no Python.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fk44CpP60z8ykftWcLA4SA.jpeg" /></figure><p>O Pipenv, o “Workflow de Desenvolvimento em Python para Humanos” criado por Kenneth Reitz há pouco mais de um ano, tornou-se o recurso oficial recomendado para gerenciar dependências no Python. Mas ainda há confusão sobre quais problemas ele resolve e como ele é mais útil do que o workflow padrão padrão de trabalho usando o pip e um arquivo <em>requirements.txt</em>. Na coluna Python deste mês, responderemos estas questões.</p><h3>Uma breve história da instalação de dependências no Python</h3><p>Para entender os problemas que o Pipenv resolve, é útil mostrar como o gerenciamento de dependências do Python evoluiu.</p><p>Volte para os primórdios do Python. Tínhamos o Python, mas não havia uma maneira limpa de instalar pacotes.</p><p>Depois veio o <strong><em>easy_install</em></strong>, um pacote que instala outros pacotes do Python com relativa facilidade. Mas veio com uma pegadinha: não era fácil desinstalar pacotes que não eram mais necessários.</p><p>Digite <strong><em>pip</em></strong>, com o qual a maioria dos usuários do Python estão familiarizados. O <strong><em>pip</em></strong> nos permite instalar e desinstalar pacotes. Poderíamos especificar versões, executando <strong><em>pip freeze&gt; requirements.txt</em></strong> para produzir uma lista de pacotes instalados, em um arquivo de texto, e usar o mesmo arquivo de texto para instalar tudo o que uma aplicação precisa com o <strong><em>pip install -r requirements.txt</em></strong>.</p><p>Mas o pip não incluiu uma maneira de isolar os pacotes uns dos outros. Podemos trabalhar em aplicações que usam diferentes versões das mesmas bibliotecas, então precisamos de uma maneira de gerenciar isso. Junto vieram os ambientes virtuais, que nos permitiram criar ambientes pequenos e isolados para cada aplicação em que trabalhamos. Vimos surgir muitas ferramentas para gerenciar ambientes virtuais: virtualenv, venv, virtualenvwrapper, pyenv, pyenv-virtualenv, pyenv-virtualenvwrapper e muito mais. Todas elas trabalham bem com arquivos <strong><em>pip</em></strong> e <strong><em>requirements.txt</em></strong>.</p><h3>O novo garoto: Pipenv</h3><p><em>O Pipenv visa resolver vários problemas.</em></p><p>Primeiro, o problema é precisar da biblioteca pip para a instalação de pacotes, além de uma biblioteca para criar um ambiente virtual, além de uma biblioteca para gerenciar ambientes virtuais, além de todos os comandos associados a essas bibliotecas. Isso é muito para gerenciar. O Pipenv vem com suporte ao gerenciamento de pacotes e ambiente virtual, para que você possa usar uma única ferramenta para instalar, desinstalar, rastrear e documentar suas dependências e criar, usar e organizar seus ambientes virtuais. Quando você inicia um projeto com ele, o Pipenv cria automaticamente um ambiente virtual para esse projeto, se você ainda não estiver usando um.</p><p>O Pipenv realiza esse gerenciamento de dependência abandonando o <em>requirements.txt</em> e trocando-o por um novo documento chamado <strong><em>Pipfile</em></strong>. Quando você instala uma biblioteca com o Pipenv, o <strong><em>Pipfile</em></strong> do seu projeto é atualizado automaticamente com os detalhes dessa instalação, incluindo informações de versão e, possivelmente, o local do repositório Git, o caminho do arquivo e outras informações.</p><p>Em segundo lugar, o Pipenv quer facilitar o gerenciamento de interdependências complexas. Sua aplicação pode depender de uma versão específica de uma biblioteca, e essa biblioteca pode depender de uma versão específica de outra biblioteca, e são apenas dependências e pedras por todo o caminho. Quando duas bibliotecas que sua aplicação usa têm dependências conflitantes, sua vida pode se tornar difícil. O Pipenv quer aliviar essa dor mantendo o controle da árvore de interdependências da sua aplicação em um arquivo chamado <strong>Pipfile.lock</strong>. O <strong>pipfile.lock</strong> também verifica se as versões corretas das dependências são usadas em produção.</p><p>Além disso, o Pipenv é útil quando vários desenvolvedores estão trabalhando em um projeto. Com um workflow utilizando o <em>pip</em>, João pode instalar uma biblioteca e passar dois dias implementando um novo recurso usando essa biblioteca. Quando João confirmar as alterações, ele pode esquecer de atualizar as listas de dependências do <em>pip</em>. No dia seguinte, Maria puxa as mudanças de João, e de repente os testes estão falhando. Leva um tempo para perceber que o problema é a falta da biblioteca que não foi colocada por João no requirements.txt e que, consequentemente, Maria não instalou no seu ambiente virtual.</p><p>Como o Pipenv auto-documenta as dependências à medida que você as instala, se Maria e João estivessem usando o Pipenv, o <strong>Pipfile</strong> teria sido atualizado automaticamente e incluído no commit do João. Maria e João teriam economizado tempo e enviariam seus produtos mais rapidamente.</p><p>Finalmente, o uso do Pipenv sinaliza para as outras pessoas que estão trabalhando no seu projeto que ele vem com uma maneira padronizada de instalar dependências e requisitos de desenvolvimento e teste. Usar um workflow com arquivos pip e requirements.txt significa que você pode ter um único arquivo requirements.txt ou vários arquivos de requisitos para diferentes ambientes. Pode não estar claro para os seus colegas que eles devem executar o dev.txt ou o local.txt quando estiverem executando o projeto em seus laptops, por exemplo. Pode haver uma confusão quando dois arquivos de requisitos estiverem fora de sincronia. É o <em>local.txt </em>que está desatualizado<em>, </em>ou o <em>dev.txt</em> que está supostamente diferente? Vários arquivos de requisitos exigem mais contexto e documentação para permitir que os outros(desenvolvedores) instalem as dependências adequadamente e conforme o esperado. Esse fluxo de trabalho tem o potencial de confundir colegas e aumentar sua carga de manutenção.</p><p>O uso do Pipenv, que fornece o Pipfile, permite evitar esses problemas, gerenciando dependências para diferentes ambientes. Este comando irá instalar as principais dependências do projeto:</p><pre><strong>$ pipenv install</strong></pre><p>Adicionando a tag <strong><em>--dev</em></strong> é possível instalar as dependências necessárias no cenário de desenvolvimento/teste:</p><pre><strong>$ pipenv install --dev</strong></pre><p>Existem outros benefícios em usar o Pipenv: ele possui melhores recursos de segurança, representa graficamente suas dependências em um formato mais fácil de entender, manipula arquivos .env sem problemas e pode lidar automaticamente com diferentes dependências para ambientes de desenvolvimento versus produção em um arquivo. Você pode ler mais na <a href="https://docs.pipenv.org/">documentação</a>.</p><h3>Pipenv em ação</h3><p>Os fundamentos do uso do Pipenv são detalhados na seção <a href="https://packaging.python.org/tutorials/managing-dependencies/">Gerenciando Dependências da Aplicação</a> do tutorial oficial de empacotamento do Python. Para instalar o Pipenv, use <strong>pip</strong>:</p><pre><strong>$ pip install pipenv</strong></pre><p>Para instalar pacotes para usar em seu projeto, mude para o diretório do seu projeto. Então, para instalar um pacote(usaremos o Django como exemplo), execute:</p><pre><strong>$ pipenv install django</strong></pre><p>Você verá alguma saída que indica que o Pipenv está criando um Pipfile para o seu projeto.</p><p>Se você ainda não estiver usando um ambiente virtual, verá também alguns resultados do Pipenv dizendo que está criando um ambiente virtual para você.</p><p>Então, você verá a saída que está acostumado a ver ao instalar pacotes.</p><p>Para gerar um arquivo <strong><em>Pipfile.lock</em></strong>, execute:</p><pre><strong>$ pipenv lock</strong></pre><p>Você também pode executar scripts Python com o Pipenv. Para executar um script Python top-level chamado <strong><em>hello.py</em></strong>, execute:</p><pre><strong>$ pipenv run python hello.py</strong></pre><p>E você verá o resultado esperado no console.</p><p>Para iniciar uma <strong><em>shell</em></strong>, execute:</p><pre><strong>$ pipenv shell</strong></pre><p>Se você quiser converter um projeto que atualmente usa um arquivo requirements.txt para usar o Pipenv, instale o Pipenv e execute:</p><pre><strong>$ pipenv install requirements.txt</strong></pre><p>Isso criará um Pipfile e instalará as dependências especificadas. Considere o seu projeto atualizado!</p><h3>Aprenda mais</h3><p>Confira a documentação do Pipenv, principalmente o <a href="https://docs.pipenv.org/basics/">Uso Básico do Pipenv</a>, para ir mais longe. O criador do Pipenv, Kenneth Reitz, deu uma palestra sobre o Pipenv, <a href="https://www.pytennessee.org/schedule/presentation/158/">“O Futuro do Gerenciamento de Dependências no Python”</a>, em um evento recente, o PyTennessee. A palestra não foi gravada, mas seus slides são úteis para entender o que o Pipenv faz e os problemas que ele resolve.</p><h3>Créditos</h3><p>Este artigo é uma tradução direta do artigo <a href="https://opensource.com/article/18/2/why-python-devs-should-use-pipenv"><strong>Why Python devs should use Pipenv</strong></a><strong> </strong>publicado no site <strong>www.opensource.com.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ae3d3154c44" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Flask e Facebook]]></title>
            <link>https://medium.com/@wilfilho/flask-e-facebook-2d3544ad504a?source=rss-71b7ac064dab------2</link>
            <guid isPermaLink="false">https://medium.com/p/2d3544ad504a</guid>
            <dc:creator><![CDATA[Wilson Martins]]></dc:creator>
            <pubDate>Fri, 22 May 2015 15:31:35 GMT</pubDate>
            <atom:updated>2015-05-22T19:49:58.378Z</atom:updated>
            <content:encoded><![CDATA[<h4>Como integrar o Facebook à sua aplicação escrita em Flask</h4><p>Bem, existem uma série de tutoriais que ensinam como integrar a sua aplicação escrita em Flask ao Facebook. Os exemplos de alguns tutoriais funcionam, alguns são complexos e outros não funcionam por algum motivo.</p><p>Neste post, como já esperado, aprenderemos a integrar o Flask ao Facebook, permitindo ao usuário se cadastrar e logar através da sua conta no Facebook. Claro que poderíamos dar mais opções aos usuários, fornecendo também a opção deles logarem pelo Twitter ou qualquer outra rede social, mas como o foco deste post é apresentar a integração com o Facebook, focaremos exclusivamente nele.</p><p>O principal benefício de não só integrar o Facebook, mas como qualquer outra rede social na nossa aplicação é a praticidade oferecida ao usuário. Quando nós oferecemos ao usuário por exemplo: se inscrever com o Facebook, ele não precisará colocar o seu email, colocar a sua senha, colocar o seu nome, etc. Ele apenas clica no botão de login com o Facebook e bum! Ele já está registrado no nosso banco de dados.</p><p>Mas como já devemos saber, por trás dessa “mágica” há um truque bastante interessante, digamos assim. A primeira coisa que devemos ter em mente para ela funcionar o usuário deverá estar logado na sua conta. Caso o usuário não esteja logado, então ele será redirecionado para uma tela de login do Facebook. Algo como a imagem abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fDdt7NMEeo5H0nBY139VNw.png" /><figcaption>Página de login onde somos redirecionados.</figcaption></figure><p>Quando o usuário logar na sua conta, então nós receberemos os dados dele, tais como: o seu id no Facebook(dado importante), o seu nome, o seu gênero, etc.</p><h3>Criando e configurando aplicação no Facebook</h3><p>Antes de mais nada, nós deveremos criar uma aplicação no Facebook para poder obter os dados de acesso. Sendo assim, iremos primeiramente acessar a seguinte url: <a href="https://developers.facebook.com/">https://developers.facebook.com/</a>. Ao acessar a url, deveremos ir até o menu e clicar na opção “<em>My Apps</em>”. Quando clicarmos na opção “<em>My Apps</em>” seremos redirecionados para uma outra página, onde deveremos clicar no botão “Add a new app”, como mostra a imagem abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hQPvx1lQZ2DS0-7vi7aUbg.png" /></figure><p>Após isto, uma popup será aberta para nós podermos selecionar qual é a plataforma em que utilizaremos a nossa aplicação. Como estamos querendo integrar com o Flask, selecionaremos a opção <em>“Website”</em>. Na próxima página devemos cliar no botão de pular.</p><p>Quando pularmos, vamos ser redirecionados para outra páginas onde devemos colocar algumas informações sobre a nossa aplicação. Por fim, seremos redicionados a um painel de administração do nosso app.</p><h4>Configurando aplicação</h4><p>Agora que criamos o app, vamos configurar ele para podermos utilizá-lo no nosso localhost. A primeira coisa que deveremos fazer é entrar nas configurações. Quando entrarmos, seremos redirecionados para as configurações básicas do nosso app, como podemos ver na imagem abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oAAj_X_xuKDZQQXnVJMKIg.png" /></figure><p>O que nós devemos fazer nela é o seguinte: deveremos clicar no botão “+ Add Plataform” e selecionar a opção Website. Após isso, ele irá fornecer dois campos para nós preenchermos. As informações que devemos colocar nesses campos são correspondente a url da nossa aplicação no localhost, ou seja, no nosso caso utilizaremos a porta 3000 no localhost, sendo assim, colocaremos a url <a href="http://www.localhost:5000/">http://www.localhost:3000/.</a></p><p>Feito os passos descritos acima, devemos salvar as alterações clicando no botão “Save Changes”. Por fim, devemos clicar na aba “Advanced”, ir até o container “OAuth Settings” e adicionar a nossa url local ao campo “Valid OAuth redirect URIs”. Para um melhor compreendimento, vejamos a imagem abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XPYEliwYY3pBFdaNvTnXUw.png" /></figure><p>Bem, agora temos tudo configurado para criarmos a nossa aplicação no ambiente local.</p><h3>Integrando o Flask ao Facebook</h3><p>Antes de mais nada, vamos instalar as nossas dependências(é recomendado criar um ambiente antes). Neste exemplo utilizaremos os seguintes pacotes: flask, flask-sqlalchemy, flask-login e o flask-oauth.</p><p><strong><em>$ pip install flask flask-sqlalchemy flask-login flask-oauth</em></strong></p><p>Agora que possuímos todas as dependências instaladas, vamos iniciar a criação da nossa aplicação. Inicialmente vamos criar um arquivo chamado <strong>app.py</strong> e após isto vamos importar os objetos que nós necessitaremos. Vejamos no trecho de código abaixo como ficará as nossas importações.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d9cf23abe22434101f477d27a913edd1/href">https://medium.com/media/d9cf23abe22434101f477d27a913edd1/href</a></iframe><p>Logo abaixo das nossas importações nós devemos declarar duas constantes, sendo elas: o <em>App Id </em>e o <em>App Secret </em>da nossa aplicação gerada lá no Facebook. Sendo assim, ficará da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0fd729fc47a5e0f186682aebeed66c93/href">https://medium.com/media/0fd729fc47a5e0f186682aebeed66c93/href</a></iframe><p>Após importamos o que iremos utilizar na construção da nossa aplicação e declararmos as nossas constantes, vamos criar um objeto da classe Flask(como de padrão) e adicionar algumas configurações a ele. Para um melhor compreendimento, vejamos o trecho de código logo abaixo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9db80b33cc7afa3752448a342c8d0427/href">https://medium.com/media/9db80b33cc7afa3752448a342c8d0427/href</a></iframe><p>No trecho de código acima, basicamente explicitamos que o servidor deverá rodar no modo <strong>debug</strong> e que a url do nosso banco de dados é sqlite:///example.db. Feito isso, vamos criar o nosso <em>model</em>, onde conterá as seguintes colunas: o id do usuário, o nome do usuário, o id correspondente ao Facebook do usuário e o email do usuário, sendo o email opicional.</p><p>O email será opicional pelo fato de que nem todos os usuários quando logarem com o Facebook retornarão um email para nós. Essa ausência do email no retorno dos dados pode possuir diversas razões. Um motivo comum é quando o usuário não confirma o email, sendo assim o Facebook não retornará ele para nós. Vejamos o trecho de código abaixo para uma melhor compreensão.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/dffeafc058801b3c698ed20f67ae4a0f/href">https://medium.com/media/dffeafc058801b3c698ed20f67ae4a0f/href</a></iframe><p>No trecho de código acima criamos um objeto da classe SQLAlchemy e criamos a classe User, que nada mais é do que o nosso <em>model</em>. Podemos perceber também que nós declaramos como parâmetro na coluna <em>email</em> o <strong><em>nullable=True</em></strong>, indicando que esta coluna pode conter valores nulos, ou seja, nenhum valor.</p><h4>Criando os callbacks necessários para o login</h4><p>Inicialmente nós vamos criar um objeto da classe Oauth e outro objeto da classe LoginManager. O objeto da classe Oauth será utilizado para nós fazermos a autentificação do usuário no Facebook e o objeto da classe LoginManager para o usuário realizar o login na nossa aplicação.</p><p>Logo abaixo do <em>model</em> vamos adicionar as seguintes linhas:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5d10149a935542fa6bf66de0f4869d3b/href">https://medium.com/media/5d10149a935542fa6bf66de0f4869d3b/href</a></iframe><p>No trecho de código acima podemos perceber a presença de duas linhas adicionais. A linha em que nós declaramos o método <em>init_app()</em> é importante para nós iniciarmos o objeto da classe LoginManager no contexto da nossa aplicação. E a linha em que nós definimos um valor para a propriedade <em>login_view</em> é importante pois nós definimos em qual rota estará a nossa página de login.</p><p>Agora iremos criar uma variável chamada <em>facebook</em> que armazenará as informações necessárias para realizarmos a autentificação com o Facebook. Informações como: a url base, a url de autenticação, tokens de acesso, etc. Sendo assim, logo abaixo do trecho de código que acabamos de escrever acima devemos colocar a seguinte linha:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/64fdc98f53203ed8649f0cba4da1b34b/href">https://medium.com/media/64fdc98f53203ed8649f0cba4da1b34b/href</a></iframe><p>Após criarmos todos os objetos necessários, vamos criar os nossos callbacks. O primeiro deles será relacionado a restrição de acesso, ou seja, se o usuário tentar acessar uma página em que ele não esteja autorizado, iremos barrá-lo e jogá-lo para a página de login. Ficará da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e7de3dbf8033a701474adf9149e345f7/href">https://medium.com/media/e7de3dbf8033a701474adf9149e345f7/href</a></iframe><p>O segundo callbacks será responsável por recarregar o id do usuário armazenado na sessão, onde ele receberá o <em>id </em>desse usuário e retornará como resposta um objeto correspondente a este usuário.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/deaf80a70df0b02095e19dd867b8303b/href">https://medium.com/media/deaf80a70df0b02095e19dd867b8303b/href</a></iframe><p>O próximo callback será responsável por, a cada requesição feita em qualquer página identificar o usuário atual e inserí-lo na propriedade user do objeto g(que importamos lá no começo).</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/940d2c9baea25d3c8c8e924d5b9f9dd5/href">https://medium.com/media/940d2c9baea25d3c8c8e924d5b9f9dd5/href</a></iframe><p>Agora que temos os callbacks de login criados, vamos criar os callbacks para autenticação no Facebook. Vejamos o trecho de código abaixo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2f0fc371e074988e366288fe3783e075/href">https://medium.com/media/2f0fc371e074988e366288fe3783e075/href</a></iframe><p>Como podemos ver, o primeiro callback na verdade é uma rota que ficará responsável por receber os dados do usuário após a autenticação no facebook, registrar este usuário no nosso banco de dados caso ele ainda não esteja registrado e logá-lo. Esse trecho de código é muito importante pois é aqui onde nós logaremos o usuário através do seu id do Facebook, que nada mais é do que um identificador único, permitindo a ausência de qualquer tipo de senha para o usuário que optar por este tipo de login.</p><p>O segundo callback é responsável apenas por pegar token da sessão.</p><h4>Criando as rotas</h4><p>Por fim, após termos feito todos esses passos, vamos criar as rotas que o usuário acessará e também o seus templates. Vejamos o trecho de código abaixo para entendermos a maneira que ficará as nossas rotas.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c6b787e29dbe8e13b006d0e6a4552485/href">https://medium.com/media/c6b787e29dbe8e13b006d0e6a4552485/href</a></iframe><p>A primeira rota nada mais é que a nossa index, onde a mesma irá renderizar o nosso template index.html. A segunda rota é uma rota restrita, onde apenas os usuários logados podem acessar. Podemos perceber isso por causa da presença do decorator <em>login_required</em>.</p><p>A terceira rota exige um pouco mais de explicação. Ela fará o seguinte: caso o usuário atual não esteja logado, então ela vai enviar uma requisição para o facebook para poder autentificar o usuário. O Facebook por sua vez, irá retornar uma série de dados do usuário caso tudo ocorra bem, então, nós seremos redirecionados lá para a rota <em>/login-facebook/authorized</em>, onde já nos foi explicado o que irá acontecer. Caso o usuário já esteja logado, então, obviamente, nós o redirecionamos para o painel de administração.</p><p>A última rota como já devemos saber, irá deslogar o usuário.</p><p>O último passo que devemos dar é executar a nossa aplicação. Vejamos o trecho de código abaixo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8b883bb895eed36b444c74106a6dc6b7/href">https://medium.com/media/8b883bb895eed36b444c74106a6dc6b7/href</a></iframe><p>Sendo assim, chegamos ao fim desse simples tutorial de como integrar a nossa aplicação em Flask ao Facebook. Integrar com outras redes sociais seguem a mesma linha de raciocínio, porém modificando as urls e os tokens. Para visualizar o projeto completo, basta acessar o nosso repositório no github: <a href="https://github.com/wilfilho/flask-facebook-example">flask-facebook-example</a>. Até mais.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2d3544ad504a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Conhecendo o coração e as artérias do PyQt5]]></title>
            <link>https://medium.com/@wilfilho/conhecendo-o-coracao-e-as-arterias-do-pyqt5-22ba4187531?source=rss-71b7ac064dab------2</link>
            <guid isPermaLink="false">https://medium.com/p/22ba4187531</guid>
            <dc:creator><![CDATA[Wilson Martins]]></dc:creator>
            <pubDate>Sat, 31 Jan 2015 02:35:52 GMT</pubDate>
            <atom:updated>2015-02-21T20:10:30.912Z</atom:updated>
            <content:encoded><![CDATA[<p>Desvendando um pouco da sua anatomia</p><p>Bem, esta é a segunda parte da série de artigos que pretendem abordar exclusiva e unicamente o PyQt5 por completo. Como sabemos, nesta etapa entenderemos como funcionam as coisas por trás do PyQt5. Aprenderemos sobre o sistema de sinais e slots, o sistema de eventos, timers, threads e um pouco mais. Alguns poderiam achar que eu estaria sendo um pouco precipitado em estar abordando threads ou até mesmo timers num segundo artigo sobre PyQt5, mas eu diria que não, pelo fato de ser algo bastante simples de entender e muito útil em diversas ocasiões.</p><p>Caso você esteja chegando agora, o primeiro post desta série é o: <a href="https://medium.com/@wilfilho/pyqt5-o-fantastico-mundo-das-guis-62914b1b39c1">PyQt5 — O fantástico mundo das GUIs</a>. Nele, abordamos conceitos iniciais e fundamentais para o compreendimento e utilização do PyQt5 como um todo. Então, se ainda não o leu, recomendo fortemente uma leitura.</p><p>Em resumo a tudo que veremos aqui, basicamente iremos desbravar o módulo QtCore, local onde fica o coração do PyQt5(do PyQt4, do PySide, do Qt e os seus demais filhos). Sendo assim, é importante que você entenda os conceitos dados aqui para que a luz entre na sua mente. Sem mais delongas, vamos ao que interessa.</p><blockquote><strong>Atenção: </strong>Apesar deste post ser um tanto grande, o mesmo permite que você não siga um padrão linear para lê-lo. Por exemplo: Você pode iniciar lendo o último tópico presente nele, voltar para o começo e depois ler o meio; Ou até mesmo fazer o que você quiser. Porém, vale ressaltar que, se você ainda não sabe nada dos assuntos tratados aqui ou sabe um pouco é recomendável que se tenha uma leitura linear dele.</blockquote><blockquote>Signals e slots</blockquote><p>Com certeza, o surgimento dos computadores pessoais foi um marco para a tecnologia da informação. Foi o passo inicial para uma série de evoluções e criações surpreendentes, que hoje estão efetivamente presentes na nossa vida. Vide a internet, que toma quase todo o nosso tempo do dia. Mas nem sempre foi assim, nem sempre existiu toda a acessibilidade dada pelos computadores pessoais.</p><p>Na idade da pedra, nós não tínhamos o mouse nem a interface gráfica bonitinha para utilizar o nosso computador. Tínhamos que fazer tudo a mão, aprender uma série de comandos para executar uma simples tarefa. Enfim, tudo isso dificultava muito a acessibilidade dos usuários mais comuns.</p><p>Desde o surgimento das interfaces gráficas a forma com que escrevemos softwares para a plataforma desktop mudou drasticamente. Agora, as nossas aplicações seriam baseadas em ações diretas do usuário em uma interface e não mais em comandos em modo texto dados para o nosso software. É neste ponto que o assunto Signal e Slots entra no nosso contexto.</p><p>Algumas bibliotecas de interfaces gráficas utilizam callbacks para poder identificar as ações realizadas pelos usuários na nossa interface, e embora eles cumpram com os seus deveres, os mesmos possuem duas falhas que fizeram com que o Qt não as utilizasse. Sendo elas: a primeira delas é que um callback não é do tipo seguro(type safe), ou seja, nós não teremos certeza de que o callback chamará o método com os argumentos declarados; O segundo problema encontrado na utilização dos callbacks é que eles são fortemente acoplados à função de processo. Vejamos a imagem 1.1 para um melhor compreendimento sobre Signal e Slots.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/516/1*ijJnF3DjZBx2Lk8CkTF5uQ.png" /><figcaption><a href="http://doc.qt.io/qt-5/signalsandslots.html">Imagem retirada da documentação do Qt</a>. Explica basicamente como são os Signals e Slots.</figcaption></figure><p>Em alternativa a utilização dos callbacks, temos o Signals e Slots, disponibilizado no Qt. Um sinal é emitido todas as vezes que o estado de um objeto é modificado, ou seja, todas as vezes que ocorre uma ação(como clicar em um botão). Quando um Signal é ativado, ele chama o Slot(ou um método) que estiver conectado a este sinal. Na imagem acima, podemos ver claramente isso.</p><p>Por exemplo, no objeto 1. Vamos supor que este objeto fosse um botão, sendo assim, este botão teria dois sinais(Signal 1 e Signal 2) conectados a dois Slots(Slot 1 e Slot 2). Todas as vezes que um sinal relacionado a este botão for emitido, ele chamará o slot correspondente a ele. Vale ressaltar que ao invés de Slot poderíamos ter métodos, como veremos mais a frente.</p><p>Para entrarmos no contexto, vamos criar um exemplo simples onde clicamos em um botão e ele nos exibe em um diálogo o texto que estiver escrito dentro de uma linha de texto. Como vimos no post anterior, o PyQt tem basicamente uma estrutura de código para criar uma simples janela, porém caso não esteja lembrado, veja o código a seguir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7765cc62cf7ec50f8cc0dfcb3d6ad3d8/href">https://medium.com/media/7765cc62cf7ec50f8cc0dfcb3d6ad3d8/href</a></iframe><p>Acima temos basicamente uma janela, porém, para o nosso exemplo nós precisamos mais que isso, precisamos de um botão, um layout, uma área onde o usuário possa inserir o texto e um diálogo(neste caso será o MessageBox). Sendo assim, vamos modificar as nossas importações para que possamos utilizar os recursos descritos anteriormente. As importações devem ficar similares ao trecho de código abaixo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5c1b0e28e93bc52faca88e3c6572a5ef/href">https://medium.com/media/5c1b0e28e93bc52faca88e3c6572a5ef/href</a></iframe><p>A diferença entre as importações acima e as anteriores é que nós adicionamos as classes QPushButton, QLineEdit, QHBoxLayout e QMessageBox. O QPushButton, como já sabemos, nos fornece um botão. O QLineEdit nos oferece uma linha de texto para o usuário digitar algo. O QHBoxLayout nos fornece um layout na posição horizontal e o QMessageBox uma caixa de diálogo com algumas configurações pré-definidas.</p><p>Agora que temos as importações, devemos encaixar os nossos widgets dentro da interface. Sendo assim, o nosso código ficará da seguinte maneira.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c14d76d2066734064100b0a27f6c29de/href">https://medium.com/media/c14d76d2066734064100b0a27f6c29de/href</a></iframe><p>Basicamente o que temos no código acima é uma declaração de um botão, a declaração de uma linha de texto(ou área de texto) e a declaração de um layout simples. Não é necessário que entendamos agora o funcionamento do layout e sim, o funcionamento dos Signals e Slots. Pois bem, faltamos um toque final para que a nossa aplicação possa ser exibida. Como vimos no post anterior, o nosso trecho de código final ficará desta forma:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2ee4b72ca0ac94cca5fbd11661405530/href">https://medium.com/media/2ee4b72ca0ac94cca5fbd11661405530/href</a></iframe><p>Ao executarmos o nosso código veremos que a linha de texto está ao lado do botão e que o layout, por esse motivo, está funcionando corretamente. Porém, há um problema, a nossa aplicação “não tem vida”. Neste ponto, utilizaremos os conceitos dados anteriormente aqui, neste código. O que faremos basicamente é: quando o usuário clicar no botão, nós pegaremos o texto que está presente dentro da área de texto e o mostraremos em um diálogo. Para tal, deveremos conhecer a forma como conectamos um objeto a um método ou slot através de um sinal.</p><h3><strong>Formas de conectar</strong></h3><p>Até meados do PyQt 4.8 a forma com que realizávamos a conexão descrita anteriormente era bem pouco intuitiva e legível. Na verdade ela se assemelha muito a forma com que é feito no Qt. Sendo assim, a forma era a seguinte:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3ef0c3a3336339ae57e5333da5103b1b/href">https://medium.com/media/3ef0c3a3336339ae57e5333da5103b1b/href</a></iframe><p>Ou seja, possuíamos um código não muito legível e feio. Mas eis que surge a luz e após esta versão surgiu uma nova forma de conectar os nossos objetos aos nossos métodos, desta vez bem mais intuitiva, legível e bonita. A sua fórmula é a seguinte:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e18c56adeb525414c1ddd26572608db8/href">https://medium.com/media/e18c56adeb525414c1ddd26572608db8/href</a></iframe><p>Ao olhar o código acima, percebemos claramente que estamos conectando um objeto a um método através de um sinal. Além de ser mais fácil de ler, é muito mais fácil de escrever. Um exemplo real da utilização da fórmula seria:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/51df6180a608b845203b18df0ae6b800/href">https://medium.com/media/51df6180a608b845203b18df0ae6b800/href</a></iframe><p>Especificamos que o botão está conectado a um método através do sinal <em>clicked</em>.</p><h3>Voltando ao código</h3><p>Aplicando o que aprendemos anteriormente, podemos conectar o nosso botão a um método e criar este método para executar o que desejamos que ele execute. Sendo assim, o nosso código inicialmente ficará da seguinte forma:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/22ad565f0c41b5268e279e52c8cb68e3/href">https://medium.com/media/22ad565f0c41b5268e279e52c8cb68e3/href</a></iframe><p>Agora que temos o nosso botão conectado ao nosso método, deveremos criar este método, obviamente. Nele, teremos que obter o texto presente na área de texto, criar um objeto da classe QMessageBox e exibi-la na tela. Ficará desta forma:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f51b45028d759ceba32ef0230d7bf5be/href">https://medium.com/media/f51b45028d759ceba32ef0230d7bf5be/href</a></iframe><p>Vale ressaltar que o método acima deve ficar dentro do escopo da nossa classe <em>Window</em>. Para obter o texto do QLineEdit utilizamos o método <em>text()</em> e armazenamos este texto dentro de uma variável. Após isso criamos um objeto da classe QMessageBox e utilizamos o método <em>information()</em> para especificar que desejamos ter um diálogo de informação.</p><h4>Conhecendo um pouco mais sobre signals</h4><p>Sabemos que os signals são emitidos todas as vezes que o estado de um objeto é modificado, ou seja, quando ocorre por exemplo um clique em um botão. Os signals nada mais são do que funções públicas que podem ser emitidas de qualquer lugar, porém é recomendável que o sinal somente seja emitido da classe que a define ou de alguma subclasse.</p><p>Quando um sinal é emitido, automaticamente o slot ou método conectado a ele é executado. Esta chamada de método é totalmente independente de qualquer event loop presente na nossa GUI, evitando travamentos. Outra característica interessante do Signal e Slots é que ao invés dos callbacks, eles são desacoplados um do outro, ou seja, uma classe que emite um sinal não se importa nem conhece quais slots irão receber este sinal.</p><p>Todo widget presente no PyQt possui os seus próprios sinais e algumas vezes slots. Por exemplo: um botão possui três tipos de sinais; o <em>clicked</em>, o <em>pressed</em> e o <em>release</em>. Já um QSpinBox possui apenas um sinal, o <em>valueChanged</em>. Ou seja, um botão que emite um sinal do tipo <em>clicked</em> não se importará quais slots receberão este sinal, até porque o sinal pode não estar conectado a um slot e sim a um método.</p><h3>Voltando ao exemplo inicial</h3><p>Podemos incrementar a nossa aplicação exibindo diversos tipos de diálogos. Para tal, utilizaremos um widget chamado QRadioButton, onde o usuário irá escolher qual utilizar para exibir a mensagem que ele deseja. Também utilizaremos as classes QVBoxLayout e QGroupBox para deixar a nossa aplicação mais organizada. Sendo assim, temos que adicionar à nossa importação as classes descritas anteriormente.</p><p>Primeiramente devemos modificar as nossas importações, que ficará da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e7469994369f454d76d49be9cff10436/href">https://medium.com/media/e7469994369f454d76d49be9cff10436/href</a></iframe><p>Após isso, devemos criar os layouts correspondente a cada conjunto de widget. A nossa classe <em>Window </em>ficará da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a761fb6731cfc36c2b77f72170280c53/href">https://medium.com/media/a761fb6731cfc36c2b77f72170280c53/href</a></iframe><p>Como já mencionado, não é necessário que compreendamos ainda sobre as diversas formas de layout presentes no PyQt, pois abordaremos isto com mais profundida no próximo post. Para uma explicação rápida, o que fazemos acima é: criamos um objeto da classe QGroupBox para agrupar os três objetos da classe QRadioButton e após isso organizamos os radio buttons dentro de um layout com orientação na posição vertical. Depois, organizamos o botão e a área de texto em um layout horizontal(como tínhamos feito anteriormente) e por fim, criamos um layout vertical para alinhar o GroupBox e o layout horizontal numa posição vertical. O resultado será este:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/264/1*UQTUmuTgq9x2Yw61xjXmYA.png" /><figcaption>Resultado do código descrito logo acima.</figcaption></figure><p>Também deveremos modificar o método <em>exibir()</em> que criamos anteriormente. Ele deverá ficar da seguinte forma:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3c672ca8b93db1e464f2e3c7c86d7173/href">https://medium.com/media/3c672ca8b93db1e464f2e3c7c86d7173/href</a></iframe><p>No trecho de código acima, modificamos o método <em>exibir()</em> para que ele verifique qual dos radio buttons estão marcados e assim, definir qual tipo de diálogo exibir. Podemos ver o resultado desta simples aplicação logo abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/308/1*Gv6wzGSrxuMgWbljscboCg.png" /><figcaption>Versão final da aplicação.</figcaption></figure><h3>Handler Events</h3><p>Assim como a emissão de signals, um evento ocorre todas as vezes que o usuário realiza uma ação na nossa interface. Porém, diferentemente dos signals todos os eventos são derivados da classe QEvent. Alguns eventos em especial possuem classes próprias para tratá-los, como é o caso do <em>closeEvent()</em>, que é um método presente em classes como: QWidget, QMainWindow e QDialog. E ainda sim possui uma classe chamada QCloseEvent, que disponibiliza métodos especiais para tratá-lo de uma forma mais livre.</p><p>Quando um evento ocorre no Qt, ele automaticamente cria um objeto deste evento para poder representá-lo através da construção de uma subclasse da classe QEvent ou qualquer outra que derive da mesma, e depois o entrega para uma instância específica da classe QObject chamando o método <em>event()</em>.</p><p>Através dos eventos nós podemos realizar uma série de ações e manipulações na nossa interface. Na realidade, podemos controlar quase tudo. Uma classe(ou widget), assim como os signals, já vem com uma série de eventos pré-definidos que precisamos apenas declará-los para modificá-los. Este eventos “pré-definidos” são chamados de <strong><em>handler events</em></strong>. Um claro exemplo disso é o já citado <em>closeEvent()</em>.</p><p>Os handler events possuem algumas pequenas características das quais devemos ter conhecimento. A primeira coisa que devemos prestar atenção é que, diferentemente dos métodos que declaramos para os signals, um handler event exige um parâmetro adicional na sua declaração, ou seja, ele exige que tenhamos um parâmetro a mais para poder tratar aquele determinado evento, seja ignorando, seja aceitando-o, etc.</p><p>Outro fato interessante sobre os handler events é que eles nada mais são do que métodos virtuais pertencentes às classes das quais derivamos. Por exemplo: no nosso exemplo anterior, nós utilizamos como top-level da nossa aplicação a classe QWidget, que por sua vez, possui uma série de métodos, eventos, signals e slots implementados. Quando herdamos a classe QWidget na nossa classe e declaramos um método como o <em>closeEvent()</em>, estamos fazendo nada mais nada menos do que sobrescrever este método para que ele haja da forma que desejamos.</p><p>Para um exemplo prático, vamos perguntar ao usuário todas as vezes que ele clicar no botão de fechar da janela se ele deseja realmente fechá-la. Inicialmente, nós sabemos que temos o seguinte código(os passos finais foram ocultados mas devem ser mantidos no seu código original):</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1fee55f00c8cbfc7e906cd41c2a5d07c/href">https://medium.com/media/1fee55f00c8cbfc7e906cd41c2a5d07c/href</a></iframe><p>Devemos adicionar o método <em>closeEvent()</em> explicitamente ao escopo da nossa classe com um parâmetro adicional, podendo nomeá-lo da forma que desejar. Da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/90163a334e97551e5b68bd2ad9b2a093/href">https://medium.com/media/90163a334e97551e5b68bd2ad9b2a093/href</a></iframe><p>A primeira coisa que fazemos é ignorar o evento de fechamento da nossa aplicação, para assim podermos exibir o diálogo para o usuário. Através do diálogo de questionamento perguntamos se o mesmo deseja fechar a aplicação, caso ele clique no no botão “Yes”, então fechamos a nossa aplicação.</p><p>Além da situação citada anteriormente, os handler events são úteis em diversas outras ocasiões, como por exemplo: no redimensionamento de janelas, na minimização de janelas, na utilização dos drag and drops em diversos widgets, etc.</p><h4>Handler events em widgets específicos</h4><p>Vimos acima que é possível utilizar handler events para uma série de situações, mas não vimos como é possível utilizar um handler event em um widget específico, ou seja, fora de uma janela. Para falar verdade, isso é bem simples, uma vez que estaremos apenas incrementando funcionalidades em um determinado widget. Para este exemplo, iremos abondar o código escrito anteriormente e iremos fazer o seguinte: todas as vezes que o usuário clicar sobre uma imagem que ficará dentro de um QLabel, ele abrir um diálogo para o usuário abrir outra imagem. Caso ainda não saiba, um QLabel só emite dois sinais, que são eles: o <em>linkHovered()</em> e o <em>linkActivate()</em>, que somente são utilizados quando temos um link em um label(isso é possível através de tags html).</p><p>Para iniciarmos vamos primeiramente criar um novo arquivo e definir o nome dele como: <strong><em>signal_emited.py</em></strong>. Nele criaremos a estrutura básica de toda aplicação(simples) que utiliza o PyQt. Dentro da nossa classe nós não adicionaremos nada ainda, pois como já descrito, nós teremos que incrementar funcionalidades na classe QLabel para que ela reconheça o clique de um botão. Sendo assim, vamos criar uma outra classe antes da classe principal da nossa aplicação e herdá-la da classe QLabel. Inicialmente ela ficará desta forma:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6708399691d602e9ad581b6c03593e5f/href">https://medium.com/media/6708399691d602e9ad581b6c03593e5f/href</a></iframe><p>Nós declaramos o método <em>setMouseTracking()</em> como <strong>True</strong> para informar que desejamos obter a posição do cursor do mouse sempre que ele se mover. Isso será importante para quando formos modificar o ponteiro do mouse. A segunda coisa que deveremos fazer é declarar o handler event <em>mousePressEvent</em>. Este evento é ativado todas as vezes que o usuário clica sobre algo, permitindo a nós fazer com que a nossa imagem reconheça um evento de clique, similar ao <em>clicked</em> presente nos botões. Ficará dessa forma:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d209ac817ba6978a30f97975e6826c5f/href">https://medium.com/media/d209ac817ba6978a30f97975e6826c5f/href</a></iframe><p>Vale ressaltar que este método deve ficar dentro do escopo da nossa classe CustomLabel. Basicamente declaramos um QFileDialog(que deveremos acrescentar às nossas importações, que fica no módulo QtWidgets), inserimos um título e após isso um filtro. Percebemos também que ele recebe duas variáveis, isso acontece porque ele retorna dois valores. O primeiro deles é a url do arquivo selecionado e a segunda é se o usuário clicou em Ok ou Cancel, retornando respectivamente True ou False. Depois, pegamos a url do arquivo que o usuário selecionou e colocamos no nosso label.</p><p>A nossa classe principal deverá ficar da seguinte maneira.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1dae6b4dce509bce0ef3c08770b792d5/href">https://medium.com/media/1dae6b4dce509bce0ef3c08770b792d5/href</a></iframe><p>Para deixar a nossa aplicação um pouco mais intuitiva, vamos fazer o seguinte. Quando o usuário passar o mouse por cima da nossa imagem, o cursor mudará para uma mão(aquela que aparece quando você vai clicar em um link ou uma imagem no Facebook). Pois bem, deveremos adicionar a classe CustomLabel estes dois métodos.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b374f5fad9764f5d0a72b67e210a8e72/href">https://medium.com/media/b374f5fad9764f5d0a72b67e210a8e72/href</a></iframe><p>É importante que o método <em>setMouseTracking</em> esteja habilitado.</p><h3>Estudando os timers</h3><p>Timers nada mais são do que temporizadores e eles podem ser utilizados para uma série de coisas, tais como: verificar algo a cada 3 segundos, estabelecer timeouts, criar cronômetros, etc. Para esta seção nós utilizaremos dois exemplos: o primeiro e mais simples será a criação de uma barra de progresso e o segundo e um pouco mais avançado, será a criação de um software para tirar screenshot.</p><p>O PyQt disponibiliza basicamente de duas classes para nós tratarmos os timers, sendo elas: QBasicTimer e QTimer. A diferença entre essas duas, é que a classe QBasicTimer fornece métodos simples para o gerenciamento de temporizadores, enquanto a QTimer oferece métodos como o <em>singleShoot()</em> e sinais como o <em>timeout</em> que permite um melhor controle sobre os nossos temporizadores.</p><h4>Utilizando um timer na classe QProgressBar</h4><p>Neste exemplo mais simples e inicial, utilizaremos como já descrito a classe QBasicTimer. Ela fornece quatro métodos principais: o <em>start()</em>, o <em>stop(), </em>o <em>isActive() </em>que retorna <strong>True</strong> quando o timer está ativo e o <em>timerId()</em> que retorna um inteiro indicado qual é o id do temporizador.</p><p>Uma coisa que devemos saber antes de utilizar os timers é que sempre que um timer é ativado, um handler event é chamado. Neste caso o handler event que é chamado é o <strong><em>timerEvent</em></strong>. Será este handler event que utilizaremos. Nas nossas importações devemos incluir a classe QBasicTimer que fica dentro do módulo QtCore, afinal, ela faz parte das features do core fornecidas pelo PyQt. As importações ficarão da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fa02d9ca8431265746dd564a462a40b0/href">https://medium.com/media/fa02d9ca8431265746dd564a462a40b0/href</a></iframe><p>Após isso, vamos criar a nossa classe, como de costume, e um método settings(). Ficará da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/671abaf0eb7d4b2069cd7409001c00b6/href">https://medium.com/media/671abaf0eb7d4b2069cd7409001c00b6/href</a></iframe><p>Agora devemos criar o nosso método <em>create_widgets()</em>, que ficará responsável por criar os widgets(obviamente) e inicializar o nosso temporizador. O nosso método ficará assim:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/48a5fd44ce38db6b38746c7e75812dac/href">https://medium.com/media/48a5fd44ce38db6b38746c7e75812dac/href</a></iframe><p>No trecho de código acima, nós definimos um objeto da classe QProgressBar onde podemos notar a utilização do self durante a criação do objeto. Como já explicado, quando um determinado widget não está contido diretamente em um determinado layout, nós deveremos referenciar o pai(ou <strong><em>parent</em></strong>, com preferir) para garantir que ele seja exibido. Depois, criamos um objeto da classe QBasicTimer, uma variável e por fim, inicializamos o nosso temporizador.</p><p>O método <em>start() </em>pode receber 3 parâmetros, sendo eles: o timeout em milissegundos, ou seja, de quanto em quanto tempo vamos ativar o handler event <strong><em>timerEvent</em></strong>; o segundo parâmetro corresponde ao tipo de temporizador e o terceiro está referente ao nosso pai(ao <strong><em>parent)</em></strong>. Para terminamos, devemos declarar o handler event <strong><em>timerEvent</em></strong> e adicionar uma simples lógica a ele, como podemos ver logo abaixo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1e6dbdf7c1423168830f5cd2028705d7/href">https://medium.com/media/1e6dbdf7c1423168830f5cd2028705d7/href</a></iframe><p>A lógica por trás do código acima é bem simples: primeiro o objeto do QBasicTimer emite um evento, no qual é ativado o <strong><em>timerEvent</em></strong>, após isso nós verificamos se a variável self.step é igual a 100, caso contrário, incrementamos mais um a ele e inserimos o valor dela no nosso ProgresssBar. E isso se repete até o valor chegar ao número 100. É basicamente como um loop. Podemos ver o resultado na imagem abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/365/1*IgEeJdQUIG6zIrS7XD_AnQ.png" /></figure><h4>Tirando screenshot com PyQt</h4><p>Como mencionado anteriormente, agora teremos um exemplo da utilização dos timers um pouco mais interessante, criando um software para tirar screenshot da nossa tela, like a <strong>KSnapshot</strong>. Isto servirá para um melhor entendimento do seu funcionamento, além de fornecer maiores exemplos sobre a utilização dos timers no PyQt.</p><p>Inicialmente nós iremos, como sempre, realizar as importações necessárias. Necessitaremos das seguintes classes para a interface gráfica: QWidget, QApplication, QPushButton, QLabel, QGridLayout, QFileDialog e QPixmap. Porém não assuste-se, o código ao total tem 60 linhas. As nossas importações ficarão da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4e834e3fb6393d3192560177cae801ca/href">https://medium.com/media/4e834e3fb6393d3192560177cae801ca/href</a></iframe><p>Devemos prestar atenção no código acima. Vemos que a classe QPixmap não foi importada do módulo QtWidgets e sim do módulog QtGui. Como explicado no post de introdução ao PyQt, no PyQt5 a separação das classes de acordo com as suas responsabilidades agora estão bastante definidas em cada módulo. Após isso, vamos declarar a nossa classe e o construtor inicial da mesma.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1f43926d1a781f2483dfc8956822ee50/href">https://medium.com/media/1f43926d1a781f2483dfc8956822ee50/href</a></iframe><p>A quarta linha é a linha que faz o screenshot ser possível no PyQt, ou seja, ela quem faz a mágica acontecer. Nós atribuímos um valor “concreto” para a variável <em>self.preview_screen</em> para que ao usuário iniciar a nossa aplicação ele possa ver em algum local o screenshot da mesma, assim como acontece no software KSnapshot. Ainda no inicializador da nossa classe nós temos os métodos <em>settings(), create_widgets()</em> e <em>set_layout</em>, que servirá para nós criarmos e organizarmos toda a nossa interface. O método <em>settings()</em> e <em>create_widgets</em>() ficarão da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/359e7570c7fec40e7851912f1402dc22/href">https://medium.com/media/359e7570c7fec40e7851912f1402dc22/href</a></iframe><p>Como já sabemos o método <em>settings()</em> insere configurações para a nossa janela, já o <em>create_widgets</em> cria e configura os widgets necessários. Nela criamos um label para exibir um preview do nosso screenshot, criamos dois botões e por fim, conectamos estes botões aos seus respectivos métodos. Pois bem, primeiramente iremos criar o método para salvar a nossa screenshot em algum lugar do computador. Realizar isto é simples, uma vez que necessitamos apenas do diretório e nome do arquivo desejado pelo usuário. Ficará assim:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6eb2fb545671d9cecd559397603bfb85/href">https://medium.com/media/6eb2fb545671d9cecd559397603bfb85/href</a></iframe><p>No trecho de código acima nós primeiramente declaramos duas variáveis que receberiam os valores retornados pelo método <em>getSaveFileName()</em>. Também neste método definimos que o usuário somente poderá salvar imagens .jpg ou .png através do parâmetro <strong><em>filter</em></strong>. Por fim, nós temos dois condicionais para verificar mesmo se o arquivo está com a extensão correta. Caso alguma das condições forem verdadeiras então salvamos o arquivo no local indicado com a sua respectiva extensão.</p><p>O próximo método a ser criado será o <em>new_screenshot()</em> que ficará responsável por retirar um novo screenshot e atualizar a imagem presente no label. Ele ficará da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fbdc67642515fb24f96aa26a7d3076db/href">https://medium.com/media/fbdc67642515fb24f96aa26a7d3076db/href</a></iframe><p>Nele primeiramente nós ocultamos a nossa janela para que ela não apareça no screenshot, após isso nós tiramos o screenshot(como fizemos lá no inicializador da classe), atualizamos a imagem presente no label e por fim mostramos novamente a nossa janela.</p><p>Agora devemos apenas criar uma instância da classe QApplication e todo o resto que nós já sabemos. Sendo assim, temos a nossa aplicação pronta, certo? Então por que não testá-la? Ao executar a nossa aplicação tudo ocorre normalmente, porém quando nós tiramos um novo screenshot acontece o que podemos ver na imagem abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/385/1*xmBnBtZDt1pTl9m-aAo6kA.png" /><figcaption>WE HAVE PROBLEMS!</figcaption></figure><p>Bem, parece que quando tiramos um novo screenshot a nossa aplicação aparece e isto era o que nós não queríamos. Mas e a solução? A solução é utilizar timers!</p><p>Para tal, iremos modificar o método <em>new_screenshot()</em> da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/468597567ce0f5cfcbfb4f273e29c081/href">https://medium.com/media/468597567ce0f5cfcbfb4f273e29c081/href</a></iframe><p>O que o método <em>singleShot()</em> da classe QTimer fará é o seguinte: após 1 segundo ele chamará o método <em>take_screenshot()</em> para tirar o screenshot da nossa tela sem que a nossa aplicação apareça nela. Para finalizar, abaixo do método <em>new_screenshot()</em> vamos definir o método que acabei de citar. Ele ficará basicamente como o <em>new_screenshot()</em> estava anteriormente.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1e720b0a5106c81cf0a9f997d2a73882/href">https://medium.com/media/1e720b0a5106c81cf0a9f997d2a73882/href</a></iframe><p>O método acima tira uma screenshot e armazena na variável <em>self.preview_screen, </em>atualiza a imagem presente no label e por fim, mostra a nossa aplicação de volta. Agora, devemos executar novamente a nossa aplicação e ver o resultado. Para um teste mais conciso vamos tirar um screenshot após a inicialização do software para vermos o que aconteceu.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/386/1*6h2QIcUV9uaCSfV7duMdsA.png" /></figure><p>E tcharam! A nossa aplicação agora funciona perfeitamente graças aos Timers.</p><h3>Dando um agasalho à sua interface</h3><p>Estamos quase no final deste post e nada melhor do que finalizá-lo com um assunto muito importante nos dias de hoje que é a utilização de Threads na nossa interface. Utilizar threads são necessárias em diversos cenários, desde em uma aplicação web, até mesmo no mobile.</p><p>Utilizamos as threads basicamente para solucionar um problema: travamento da nossa aplicação. Quando a nosso software é executado, independente se ele está utilizando algum framework ou não, ele automaticamente possuirá uma thread para poder executar o que ele deve executar, porém os problemas começam a surgir quando nós temos executar algo que trava a thread principal do nosso software, como por exemplo um loop. Para tal, vamos criar inicialmente um simples exemplo de como travar a nossa GUI.</p><p>Inicialmente criaremos mais um arquivo, desta vez denominado de <strong><em>thread_test.py</em></strong> e dentro dele criaremos a estrutura comum de uma janela no PyQt. Após isso, vamos criar um botão que quando ativado irá executar um loop infinito e veremos o que irá acontecer. Este exemplo inicial ficará basicamente da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/13230db86cf4a6a36c9ecb57ef33b739/href">https://medium.com/media/13230db86cf4a6a36c9ecb57ef33b739/href</a></iframe><p>Agora, devemos executar a nossa aplicação e clicar no botão para vermos o que irá acontecer. Bem, como já havíamos previsto a nossa aplicação travou completamente(e se você estiver utilizando o <strong><em>Sublime Text</em></strong>, travou ele junto também). A solução é mais simples do que imaginamos.</p><blockquote><em>Solucionando problemas</em></blockquote><p>Para solucionar esse problema o que temos que fazer é simplesmente criar uma outra thread separada da nossa thread principal para podermos executar este loop sem travar a nossa aplicação. Para tal, poderíamos utilizar módulos presentes no Python, porém, como o PyQt possui classes para isto, vamos utilizar a classe disponibilizada por ele.</p><p>A classe que utilizaremos será a QThread(nome óbvio). O PyQt ainda disponibiliza de outra classe chamada QThreadPool que permite gerenciar multiplas threads de uma forma concisa e simples. A classe QThread, assim como todas as outras abordadas neste tutorial, está presente dentro do módulo QtCore. Iremos criar uma nova classe que será herdada da classe QThread e que também será definida antes da nossa classse em que criamos a nossa janela anteriormente. Então, mãos a obra.</p><p>A nossa importação ficará da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9acf0253b64a6c5731eb87896e81d4bf/href">https://medium.com/media/9acf0253b64a6c5731eb87896e81d4bf/href</a></iframe><p>Após isso, declaramos a nossa classe que herdará da classe QThread. Neste contexto ela não necessitará de um inicializador, já que não iremos utilizar nenhum parâmetro para a nossa classe neste exemplo. Sendo assim, definimos nela apenas o método <strong><em>run()</em></strong>, que será chamado automaticamente quando chamarmos o método <strong><em>start()</em></strong> através do objeto da nossa classe. Vejamos logo abaixo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/13eb9624f4299a2d1f9c4e49b2e28da1/href">https://medium.com/media/13eb9624f4299a2d1f9c4e49b2e28da1/href</a></iframe><p>Também iremos modificar o método que está conectado ao botão para ele chamar a thread e não executar o loop diretamente. Sendo assim, o nosso método ficará da seguinte forma:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1e57d8e06268008891c39c38a1c064b3/href">https://medium.com/media/1e57d8e06268008891c39c38a1c064b3/href</a></iframe><p>Ao executar a aplicação novamente percebemos que ela ainda continua a mostrar o print declarado no loop, porém desta vez a aplicação não trava e continua a funcionar normalmente.</p><blockquote><em>Indo um pouco mais além</em></blockquote><p>Agora que sabemos como funciona basicamente a classe QThread podemos criar algo um pouco mais avançado para explorarmos ainda mais esta classe e as funcionalidades do PyQt. Para tal, criaremos um software para fazer download de músicas no formato mp3.</p><p>Antes de começarmos, devemos ter pelo menos uma ideia de como será fundamentada a nossa interface, porém, como este é um tutorial nós já possuímos o resultado dela pronta. Sendo assim, ao final deste tópico nós teremos a seguinte aplicação:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/314/1*3P0iHQOPwiupTRjTDGuFSQ.png" /><figcaption>Resultado final da nossa aplicação.</figcaption></figure><p>Baseado nesta interface podemos de cara definir quais são as classes que precisamos para criá-la. São elas: QFormLayout, QLineEdit, QPushButton, QWidget e QFileDialog. Outras classes que utilizaremos para implementar outras funcionalidades presentes no software serão: QThread, QRegExp e requests. As nossas importações ficarão da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9bba88696c3e146d11f21f5f0097c9f5/href">https://medium.com/media/9bba88696c3e146d11f21f5f0097c9f5/href</a></iframe><p>A primeira classe que criaremos será a responsável por realizar o download do arquivo mp3 e salvá-lo no computador. Como já sabemos, esta classe herdará da classe QThread. Também receberá três parâmetros na sua instanciação, sendo eles: o nome do arquivo, o local onde deveremos salvar o arquivo e a url para fazer o download. Ficará da seguinte forma:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6390824ea99e811fbf1f3146e80efa82/href">https://medium.com/media/6390824ea99e811fbf1f3146e80efa82/href</a></iframe><p>No método <strong><em>run()</em></strong> o que fazemos basicamente é: mesclar o local em que o usuário selecionou para salvar o arquivo com o nome que ele deseja e depois realizamos o download do arquivo através da biblioteca <strong><em>requests</em></strong> que foi importada logo acima. Após isso vamos definir uma segunda classe, porém, desta vez contendo a nossa interface gráfica.</p><p>No inicializador da nossa classe vamos definir a ordem de chamada dos métodos que criarão e organizarão a nossa interface. Ficará da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ea384a267abf386c9ace223c2459562d/href">https://medium.com/media/ea384a267abf386c9ace223c2459562d/href</a></iframe><p>Nela podemos ver que uma variável foi declarada, esta chamada de <em>self.path</em>. Ela ficará responsável por armazenar o diretório onde deveremos salvar a música. O método <em>settings()</em> e o <em>create_widgets()</em> ficarão da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bf3e065f3ba0d3f385789e7bc2f66a62/href">https://medium.com/media/bf3e065f3ba0d3f385789e7bc2f66a62/href</a></iframe><p>No <em>settings()</em> definimos algumas configurações para a nossa janela. No <em>create_widgets()</em>, como já esperado, definimos os widgets que utilizaremos e realizamos duas conexões: A primeira delas é conectando o objeto <em>self.btn_select_path</em> ao método <em>select_path</em>(), e a segunda é conectando o objeto <em>self.btn_down</em> ao método <em>download()</em>. Para finalizar a interface, deveremos organizá-la dentro de um layout. Para tal utilizaremos a classe QFormLayout, pois para a forma com que está apresentada a organização dos widgets é a mais condizente(estudaremos isso no próximo capítulo).</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e607152e9893d22a890ab94c7225d7d5/href">https://medium.com/media/e607152e9893d22a890ab94c7225d7d5/href</a></iframe><p>Agora iremos criar dois métodos, estes que estão conectados aos dois botões descritos no método <em>create_widgets()</em>. Ficará assim:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a31cc574db7319a48d33e3cc32b4e94c/href">https://medium.com/media/a31cc574db7319a48d33e3cc32b4e94c/href</a></iframe><p>Os dois métodos acima são bem simples, uma vez que o primeiro apenas exibe uma caixa de diálogo perguntando ao usuário em qual diretório salvar a música e logo atribuindo este valor retorna a variável <em>self.path</em>. O segundo método contém referências(chamadas) para outros métos que criaremos a seguir. O <em>verify_fields()</em>, como o próprio nome já diz, verifica se os campos(diretório onde salvar o arquivo, nome do arquivo e url da música) estão preenchidos corretamente. Caso estejam então chamamos o método <em>manage_interface()</em> com o parâmetro <strong>False</strong>, indicando que nós queremos desabilitar todos os widgets e posteriormente chamamos o método <em>thread_qt()</em> que criará um objeto da classe DownloaderMusic(criada anteriormente) passando os parâmetros necessários, além de iniciar o download.</p><p>O método <em>verify_fields()</em> ficará da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/591905dbbddf1ab8aba216bc9a6ae728/href">https://medium.com/media/591905dbbddf1ab8aba216bc9a6ae728/href</a></iframe><p>O interessante do método acima é que ele utiliza a classe QRegExp para poder validar os campos, onde na verdade nós poderíamos muito bem utilizar um módulo do próprio Python, porém nós devemos seguir a seguinte lógica(há exceções para isso): Se existe uma funcionalidade no PyQt, utilize-a e esqueça as opções externas a ela.</p><p>Agora, deveremos criar os métodos <em>thread_qt()</em> e <em>manage_interface()</em>. Eles ficarão da seguinte maneira:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/882c2a1180a850d3131a2436e90de130/href">https://medium.com/media/882c2a1180a850d3131a2436e90de130/href</a></iframe><p>No método <em>thread_qt</em> percebemos que temos um outro objeto conectado a um outro método, ou seja, o objeto <em>self.thre</em> está conectado ao método <em>self.downfin</em> com a condição de quê: Quando a thread for finalizada chame-o. Sendo assim, também deveremos criá-lo por outro motivo: quando nós iniciamos o download nós simplesmente desabilitamos os widgets da nossa aplicação para o usuário(bobalhão) não ficar mexendo nela sem necessidade. Quando o download termina não tem porquê os widgets ficarem desabilitados, sendo assim, temos que reabitá-los para o usuário poder utilizar novamente o software. E aproveitando o gancho podemos mostrar uma notificação para o mesmo de quê o download foi finalizado com sucesso. Este método ficará da seguinte forma:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/44420326e7d0d6252ff80af315fd1893/href">https://medium.com/media/44420326e7d0d6252ff80af315fd1893/href</a></iframe><p>A classe QSystemTrayIcon também fornece outras funcionalidades como por exemplo exibir um ícone do seu programa na sessão de ícones ocultos da barra de tarefas do Windows. No código acima ela apenas exibe uma mensagem com o título:”Download Finalizado”; e a frase:”O download da sua música foi realizado com sucesso”. Também definimos que a mensagem ficará exibida por 3 segundos. Por fim, reabilitamos a interface.</p><p>Para finalizar este software, vamos criar uma instância da classe QApplication e realizar aqueles procedimentos padrões que já conhecemos.</p><h3>Finalizando</h3><p>Pois bem, chegamos a mais um final de um post sobre o PyQt5. Embora tenha sido um post um tanto grande, isto não é tudo sobre o módulo QtCore, e sim uma parte dele. Por exemplo no módulo QtCore nós temos a possibilidade de manipular arquivos, manipular arquivos JSON(veremos na quarta parte), manipular arquivos XMLs, dentre outros.</p><p>Neste post iniciamos introduzindo os conceitos básicos sobre Signals e Slots, exploramos um pouco os Signals, posteriormente aprendemos sobre Handler Events e fizemos com que um QLabel reconhecesse um clique. Após isso iniciamos os nossos estudos sobre temporizadores(Timers) onde nos foi apresentado dois exemplos para uma melhor compreensão. Por fim, conhecemos um pouco da classe QThread criando um software para realizar download de arquivos mp3.</p><p>No próximo post iremos desbravar o mundo colorido e reluzente das GUIs, onde aprenderemos sobre Dialogs, Main Windows, a agilizar a criação da interface com QtDesigner, layouts e muito mais.</p><p>Então é isso, e até a próxima.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=22ba4187531" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PyQt5 — O fantástico mundo das GUIs]]></title>
            <link>https://medium.com/@wilfilho/pyqt5-o-fantastico-mundo-das-guis-62914b1b39c1?source=rss-71b7ac064dab------2</link>
            <guid isPermaLink="false">https://medium.com/p/62914b1b39c1</guid>
            <dc:creator><![CDATA[Wilson Martins]]></dc:creator>
            <pubDate>Thu, 20 Nov 2014 23:30:15 GMT</pubDate>
            <atom:updated>2018-07-09T20:32:02.809Z</atom:updated>
            <content:encoded><![CDATA[<h3>PyQt5 — O fantástico mundo das GUIs</h3><p>Introduzindo estudos à nova versão do Qt com Python</p><p>Na realidade, eu escrevi esse post quando a versão 5.2 do PyQt foi lançado no qual continha lindas e relevantes modificações no mesmo. Porém, apenas estou postando agora. Atualmente o PyQt5 está versão <a href="http://www.riverbankcomputing.com/news/pyqt-54">5.4</a>, e possui algumas modificações interessantes.</p><p>Percebo que não há muitos tutoriais que abordam o PyQt, principalmente o PyQt5, sendo assim, resolvi criar esta série de tutoriais. Poderíamos falar, por que não utilizar a documentação? Para quem está iniciando eu creio que seja mais difícil encarar a documentação. Apesar dela possuir todas as informações sobre o que queremos, nós não sabemos quais dessas centenas de informações olhar primeiro, para assim termos um avanço gradual. Este conjunto de posts é justamente para dar um caminho bem iluminado para quem tem interesse em conhecer o PyQt.</p><blockquote>Faço uma ressalva da <a href="http://python-gtk-3-tutorial.readthedocs.org/en/latest/">documentação do PyGtk</a>, que é muito boa.</blockquote><p>Este é o primeiro artigo de uma série de diversos outros onde abordarei o funcionamento e execução da nova versão do Qt utilizando o Python. Inicialmente será um conjunto de artigos, como descrito anteriormente, que depois poderão se transformar em vídeo aulas, havendo uma chance um tanto remota da realização do mesmo. Espero que todos possuam uma ótima leitura e conhecimento, para tal, podermos discutirmos em um momento posterior.</p><blockquote><strong>Nota:</strong> Este conjunto de artigos são baseados na documentação do <a href="http://qt-project.org/doc/qt-5/index.html">Qt5</a>.</blockquote><p>Para não nos perdemos ao longo das postagens, resolvi criar um roteiro para seguirmos e aprendermos de forma gradual sem muitas dificuldades. Seguiremos o seguinte roteiro:</p><p><strong><em>#1 — Introduzindo conceitos e estudos sobre o PyQt5</em></strong></p><p><a href="https://medium.com/@wilfilho/conhecendo-o-coracao-e-as-arterias-do-pyqt5-22ba4187531"><strong><em>#2 — Conhecendo o coração e as artérias do PyQt5</em></strong></a></p><p><strong><em>#3 — Entendendo e utilizando os componentes visuais(widgets)</em></strong></p><p><strong><em>#4— Gerenciando diversos tipos de armazenamentos de dados</em></strong></p><p><strong><em>#5 — Realizando deploy de uma aplicação desktop</em></strong></p><p>Antes de abordamos de fato as características dos filhos do Qt, vamos entender o que é o Qt em si. Creio que alguns nunca tenham ouvido sequer falado do Qt, então vamos iniciar dos seus primórdios.</p><p><strong>Conhecendo algumas características do Qt</strong></p><p>O Qt é um framework multiplataforma, criado originalmente no C++ para desenvolver aplicações desktop. Inicialmente mantido e criado pela empresa TrollTech e agora mantido pelo Qt Project. É e foi utilizado por diversas empresas de grande renome no mundo tecnológico, tais como a Google, NASA, Disney, Samsumg, Philips, Volvo, etc. Apesar do Qt ser um framework inicialmente criado para desenvolver aplicações desktop, acabou sendo portado para outras plataformas, onde podemos citar o mundo mobile. Hoje ele suporta grande parte dos sistemas mobile, como o Android, IOS, Windows Mobile, BlackBerry, (o extinto) Symbian e o Maemo. Porém, não paramos por aí, o Qt ainda influenciou, influencia e serviu como base para a criação de ambientes desktop, podendo citar o conhecido KDE e o recém chegado LXQt.</p><p>Quando o Qt foi desenvolvido, por volta de 1991–1992, ainda não existiam parte das linguagens famosas que conhecemos hoje, como por exemplo o Ruby ou o Java. Com o surgimento dessas linguagens e o aprimoramento das mesmas, o Qt acabou sendo portado para elas, originando assim, os bindings do Qt. Hoje existe uma série de bindings para diversas linguagens. No Ruby o binding do Qt é chamado de QtRuby, no Java de QtJambi, no C# de Qyoto, na linguagem Lua é chamado de QtLua e assim por diante. No Python existem dois bindings, sendo eles, o PyQt e o PySide. Como podemos observar, dentre as linguagens citadas anteriormente somente o Python possui dois bindings para o Qt.</p><p>O Qt é licenciado basicamente de três formas. Vejamos logo abaixo:</p><p><strong>Licença comercial</strong>: A licença comercial do Qt não é obrigatória, mas sim recomendada para criar aplicações comerciais, onde desejamos vender aplicações com que utilizam o Qt, desejamos possuir um maior suporte e ferramentas prontas e não disponibilizar o código fonte para o usuário. Além disso, a licença comercial do Qt fornece um conjunto de funcionalidades e ferramentas que não estão presentes nas outras formas de licença adquiridas e aceitas pelo Qt. A empresa que mantém a versão comercial do Qt é a <a href="http://qt.digia.com/">Digia</a>, que é uma empresa Finlandesa de software. Esta licença também está atrelada ao <a href="http://qt.digia.com/Product/Qt-Enterprise/">Qt Enteprise</a>.</p><p><strong>Licença LGPL</strong>: Creio que todos conheçam este tipo de licença, fazendo com que o Qt possa ser utilizado dentro dos limites da licença LGPL. O Qt utiliza a versão 2.1 da licença LGPL e possui também uma exceção para o desenvolvimento de aplicações comerciais utilizando a mesma.</p><p><strong>Licença GPL</strong>: O Qt também pode ser adquirido através da licença GPL v3, contanto que você respeite(novamente) os limites da mesma. Inclusive o PyQt obtém o Qt através da linceça GPL.</p><p>Por fim, o Qt possui duas linguagens próprias, sendo elas o QML e o QtScript. Onde o QML também é utilizado na criação de aplicativos para a versão <a href="http://developer.ubuntu.com/apps/qml/">mobile do Ubuntu</a> e o QtScript foi baseado no <a href="http://pt.wikipedia.org/wiki/Ecmascript">Ecmascript</a>. A principal ferramenta utilizada para a criação e desenvolvimento utilizando o Qt é o Qt Creator, porém possuem diversas outras opções específicas para determinadas linguagens.</p><p><strong>Conhecendo o PyQt</strong></p><p>Como já mencionado, o PyQt é um dos bindings do Python para o Qt. Foi criado e é mantido pela Riverbank Computing. A IDE utilizada no PyQt é o QtDesigner, que é substancialmente diferente do QtCreator, pois não possui suporte ao QML nem ao QtScript. Basicamente o PyQt possui um dual license, onde há a presença da licença GPL(na terceira versão)para a criação de aplicações open source(e que respeitem os termos dessa licença) e a licença comercial, destinada obviamente, para a criação e distribuição de aplicações comerciais utilizando o PyQt.</p><p>O PyQt utiliza-se de uma das características principais do Python. Para que você entenda de uma forma mais simplificada, o PyQt nada mais é do que a junção do útil ao agradável. No qual detém todo o poder e riqueza do Qt, utilizando toda a praticidade e produtividade que o Python oferece ao desenvolvedor. Caso deseje obter uma base de aplicações feitas com o PyQt, acesse o seguinte <a href="https://wiki.python.org/moin/PyQt/SomeExistingApplications">link</a>. Em meio a esta lista, podemos destacar aplicações como a Eric IDE e a Spyder IDE. Outra aplicação de muito destaque no Python e que utiliza o PyQt é a Ninja IDE. Esses são poucos exemplos de uma série de outras aplicações que o utilizam.</p><p><strong><em>Introdução ao PyQt5</em></strong></p><p>O PyQt5 traz grandes mudanças em relação ao PyQt4(como já descrito). Uma grande e fundamental dessas mudanças é a presença de novos módulos e consequentemente novas classes, deixando biblioteca mais flexível a diversos tipos de situações. Antes de iniciarmos a parte prática, vamos deter um pouco de conhecimento sobre esses módulos. Vejamos a seguir:</p><p><strong><em>QtCore:</em> </strong>Como o seu próprio nome já nos descreve, este módulo é responsável por cuidar e oferecer todas as funcionalidades relacionadas ao core do PyQt. Sendo assim, temos como exemplo: gerenciamento de sinais, eventos, slots, arquivos, threads, expressões regulares, alocação de memória, temporizadores e algumas outras funcionalidades.</p><p><strong><em>QtGui</em></strong>: No PyQt4 ele era responsável por armazenar os mais diversos tipos de widgets, desde aqueles de mais baixo nível até os de mais alto nível. Agora, no PyQt5, ele foi dividido em dois, sendo o outro módulo chamado de QtWidgets. O QtGui ficou com a função de ser um módulo de GUI base, fornecendo suporte a tratamento de imagens, textos, renderização de gráficos 2D e integração com o OpenGL.</p><p><strong><em>QtWidgets</em></strong>: Um dos pontos interessante dessa nova versão do Qt, é a nomenclatura dos módulos que as deixa mais amigáveis aos desenvolvedores. O módulo QtWidgets ficou responsável por armazenar todos os widgets de alto nível presentes no PyQt. Exemplo: nele podemos encontrar os mais diversos tipos de layout(QGridLayout, QFormLayout, QHBoxLayout, etc), à até mesmo botões, áreas de texto, locais para inserir datas, janelas, etc.</p><p><strong><em>QtSql</em></strong>: Este módulo trata diretamente com o acesso a dados, mais especificamente, o acesso ao banco de dados. É possível conectar, criar, remover e clonar conexões, além é claro, de realizar consultas no banco de dados através de 11 classes que suprem totalmente as nossas necessidades. Dentro dessas 11 classes, ainda estão incluídas 2 classes(QSqlTableModel e QSqlQueryModel) que implementam o paradigma Model/View, onde os dados fornecidos por essas classes podem ser utilizados diretamente em componentes visuais, como QListView e QTableView.</p><p><strong><em>QtTest</em></strong>: Hoje em dia, a criação de testes de unidade nos nossos projetos é indispensável, uma vez que torna o nosso projeto mais limpo e parcialmente livre de bugs posteriores que venhamos a ter. Este módulo trata exatamente disso, possuindo uma diferença em relação ao seu pai(o Qt), onde este não implementa a realização dos testes igualmente à forma do Qt, em vez disso, utiliza-se dos componentes padrões do Python utilizados para realizar testes de unidade e simula ações realizadas pelos usuários. Nela podemos testar diretamente diversos tipos de eventos, como por exemplo: podemos testar se um botão está realmente sendo ativado por determinado sinal, através de métodos disponibilizados pela classe QTest, tais como <em>mouseClick()</em>, <em>mousePress() ou mouseReleased()</em>. Sendo os métodos anteriores relacionados diretamente aos sinais suportados por um botão no PyQt.</p><p><strong><em>QtNetwork</em></strong>: Apesar de ser um módulo extra, digamos assim, é indispensável dentro do PyQt devido ao fato de que uma quantidade muito grande de aplicações utilizam-se da realização de conexões para se conectar com o que quer que seja. Neste módulo é possível construir clientes e servidores UDP, TCP, HTTP, SSL e FTP. No PyQt4 ele somente suporta IPv4, porém nesta nova versão, o IPv6 também é suportado. Outra funcionalidade interessante é o suporte a conexões baseadas no protocolo TCP e a utilização de certificados SSL.</p><p><strong><em>QtWebKit</em></strong>: Seguindo a mesma linha do QtGui, o QtWebKit na nova versão do Qt foi divido em dois, onde uma parte(QtWebKit) ficou responsável por tratar o core deste módulo e o <strong><em>QtWebKitWidgets</em></strong>, ficou responsável disponibilizar a parte visual da mesma. Ou seja, dentro do QtWebKit estão classes como: QWebHistory(responsável por tratar o histórico de navegação), QWebSettings, QWebElement, etc. Enquanto dentro do módulo QtWebKitWidgets ficam classes como: QWebView(utilizada para exibir páginas web), QWebInspector, QWebFrame, etc.</p><p><strong><em>QtSvg</em></strong>: Módulo simples que permite realizar a leitura e renderização de arquivos svg. Este módulo ainda implementa uma classe chamada QSvgWidget, que permite de forma prática a visualização do conteúdo adquirido com a renderização de um arquivo sgv.</p><p><strong><em>QtXml</em></strong>: Os arquivos XML são utilizados nos mais diversos tipos de aplicações e plataformas, seja ela mobile, desktop ou na web. É claro que o PyQt não poderia deixar de ter módulos exclusivamente para tratar deste tipo de arquivo. Este módulo contém classes que implementam as interfaces SAX e DOM do XML. Um outro módulo que incrementa a utilização do XML no PyQt é o <strong>Q<em>tXmlPatterns</em></strong>, que implementa o suporte para o XQuery e o XPath e a customização de data models no XML.</p><p><strong><em>QtMultimedia:</em></strong> Nesta nova versão do Qt, este módulo foi bem ampliado, uma vez que em versões anteriores oferecia somente suporte a manipulação e utilização de áudios e vídeos, agora possui suporte a câmera e rádio. Em relação às versões passadas, o QtMultimedia foi divido em dois nesta nova versão, onde a outra parte é chamada de <strong><em>QtMultimediaWidgets</em></strong><em>, </em>que fornece widgets para controle das funcionalidades presentes no <strong><em>QtMultimedia</em></strong>.</p><p><strong><em>QtPrintSupport</em></strong>: Este módulo contém classes que anteriormente estavam presente no módulo QtGui. Ele é responsável por fornecer diálogos e classes para realizar a impressão de documentos.</p><p><strong><em>QtWinExtras, QtMacExtras e QtX11Extras:</em></strong> Outra novidade bastante interessante é a integração total com a parte gráfica do sistema operacional que o usuário está utilizando. O QtWinExtras, permite que nós por exemplo, criemos JumpLists no Windows, coisa que não era possível em versões anteriores. O QtMacExtras e o QtX11Extras seguem a mesma linha e só poderão ser importados no sistema operacional que corresponde a cada um deles.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/354/1*j4hAxcBAwOEdZhEFO2hQpw.jpeg" /><figcaption>Exemplo de uma JumpList no Windows 7.</figcaption></figure><p><strong><em>QtScript</em></strong>: Permite criar scripts automatizados para realizar ações desejadas utilizando o EMACScript com um interpretador do Qt. Pode ser basntante útil em algumas ocasiões. Outro módulo que está na mesma linha que este é o <strong><em>QtScriptTools, </em></strong>provendo de uma classse adicional.</p><p><strong><em>QtPortSerial:</em></strong> Este módulo permite com que nós tratemos comunicações com a porta serial, não tendo que recorrer a outras bibliotecas para desempenhar tal função. Apesar de ser um pouco limitado, atende bem a grande parte dos requisitos, sendo um bom avanço para o PyQt. Conta com duas classes: QPortSerial e QPortSerialInfo.</p><p><strong><em>QtQuick</em></strong>: Provém de todos os tipos básicos para criar interfaces gráficas utilizando o QML, ou seja, possibilita criar interfaces gráficas, animações, data models, etc. Vale ressaltar que este módulo contém todas essas funcionalidades apenas dentro do QML. As classes que estão dentro do módulo QtQuick no PyQt, apenas interpretam os códigos criados utilizando o QML.</p><p><strong><em>QtQml</em></strong>: Este módulo é a ponte de ligação entre o PyQt e o <a href="http://en.wikipedia.org/wiki/QML">QML</a>. Permite tratar, interpretar e implementar funcionalidades do QML no PyQt, como por exemplo: permite implementar a engine do QML para poder interpretá-lo.</p><p><strong><em>QtSensors:</em></strong> Responsável pela manipulação de sensores, este módulo é apenas suportado na versão mobile do Qt, onde podemos citar como exemplo algumas plataformas, tais como: <a href="http://qt-project.org/doc/qt-5/android-support.html">Android</a>, <a href="http://qt-project.org/wiki/BlackBerry">BlackBerry 1</a>0, <a href="http://qt-project.org/doc/qt-5/ios-support.html">iOS</a>, <a href="https://sailfishos.org/">SailFish</a>and e <a href="http://qt-project.org/doc/qt-5/winrt-support.html">WinRT</a>.</p><p><strong><em>QtWebSockets</em></strong>: Como já podíamos esperar, o Qt5 não deixaria de fora uma tecnologia tão recentemente quanto a <a href="http://pt.wikipedia.org/wiki/WebSocket">WebSockets</a>.</p><p><strong><em>QtDesigner</em></strong>: Módulo que permite criar plugins personalizados para o QtDesigner. Este módulo é essencial, pois você pode adaptar a própria IDE às suas necessidades.</p><p><strong><em>Resumindo o PyQt5</em></strong></p><p>Pudemos ver uma grande quantidade de módulos anteriormente, e de fato, estes não são todos os módulos do PyQt5, por exemplo: possuímos ainda o módulo Enginio e o QtPositioning, que não foram abordados. Acima, estão apenas os módulos mais utilizados e notórios.</p><p>O PyQt5 traz um grande conjunto de modificações em relação ao PyQt4. Iniciando desde a organização dos módulos até novos conceitos que agora possuímos. No PyQt4 tínhamos pouco mais de 20 módulos, no PyQt5 temos quase 30 módulos que deixam a biblioteca muito abrangente e flexível a diversos cenários.</p><p>Na organização dos módulos percebemos que o QtGui foi dividido em três, onde possuímos o QtWidgets, QtPrintSupport e o próprio QtGui. A mesma coisa aconteceu com os módulos QtMultimedia e QtWebKit. Aliás, o QtWebKit, que na versão 4 do Qt utilizava o WebKit 1, agora passa a utilizar o WebKit 2, dando suporte às tecnologias web mais recente, como o HTML5 e CSS3, além de dar uma maior performance na renderização das páginas. Com essa nova organização, o nome dos módulos se tornam mais semânticos e amigáveis para todos os níveis de desenvolvedor, onde cada um foi nomeado de acordo com a sua função.</p><p>Além da organização dos módulos, houve um acréscimo na quantidade dos mesmos, onde percebemos o surgimento do QtQml, QtQuick, QtPortSerial, QtSensors, QtPositioning, QtQuick, etc. Na versão anterior, as classes responsáveis por criar um elo entre o PyQt e o QML ficavam em um módulo chamado QtDeclarative, porém agora, este módulo foi excluído e possuímos o QtQuick e o QtQml, que nos fornece uma melhor tratamento destes tipos de interfaces gráfica. O QtPortSerial nos possibilita ter uma interação com a comunicação serial, sem necessitarmos utilizar uma outra biblioteca, além de nos poupar um bom tempo.</p><p>O surgimento do <em>QtWinExtras, QtMacExtras e QtX11Extras</em>, também são de extrema importância, uma vez que possibilitam uma maior portabilidade e integração com o ambiente gráfico no qual o usuário está utilizando. É crível que as demais bibliotecas de interfaces gráficas presentes no Python não possibilite este tipo de funcionalidade, adicionando um ponto de vantagem para o PyQt.</p><p>A ampliação dos módulos também é uma característica marcante em relação a versão anterior, uma vez que módulos como o QtNetwork e o QtCore recebem um upgrade para suportar as tecnologias mais atuais. No QtNetwork temos o suporte ao IPv6, utilização de certificados SSL, dentre outros. No módulo QtCore podemos perceber a presença de classes que permitem tratar arquivos JSON, também, fazendo com que não necessitemos recorrer à bibliotecas de terceiros. Podemos ver ainda no QtCore, a presença de classes que possibilitam tratar de uma forma ainda melhor as threads.</p><p>Não podemos deixar de destacar alguns projetos que surgem paralelos ao PyQt5. O <a href="http://pyqt.sourceforge.net/Docs/pyqtdeploy/"><em>pyqtdeploy</em></a>, como o próprio nome já nos diz, permite realizar o deploy de aplicações criadas com o PyQt4 e PyQt5, não necessitando recorrer à bibliotecas como o py2exe ou cx_Freeze. O <a href="http://pyqt.sourceforge.net/Docs/dip/"><em>dip</em></a>, também é outro projeto de extrema importância para projetos que prezam pelas boas práticas, possuindo diversas abstrações que agilizam o nosso desenvolvimento quando utilizados tais quesitos(sempre :P).</p><p>Por fim, podemos destacar uma forte presença e incentivo do Qt em utilizarmos o QML na GUI da nossa aplicação. O QML já estava presente no Qt desde versões passadas, porém agora, pelo que podemos ver, o mesmo recebeu um conjunto de upgrades que permite ao desenvolvedor possuir não só uma renderização mais rápida, mas também um riqueza visual muito grande e um melhor desempenho.</p><p><strong><em>Instalando o PyQt5 no Windows</em></strong></p><p>Atualmente os binários do PyQt5 para o Windows somente estão disponíveis para a versão 3.4 do Python, sendo assim, caso não tenha esta versão do Python, trate de baixá-la e instalá-la.</p><p>Para realizar a instalação é muito simples. Antes de mais nada, vamos fazer o download do PyQt5. Para tal, deveremos acessar o seguinte link: <a href="http://www.riverbankcomputing.com/software/pyqt/download5">http://www.riverbankcomputing.com/software/pyqt/download5</a>. Você deverá selecionar a versão mais condizente com o seu sistema operacional. Caso você realize o download da versão errada, terá problemas ao importar o PyQt.</p><p>Após realizarmos o download, deveremos executar o arquivo e clicar em Next(forevermente). Feito isso, o PyQt5 já estará instalado no seu computador. Para termos certeza se ele foi instalado com sucesso, deveremos abrir o interpretador do Python e executar a seguinte linha:</p><p><strong><em>&gt;&gt;&gt; from PyQt5 import QtWidgets</em></strong></p><p>Poderá ocorrer um erro na importação se você não baixou a versão correta(como já descrito). Para resolver isto, basta baixar a outra versão.</p><p><strong><em>Instalando o PyQt5 no Mac OS X</em></strong></p><p>Para facilitar a instalação do PyQt5 no Mac OS X, utilizaremos o gerenciador de pacotes <a href="http://pt.wikipedia.org/wiki/Homebrew"><em>Homebrew</em></a><em>. </em>Caso não o tenha instalado(but, what?), execute a seguinte linha de comando no seu terminal:</p><p><strong>$</strong> <em>ruby -e “$(curl -fsSL </em><a href="https://raw.githubusercontent.com/Homebrew/install/master/install"><em>https://raw.githubusercontent.com/Homebrew/install/master/install</em></a><em>)&quot;</em></p><p>Após isto, teremos o <em>Homebrew</em> instalado. Agora deveremos executar mais uma linha de comando.</p><p><strong>$</strong> <em>brew install pyqt5</em></p><p>Para verificar se o PyQt5 foi realmente instalado no seu Mac, vamos realizar os mesmos procedimentos da instalação no Windows, porém com uma diferença. Deveremos fechar o terminal e abri-lo novamente. Após termos aberto o terminal, vamos abrir o terminal do Python e executar a seguinte linha:</p><p><strong><em>&gt;&gt;&gt; from PyQt5 import QtWidgets</em></strong></p><p>Caso possua algum erro, é recomendável que instale o PyQt5 manualmente. Para tal, você precisa baixar o source do PyQt5 e compilá-lo(se vira rapá!).</p><blockquote><strong>Dica</strong>: Baixe e compile o Qt5 antes.</blockquote><p><strong><em>Instalando o PyQt5 no Ubuntu</em></strong></p><p>Pelo fato do PyQt5 não possuir ainda nenhum pacote nos repositórios do Ubuntu, diferentemente do Arch Linux que já possui, temos que fazer tudo na mão. Ou seja, vamos ter que baixar o Qt5, baixar o SIP, o PyQt5 colocar tudo na panela e mexer até ficar pronto.</p><p>A primeira coisa que devemos fazer é instalar o Qt5, pois necessitamos do <strong><em>qmake</em></strong> para poder compilá-lo. Sendo assim, devemos acessar: <a href="http://www.qt.io/download-open-source/">http://www.qt.io/download-open-source/</a>. Você deverá baixar a versão mais condizente com o seu sistema operacional.</p><blockquote><strong>Dica</strong>: você pode utilizar o <strong><em>wget</em></strong> para baixar.</blockquote><p>Após baixarmos o Qt5, devemos instalá-lo obviamente. É interessante darmos permissão ao arquivo, sendo assim, execute a seguinte linha:</p><pre>$ chmod +x qt-opensource-linux-x64-5.4.0.run</pre><blockquote><strong>Atenção</strong>: se o nome do seu arquivo não for este, você deverá modificar a linha acima indicando-o, caso contrário teremos um erro de “<em>no surch file”.</em></blockquote><p>Depois bastamos executar o arquivo, seguir as pages wizards até o final. Antes de baixarmos ou insalarmos o PyQt5, devemos instalar dois pacotes. O <em>build-essential</em> e o <em>python-dev</em>. O último é importante pelo fato do SIP utilizar durante a sua compilação. Devemos executar as seguintes linhas:</p><pre>$ <em>sudo apt-get install build-essential</em></pre><pre>$ sudo apt-get install python3.4-dev</pre><p>Agora que temos estes dois pacotes essenciais instalados, iremos baixar primeiramente o SIP. O SIP na verdade, de uma forma bem resumida, é o senhor que faz toda a mágica do Qt ser possível no PyQt. No PySide temos o Shiboken. Devemos acessar o seguinte link: <a href="http://www.riverbankcomputing.com/software/sip/download">http://www.riverbankcomputing.com/software/sip/download</a>. Após o download, devemos entrar na pasta e executar o seguinte comando:</p><pre>$ <em>sudo python3.4 configure.py</em></pre><p>Isto irá preparar os arquivos para nós realizarmos a compilação. Após isso, devemos executar o comando: <strong><em>sudo make</em></strong>. E após este último comando: <strong><em>sudo make install</em></strong>. Feito isso, temos o SIP instalado. Agora, vamos realizar o download do PyQt5. Bastamos acessar o seguinte link: <a href="http://www.riverbankcomputing.com/software/pyqt/download5">http://www.riverbankcomputing.com/software/pyqt/download5</a> e realizar o download. Depois de descompactado, deveremos entrar na pasta e executar o mesmo comando que executamos inicialmente no SIP, ou seja:</p><pre>$ <em>sudo python3.4 configure.py</em></pre><p>Caso possua o seguinte erro: “<em>Error: Use the —qmake argument to explicitly specify a working Qt qmake.”. </em>Isso indica que nós devemos especificar o local do qmake. Este local por acaso está dentro da pasta onde você instalou o Qt5. A estrutura de diretórios até o qmake é a seguinte: qt5_path/5.4/gcc_64/bin/qmake. Caso o não esteja neste diretório, você deverá procurar sempre a pasta bin dentro do local onde foi instalado o seu Qt. Devemos assim, executar o seguinte comando(após termos encontrado o qmake):</p><pre>$ sudo python3.4 configure.py --qmake=/home/will/Qt5.4.0/5.4/gcc_64/bin/qmake</pre><p>Após isto, deveremos executar o comando: <strong><em>sudo make</em></strong> e por fim: <strong><em>sudo make install</em></strong>. Feito isso, teremos o PyQt5 instalado e pronto para uso.</p><blockquote><strong>Extra: </strong>Caso você tenha um erro relacionado a instalação da tool <strong>pyuic5</strong> você deverá fazer o seguinte, executar o configure.py com a opção de <strong>no-tools</strong>. Assim: <strong>python3.4 configure.py —no-tools</strong>.</blockquote><p><strong>Nascendo no fantástico mundo das GUIs</strong></p><p>Bem, após termos tido um conhecimento inicial sobre o PyQt5 e também possuí-lo instalado na nossa máquina, chegou a hora de pormos a mão na massa e partir para algo prático(finalmente, uhu!).</p><p>Sabemos que, antes de mais nada, quando desejamos utilizar uma biblioteca ou uma funcionalidade da mesma, devemos importar o que desejamos. No PyQt5, não é diferente. Sendo assim, inicialmente deveremos realizar as seguintes importações:</p><pre><strong>from</strong> PyQt5.QtWidgets <strong>import</strong> *</pre><pre><strong>import</strong> sys</pre><p>Primeiramente importamos tudo que estiver dentro do módulo QtWidgets. Realizar esta importação é essencial pelo fato de quê, dentro dele possui as classes QApplication e QWidget(classes que utilizaremos nesse exemplo inicial).</p><p>Importamos o sys para não fugir de um padrão nos códigos que utilizam o PyQt. Ele pegará os argumentos da linha de comando e jogará como parâmetro na instanciação da classe QApplication. Entenderemos melhor isto um pouco mais a frente.</p><p>Após realizarmos as importações que desejamos, devemos criar uma classe que conterá as configurações e os widgets presentes na nossa janela. Mas eis que surge uma questão. É possível utilizar o PyQt sem OO? Sim, é possível, porém não é recomendável. A cada instante que o seu código for ficando maior, o mesmo se tornará mais difícil de dar manutenção. Sendo assim, se ainda não sabe OO, sugiro que primeiramente tenha um bom conhecimento para seguir neste tutorial. O tipo de janela que utilizaremos para este exemplo inicial será o QWidget. Deixaremos dessa forma:</p><pre><strong>class</strong> Window(QWidget):</pre><p>No trecho de código acima, podemos ver claramente a presença de uma herança simples, onde estamos herdando da classe QWidget todos os seus objetos e métodos. Além do QWidget, existem mais duas classes que são frequentemente utilizadas como janela top-level das nossas aplicações, sendo elas: QMainWindow e QDialog. A classe QMainWindow, como o próprio nome nos sugere, é uma classe que nos possibilita ter uma janela principal de onde podemos chamar modals dialogs(diálogos filhos, de grosso modo). Nela também há a presença de métodos que facilitam a criação e introdução de alguns widgets, por exemplo: existe métodos para criar barra de status, DockWidgets, toolbars, etc., onde declaramos o método e ele nos retorna uma instância pré-configurada do que queremos. Já a classe QDialog, possui um formato de janela diferente e métodos diferentes, afinal, é uma classe para se criar diálogos. Podemos perceber nela, a presença de apenas um botão para fechar, além dele responder por padrão a algumas teclas, como por exemplo, à tecla Esc. A classe QWidget é a classe mãe de todos os widgets. Isso significa dizer que, botões(QPushButton), áreas de texto(QTextEdit, QLineEdit, QPlainText, etc.), a classe QMainWindow, a classe QDialog e todas as demais que fazem parte do âmbito visual das nossas aplicações derivam dela.</p><blockquote><strong>Pais e filhos</strong></blockquote><blockquote>No PyQt, os widgets podem ser definidos de duas formas: aqueles que não possuem pai(conhecidos como widgets pai) ou aqueles que necessitam de um pai para serem exibidos(conhecido como widgets filho). Aqueles que não possuem pai nada mais são do que janelas top-level, como as classes citadas logo acima: QMainWindow, QDialog e QWidget. Já o segundo tipo de widgets, necessitam de um pai para serem exibidos, ou seja, necessitam de classes como QMainWindow, QWidget ou QDialog para serem mostrados. Exemplos: botões(QPushButton), áreas de texto(QLineEdit, QPlainText, QTextEdit, etc.), barras de rolagem(QScrollbar), abas(QTabWidget), barras de status(QStatusBar), menus(QMenu), etc. Vale fazer uma observação de que a classe QWidget pode assumir os dois papéis, ou seja, pode ser utilizada com um pai ou sem um pai. O PyQt utiliza desse artifício de widgets pai e widgets filhos para ter certeza de que está excluindo tudo que deveria. Por exemplo, quando uma janela utilizando a classe QMainWindow é fechada, ele verifica se a classe QMainWindow é pai ou filho, caso ele seja pai, o mesmo excluirá a QMainWindow e todos os seus filhos, ou seja, todos os widgets que estão dentro dela.</blockquote><blockquote><strong>OBS</strong>: O termo “pai” nesta ocasião está relacionado a palavra “frame”, ou seja, local onde deve ser colocado algo ou deve ser armazenado algo.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/713/1*W5m4ubb2vzbKcVLViIi-Iw.png" /><figcaption>Exemplo de onde são derivadas classes importantes no PyQt.</figcaption></figure><p>Todas as classes, e consequentemente widgets, presentes no PyQt são derivados da classe QObject, seja diretamente ou indiretamente. Dessa forma, por exemplo, a classe QWidget é derivada da QObject, que a classe QMainWindow é derivada da classe QWidget. Para um melhor entendimento devemos observar a imagem acima, onde podemos ver claramente essas heranças. Na mesma imagem podemos ver ainda que a a classe QEvent também é derivada da classe QObject e que possui classes que derivam dela, como por exemplo a QMoveEvent. É claro, existem mais classes que não são derivadas nem da classe QEvent, nem da classe QWidget, que não estão neste exemplo, como por exemplo a classe QAbstractAnimation, que possui 6 classes que são derivadas dela(QVariantAnimation, QPropertyAnimation, QPauseAnimation, QAnimationGroup, QSequentialAnimationGroup e QParallelAnimationGroup).</p><p>Após declararmos a nossa classe, deveremos declarar o inicializador da mesma. O mesmo poderá receber um parâmetro adicional, este chamado de <em>parent</em> e deverá ser atribuído um valor nulo. Vejamos a seguir:</p><pre><strong>def</strong> __init__(self, parent=<strong>None</strong>):</pre><p>O parâmetro <em>parent</em> é utilizado para indicar que nesta janela existe um frame pai, ou seja, um local onde todos os widgets estarão. Neste caso, temos uma janela que agrupará grande parte dos widgets. Ele pode ser simplesmente omitido caso desejares, porém eu sugiro que não, pois é algo padrão no PyQt.</p><p>Agora devemos inicializar a classe da qual estamos derivando, ou seja, a classe QWidget. Utilizaremos o <strong>super() </strong>ao invés das formas convencionais. Ficará da seguinte forma:</p><pre><strong>super</strong>(Window, self).__init__(parent)</pre><p>Estamos chegando às partes finais do nosso script. Deveremos sair do bloco da nossa classe e criar uma instância da classe QApplication, da seguinte forma:</p><pre>root = QApplication(sys.argv)</pre><p>Nesta linha de código estão envolvidas muitas informações, porém vamos por partes. Sempre quando criamos uma instância da classe QApplication, devemos passar como parâmetro uma lista. Por padrão passamos como parâmetro uma lista de informações obtidas na linha de comando, ou seja, passamos como parâmetro o <em>sys.argv</em>. Poderíamos passar uma lista vazia se desejássemos, por exemplo:</p><pre>root = QApplication([])</pre><p>Ainda sobre o trecho de código acima, é de extrema importância criar uma instância da classe QApplication, pelo seguintes motivos:</p><p>1 — A classe QApplication é responsável habilitar o tratamento de eventos na nossa aplicação. Sem tratamento de eventos, ou seja, sem reconhecimento de ações, sem reações.</p><p>2 — É responsável por adquirir características gráficas do sistema operacional, tais como cores e fontes. Isso é importante pois deixa a aplicação nativa e padronizada.</p><p>3 — Caso não criemos, a nossa janela não será apresentada pelo simples fato de quê não conseguiremos criar o loop para exibir a nossa aplicação, ela também não será alocada na memória, além dos dois itens citados anteriormente.</p><blockquote><strong>Não olhe apenas em uma única direção</strong></blockquote><blockquote>Vimos logo acima que se não criarmos uma instância da classe QApplication a nossa interface não poderá ser mostrada, porém isso não é tudo. Nós podemos dispensar a utilização da classe QApplication, pela utilização da classe QCoreApplication ou QGuiApplication dependendo da ocasião. Para definirmos a utilização de cada uma dessas classes é simples, vejamos: Quando a nossa aplicação for algo normal, ou seja, possuir interface gráfica(maioria dos casos) e possuir classes baseadas na classe QWidget, então nós utilizamos a classe QApplication; Quando a nossa aplicação não possuir interface e apenas for utilizada na linha de comando, utilizamos a classe QCoreApplication; Quando a nossa aplicação não utilizar classes que se baseiam na classe QWidget e possuir interface, então utilizamos a QGuiApplication(poucos casos). Talvez agora, quando você for criar algo utilizando o PyQt ficará se perguntando sobre qual utilizar, QGuiApplication ou QApplication. Bem, a dica que posso dar é a seguinte: sabemos que todos os widgets presentes no PyQt são derivados da classe QWidget, então sabemos que vamos utilizar a classe QApplication. Outro ponto interessante de se analisar neste tipo de ocasião é se a minha aplicação possui uma janela ou não, se possuir então você utiliza a classe QApplication. A classe QGuiApplication é e deve ser somente utilizada em casos específicos. Por via das dúvidas, utilize QApplication.</blockquote><blockquote><strong>Extra: </strong>Um local onde o podemos ver bastante a presença do QGuiApplication é na integração do PyQt com o QML, pois nesta ocasião não há a presença de classes baseadas na QWidget.</blockquote><p>Temos também que criar uma instância da nossa janela principal, ou seja, da classe Window e imprimi-la utilizando o método <em>show()</em>. Podemos ter diversas janelas dentro de um único arquivo, sendo assim é importante definir qual será a principal e quais serão as janelas filhas. Ficará da seguinte forma:</p><pre>app = Window()</pre><pre>app.show()</pre><p>O método <em>show() </em>está presente em grande parte dos widgets e serve para exibir algo na tela.</p><p>Por fim, temos que criar um loop infinito, onde a nossa interface será mostrada infinitamente(:P) até que o usuário a feche. Para isso, deveremos escrever a seguinte linha de código:</p><pre>sys.exit(root.exec_())</pre><p>O <em>sys.exit()</em> garantirá que a nossa janela será fechada corretamente, além de que os pixels serão “limpos” quando a mesma for fechada. O código final, ficará da seguinte maneira:</p><pre><strong>from </strong>PyQt5.QtWidgets <strong>import </strong>*<br><strong>import </strong>sys</pre><pre><strong>class </strong>Window(QWidget):<br>    <strong>def </strong>__init__(self, parent=<strong>None)</strong>:<br>        <strong>super(</strong>Window, self).__init__()</pre><pre>root = QApplication(sys.argv)<br>app = Window()<br>app.show()<br>sys.exit(root.exec_())</pre><p><strong><em>Importando da forma correta, definindo título e algo mais</em></strong></p><p>Agora que detemos conhecimento sobre como criar uma janela utilizando o PyQt e quais são os trechos de códigos básicos, iremos brincar um pouco com a nossa janela que foi criada anteriormente.</p><p>A forma com a qual importamos o que queríamos é a menos apropriada possível, pois de acordo com as convenções de código do Python, nós estamos diminuindo a legibilidade do nosso código, uma vez que não estamos especificando o que usamos. Sabemos que as classes que utilizamos para criar o nosso hello world foram: QWidget e QApplication. Sendo assim, iremos modificar a primeira linha do nosso script para que a mesma fique da seguinte forma:</p><pre><strong>from</strong> PyQt5.QtWidgets <strong>import </strong>QApplication, QWidget</pre><blockquote><strong>Dica</strong>: No início do post foram apresentados diversos módulos descrevendo cada um deles, justamente para sabermos qual devemos utilizar e quais classes utilizar. Sendo assim, quando não souber qual módulo utilizar basta ir até o mesmo para acender uma luz na sua mente. E jamais importe tudo, apenas o necessário.</blockquote><p>Modificar o título da janela é uma tarefa bem simples, precisamos apenas utilizar o método <em>setWindowTitle()</em>, que receberá como parâmetro uma string. Dentro do bloco do inicializador da nossa classe, deveremos escrever a seguinte linha:</p><pre>        self.setWindowTitle(&quot;Hello World&quot;)</pre><p>Modificar o tamanho da nossa janela é tão simples quanto modificar o título. Podemos utilizar dois métodos, sendo eles: <em>resize()</em> ou <em>setGeometry()</em>. Como estamos iniciando, utilizaremos o <em>resize()</em>. Ele receberá dois parâmetros, sendo que o primeiro definirá a largura e o segundo a altura.</p><blockquote><strong>Nota</strong>: Ambos devem ser inteiros.</blockquote><pre>        self.resize(250, 300)</pre><p>Modificar o ícone da nossa janela, exige um pouco mais de trabalho. Primeiro deveremos importar a classe QIcon, que está localizada dentro do módulo QtGui e não no módulo QtWidgets. Sendo assim, as nossas importações ficarão da seguinte maneira:</p><pre><strong>from </strong>PyQt5.QtWidgets <strong>import </strong>QApplication, QWidget</pre><pre><strong>from</strong> PyQt5.QtGui<strong> import </strong>QIcon</pre><pre><strong>import </strong>sys</pre><p>Após isso, utilizaremos o método <em>setWindowIcon()</em>, onde o mesmo receberá como parâmetro uma instância da classe QIcon. A classe QIcon, por sua vez, receberá como parâmetro uma string indicando o diretório da imagem. Após a declaração do método <em>resize()</em>, deveremos incluir a seguinte linha:</p><pre>        self.setWindowIcon(QIcon(&quot;/static/logo.ico&quot;))</pre><p>Bem, estamos chegando ao final deste post introdutório ao PyQt5. Para realizar o download do código apresentado neste post, basta acessar esse <a href="http://bit.ly/1w1wPcF">link</a>.</p><p><strong><em>Onde posso encontrar exemplos?</em></strong></p><p>Existem muitos locais na internet onde poderá encontrar exemplos de código utilizando o PyQt, porém se desejas encontrar códigos especificamente utilizando o PyQt5, você terá basicamente dois locais confiáveis. O primeiro deles é o diretório onde está instalado o próprio PyQt5. Para encontrarmos, bastamos ir até o local onde o mesmo está instalado, entrar na pasta <em>examples</em> e ver asdiversas rosas.</p><p>Outro local onde contém muito mais exemplos do que o descrito anteriormente é a documentação do Qt. Dependendo do seu conhecimento, este local poderá ser um caminho de pedras ou de rosas. Se conhece o C++ ou tem o mínimo de conhecimento possível, conseguirá se virar bem com os exemplos. Caso não tenha, ficará meio difícil. O link para a documentação do Qt5 está no início do post.</p><p><strong>Finalizando</strong></p><p>Enfim, chegamos a final desta introdução ao PyQt5, onde detivemos conhecimento do Qt, do próprio PyQt, dos módulos contidos dentro do PyQt5, das suas características e do seu funcionamento. Aprendemos a realizar a instalação do mesmo no Mac OS X, no Windows e no Ubuntu. Também criamos a nossa primeira aplicação, onde foi abordado o funcionamento de cada linha de código fundamental na criação de uma janela utilizando o PyQt. Após isso, brincamos um pouco quando aprendemos a modificar o título, ícone e tamanho da nossa janela.</p><p>Claro, este foi um post inicial para entendermos um pouco sobre a biblioteca. No próximo post começaremos a desenvolver um software real que se estenderá até o final do conjunto de posts.</p><p>Espero que tenha usufruído desta leitura, até mais.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=62914b1b39c1" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>