DEV Community: Flávio Filipe

Documentando código Python com Type Hints

Flávio Filipe — Thu, 08 Jul 2021 13:13:21 +0000

Introdução

Fiquei um pouco confuso ao começar a estudar sobre a declaração explícita com Python. Ao tentar comparar com outras linguagens como Java, C++ ou Typescript a compreensão começa a ficar um pouco problemática. Para entender o que é, para que serve e quando utilizar é preciso entender o motivo da sua criação.

Para começar precisamos ressaltar duas coisas importantes sobre o Python:

É uma linguagem fortemente tipada, isto é, cada variável tem um tipo e em alguns casos é preciso convertê-las para realizar operações, por exemplo: ‘1’ + 1 irá retornar uma exceção pois os tipos são diferentes.
É uma linguagem de tipagem dinâmica. Isso significa que podemos alterar o tipo da variável ao longo do programa, como por exemplo:

n = 2 # n é do tipo inteiro
n = ‘teste’ # n é do tipo string

Tipo de dados

Para conhecermos melhor os tipos em python podemos utilizar o método type(var).

Os mais comuns são:

Tipo	Descrição	Exemplo
str	Texto	'hello'
int	Número Inteiro	1 , 2, 3
float	Número Real	1.0, 2.0
list	Lista	[1,2,3]
dict	Dicionário	{'title': 'post 1', 'category': 1 }

Vantagens da Tipagem Estática

A grande vantagem de se trabalhar com linguagens de tipagem estática é que ao definir o seu tipo: garantimos que não teremos problemas em tentar somar um inteiro com uma string durante o desenvolvimento do código.
Outra vantagem é poder entender os tipos de dados que uma função está esperando, apontando um erro imediato na IDE durante a escrita do código caso o parâmetro passado seja de um tipo diferente.

Mas e se tratando de Python, como podemos ganhar agilidade no desenvolvimento e evitar erros comuns com os tipos de dados e deixar claro para quem for dar manutenção no futuro os tipos de dados que esperamos trabalhar?

Vamos considerar o código abaixo:

def somar(a, b):
    return a+b

Olhando para ele fica difícil saber o real propósito da sua criação. Ele foi criado para somar números, textos ou listas? O que aconteceria se eu passasse um número no primeiro parâmetro e um texto no segundo? Precisamos deixar claro para quem precisar olhar para este código no futuro.

Docstring

Na PEP-257, com a chegada do Docstring, é apresentada uma convenção para documentar nossas funções. Abaixo um exemplo com a tentativa de facilitar nosso entendimento:

def somar(a, b):
    '''
        Retorna a soma de dois números inteiros
        Params:
            a (int)
            b (int)
    '''
    return a+b

Dependendo da IDE ou editor de texto utilizado, ao chamar esta função e passar o mouse por cima, ele irá apresentar a sua documentação. Mas pensando no cenário onde teremos vários métodos e para todos eles precisaríamos criar um docstring somente para informar o tipo de parâmetro e seu retorno acaba se tornando uma tarefa repetitiva.

Decoradores para Funções e Métodos

Na PEP-318, com a chegada dos decoradores para as funções e métodos, é apresentado uma sintaxe para ser utilizada com a finalidade de definir os tipos de parâmetros e retorno, assim poderíamos simplificar nossa documentação criando uma funçao de para informar os parâmetros e retorno:

@accepts (int, int)
@returns (int)
def somar(a, b):
    return a+b

Aqui temos alguns exemplos da utilização dos decorators para facilitar o entendimento deles:

Finalmente os Annotations

No ano de 2006, com a chegada do Python 3, a PEP-3107 nos trouxe uma outra forma de documentar nosso código com as Anotações de Função. Agora nós podemos fazer as anotações dentro do parâmetro da função e logo em seguida informar seu retorno, que basicamente fazem o uso das anotations para fazer o mapeamento.

Type Hints

A PEP-483 nos trás uma nova “teoria” da proposta de implementação de tipos para o Python 3.5 Segue a citação que deixa bem claro o real propósito da nova implementação sugerida:

É importante que o usuário seja capaz de definir os tipos de uma forma que possa ser entendida por verificadores de tipo. O objetivo deste PEP é propor uma forma sistemática de definir tipos para anotações de tipo de variáveis e funções usando a sintaxe PEP 3107 . Essas anotações podem ser usadas para evitar muitos tipos de bugs, para fins de documentação, ou talvez até mesmo para aumentar a velocidade de execução do programa. Aqui, nos concentramos apenas em evitar bugs usando um verificador de tipo estático.

Porém é com a PEP-484 que isso acontece, com a chegada dos Type Hints ou Dicas de Tipo.

Segue um exemplo atualizado usando a nova sintaxe e falaremos sobre ele em seguida:

def somar(a: int, b: int) -> int:
    return a+b

Agora, de uma forma mais semântica, conseguimos documentar melhor nosso método. Fica claro os tipos de dados de entrada e saída. Agora vamos à "confusão" citada no início deste artigo quando tentei comparar com outras linguagens.

Ao olharmos o histórico da implementação podemos perceber que esta funcionalidade está mais ligada a documentação e legibilidade do código ao invés de tornar a linguagem estática. Sendo assim, diferente de outras linguagens estáticas, ao fazer uma declaração explícita dos valores de entrada ele não nos obriga a informá-los ou proíbe a mudança de tipo ao longo do código. Isso significa que o código abaixo ainda é um código válido:

def somar(a: int, b: int) -> int:
    return a+b  

print(somar('a', 'b')) 

>> 'ab'

Isso ocorre porque o intuito é DOCUMENTAR e não obrigar os tipos de entrada e saída. A grande vantagem desta funcionalidade está no desenvolvimento se combinado com a ferramenta de terceiros para fazer a validação no código.

Utilizando uma IDE ou um editor de texto configurado para o python, ao escrever o código acima seria apresentado um erro informando que os tipos de dados são incompatíveis. Outras ferramentas, como o MyPy, podem garantir se o código segue as regras de implementação propostas. Com isso em mente, vamos explorar um pouco mais o que podemos fazer com os Types Hints.

Eu estou utilizando o PyCharm, uma IDE feita para Python. Ela tem uma ótima integração com os Type Hints fazendo as validações em tempo de desenvolvimento. Mas sintam-se a vontade para testar em outros editores. Você poderá executar o MyPy sempre que quiser testar suas implementações

EXEMPLOS COM TYPE HINTS

Exemplo 1: Precisamos passar uma lista de palabras para um método fazer algum tipo de validação nelas. Assim, precisamos especificar o tipo de lista que estamos esperando:

def validar_palavras(palavras: list[str]) -> bool:
    return True if 'teste' in palavras else False

print(validate_words(['Nome', 'teste'])

Utilizando o list[str] informamos que estamos esperando uma lista de palavras para nossa função. No método acima o -> bool informa que o retorno é um boleano (Verdadeiro ou Falso).

Exemplo 2: Precisamos dar as boas vindas ao suário. Por isso iremos criar um método que recebe o nome e o status do usuário, se ele tiver o status ATIVO irá retornar a mensagem: `Bem vindo <NOME>!`. Mas se ele possuir o status SUSPENSO deverá retornar a mensagem: `Usuário Suspenso!`

from typing import TypedDict  

from enum import Enum  


class UserStatus(Enum):  
    ATIVO = 1  
    SUSPENSO = 2  


class UserType(TypedDict):  
    nome: str  
    status: UserStatus  


def boas_vindas(usuario: UserType) -> str:  
    if usuario['status'] == UserStatus.SUSPENSO:  
        return 'Usuário Suspenso!'  

    return f"Bem vindo {usuario['nome']}"  


usuario_ativo: UserType = {'nome': 'Usuário Ativo', 'status': 'ativo'}  
usuario_suspenso: UserType = {'nome': 'Usuário Suspenso', 'status': UserStatus.SUSPENSO}  
print(boas_vindas(usuario_ativo))  
print(boas_vindas(usuario_suspenso))

Para este exemplo nós criamos duas classes para ser a referência de tipo de entrada para nossa função. A class UserStatus será usada para definir nossos tipos padrões de status aceitos, enquanto a UserType serão os tipos de dados esperados pelo usuário.

Caso vc esteja utilizando o PyCharm ou algum editor configurado para reconhecer os tipos verá que poderá utilizar o autocomplete e caso passe algum parâmetro errado o próprio editor já acusa que há um erro:

Você poderá usar também a opção do autocomplete apertando ctrl+espaço:

Para conhecer mais como definir os tipos com classes poderá consultar a PEP-589.

Conclusão

Com a declaração explicita podemos:

Documentar melhor nosso código
Ter segurança na hora de fazer o refatoramento
Aproveitar ao máximo o autocomplete
Pensar melhor nos dados da nossa aplicação
Deixar o código mais claro e limpo

[Python] Exceções - Transformando bugs em features

Flávio Filipe — Mon, 22 Feb 2021 03:09:37 +0000

Neste post veremos como transformar os bugs em features, em outras palavras, como lidar com "erros" ao desenvolvermos nossas regras.

Sendo assim, aqui falaremos sobre como lançar exceções com o rise, como tratá-las utilizando o try/except e como criar exceções personalizadas para melhorar a legibilidade do nosso código.

Estaremos utilizando a linguagem Python, mas os conceitos abordados servirão para qualquer linguagem de programação que siga estes princípios de tratamento e lançamento de exceções.

Índice

Erros e Exceções
Bug vs Exceções
Tratando erros com o try/except
Lançando exceções
Exceções personalizadas
Conclusão
Bônus - Pytest

Erros e Exceções

Por que lançar e tratar exceções?

É muito comum encontrar códigos como este:

def diga_ola(nome):
    if len(nome) < 5:
        return false
    elif len(nome) > 100:
        return false
    elif name.isnumeric():
        return false
    else:
        return f'ola {nome}'

Bom, claramente essas verificações estará relacionada com nossa regra de negócio. Sendo assim, para entender seu funcionamento teremos que ler e interpretar o que está acontecendo e em qual ordem.

O problema é quando executamos a função e ela retorna um false na nossa cara. Mas e aí?! Onde falhou?? Em qual parte da regra ela não passou?? E é nessas horas que fazemos o velho print('aqui 1'), print('aqui 2'), print('aqui N') para saber até onde o código está chegando.

Na tentativa de "melhorar" ainda fazemos assim:

'''
Função para dizer olá
'''
def diga_ola(nome):
   // Verifica se o nome é menor que 5
    if len(nome) < 5:
        return false
    // Verifica se o nome é maior que 100
    elif len(nome) > 100:
        return false
    // Verifica se o nome é um número
    elif name.isnumeric():
        return false
    // Retornao nome formatado: Olá + nome
    else:
        return f'ola {nome}'

Se antes já estava ruim, agora que piorou. Nada pythonico!
Vamos ver formas melhores de organizar este código.

Bug vs Exceções

Resumidamente

Exceções são erros esperados, previsíveis e conhecidos de alguma situação. Ex: Divisão entre dois números x / y. Já é esperado que ocorra um erro caso o valor y == 0, logo podemos criar formas de tratar antes que trave o sistema.
Já o bug é um erro desconhecido, algo que não estava sendo esperado em uma funcionalidade. Ex: Exibir um alerta no navegador do usuário. Poderá acontecer N situações, como tamanhos de telas diferentes, navegadores diferentes, erro de conexão com a internet, desabilitar a execução de scripts no navegador, etc. Apesar de imarginarmos e tentar tratar algum deles, em algum momento essa "exceção não prevista" poderá travar o funcionamento de uma página.

Um bug conhecido poderá ser uma exceção tratada!

Caso queira se aprofundar nas terminologias poderá pesquisar sobre o padrão IEEE nº 610.12-1990 ou neste artigo da Dev Media Gestão de defeitos

Tratando erros com o try/except

Tente executar o cód a baixo

print(1/0)

O resultado será uma mensagem de erro:

Traceback (most recent call last):
    ...
ZeroDivisionError: division by zero

Podemos melhorar esta mensagem tratando a exceção e isolando-a numa função

def  divide_numeros(dividendo, divisor):
    try:
        print(dividendo/divisor)
    except:
        print ('O divisor não pode ser 0.')

divide_numeros(1, 0)

O resultado será: O divisor não pode ser 0.

Mas o que acontece se executarmos: divide_numeros(1, 'teste') ?
O resultado será exatamente a mesma mensagem! Portanto, precisamos tratar as exceções individualmente e exibir a mensagem adequada.
Podemos reescrever assim:

def  divide_numeros(dividendo, divisor):
    try:
        print(dividendo/divisor)
    except  ZeroDivisionError:
        print ('O divisor não pode ser 0.')
    except  TypeError:
        print('Insira apenas números')

Lançando exceções

Vamos falar agora de exceções relacionados a nossa regra de negócio.
Vamos rever o cenário onde nosso sistema terá uma mensagem de saudação para um usuário. Porém teremos algumas regras:

O nome não poderá ser números;
O nome deverá ter menos que 100 caracteres
O nome deverá ter mais que 5 caracteres

Como já vimos antes, encher o código de if e else não é legal. Por isso faremos um código com tratamento de exceções. Começaremos criando nossa função:

def  diga_ola(name: str) -> str:
    return f'Olá {nome}'

O método acima recebe uma string por parâmetro e retorna uma string como resposta. Então poderíamos executar da seguinte maneira: diga_ola('Flávio').

Como estamos especificando que o parâmetro recebido deverá ser uma string, ao tentar passar um número teremos um erro: diga_ola(123)

AttributeError: 'int' object has no attribute 'isnumeric'

Sendo assim, já podemos capturar nossa primeira exceção

try:
    print(diga_ola(123))
except  AttributeError:
    print('Insira apenas texto')

Para deixarmos dinâmico, vamos pedir através de um input para que o nome seja inserido:

try:
    name = input('Insira seu nome: ')
    print(diga_ola(name))
except  AttributeError:
    print('Insira apenas texto')

Faça o seguinte teste:

Execute seu código
Insira um o número 123
O resultado será: Olá 123

Como assim? Acabamos de tratar este erro...
O problema é que quando se trata de um input todo dado é uma string, logo atende ao nosso requesido. Por isso, precisaremos tratar dentro de nosso método e "lançar" uma nova exceção.

Lançando uma exceção

Para lançar uma nova exceção utilizaremos a palavra reservada rise e dizer qual é seu tipo e a mensagem. Vamos modificar nosso método:

def  diga_ola(name: str) -> str:
    if name.isnumeric():
        raise  TypeError('Apenas letras')
    return f'Olá {nome}'

No trecho raise TypeError('Apenas letras') estamos lançando um exceção do tipo TypeError e passando por parâmetro a mensagem que será exibido.

Conheça a lista de exceções padrões que poderá ser lançada que são nativas da linguagem Python na docs.

Já seguindo este curso, vamos implementar as outras regras:

def  diga_ola(name: str) -> str:
    if  name.isnumeric():
        raise  TypeError('Apenas letras.')  

    if  len(name) > 100:
        raise  OverflowError('Nome muito grante.')

    if  len(name) < 5:
        raise  ValueError('Nome pequeno.')

    return  f'Olá {name}'

E podemos chamá-lo assim:

try:
    name = input('Insira seu nome: ')
    print(diga_ola(name))
except  AttributeError:
    print('Insira apenas texto')
except  ValueError  as  error:
    print(error)

Está bem melhor de entender, mas ainda podemos melhorar.
Ao verificar se o parâmetro é menor que 5, nós lançamos uma função genérica e exibindo sua mensagem. Será que poderíamos criar "Exceções Personalizadas" e tratá-las da maneira ideal e não de forma genérica?

Exceções personalizadas

Criar exceções personalizadas nos ajudará a deixar nosso código mais organizado e legível.
Vamos criar um arquivo chamado exceptions.py com o seguinte conteúdo:

class  NomePequenoException(ValueError):
    pass

Aqui nós estamos criando uma classe que estende a classe ValueError. Apesar de não executar nada, nos será muito útil na leitura do código. Veja nosso código final completo, onde faremos a importação da exceção e tratamos de forma individual:

import  Exceptions
def  diga_ola(name: str) -> str:
    if  name.isnumeric():
        raise  ValueError('Apenas letras.')  

    if  len(name) > 100:
        raise  OverflowError('Nome muito grante.')

    if  len(name) < 5:
        raise  Exceptions.NomePequenoException('Nome pequeno.')

    return  f'Olá {name}'

def  main():
    try:
        name = input('Insira seu nome: ')
        print(diga_ola(name))
    except  AttributeError:
        print('Insira apenas texto')
    except  Exceptions.NomePequenoException:
        print('Insira nomes com 5 ou mais letras')
    except  ValueError  as  error:
        print(error)

if  __name__ == '__main__':
    main()

Conclusão

Desenvolver um bom código não é só "o que funciona", mas também é se preocupar com a organização e legibilidade para facilitar a manutenção. Boa parte do tempo de desenvolvimento é encontrando falhas. Por isso, organizar as exceções ao desenvolver novas features nos ajudará a rastrear o erro e facilitará no processo de teste.

No exemplo que criamos temos o caso onde a função será chamada em apenas um lugar. Mas em um sistema maior, onde será chamado em vários lugares, por várias pessoas, poderemos ter formas diferentes de tratar estas exceções: fazendo um print, registrando um log, retornando a mensagem para um dashboard em um frontend, etc. Por isso, é uma boa prática deixar a cargo de quem executa o método decidir o que fazer quando houver a exceção.

Dica: Ficamos presos em criar o menor número de linhas, a menor quantidade de arquivos, os nomes mais compactos de variáveis e métodos. Mas hoje, com a grande capacidade computacional e diversas ferramentas para compactar nosso código, a quantidades de bytes em um arquivo é o menor dos problemas. Sendo assim, não exite em criar arquivos de exceções, testes e escrever nomes coerentes para seus componentes.

Bônus: pytest

Deixo aqui minha sugestão off topic para o estudo de testes automatizados. A baixo terá as instruções para executar os testes aplicados a nosso exemplo.

Criando ambiente

venv

python3 -m venv venv

Caso esteja no Windows e tenha erro ao encontrar o Python, tente executar assim ou consulte a documentação:
py -m venv venv

Ative o ambiente

Linux: source venv/bin/activate
Windows: venv/scripts/activate

Instalando o pytest

pip install pytest

Arquivo te testes

Crie o arquivo test_exceptions.py (todos os testes deverão começar com test_*)

import  pytest
import  random
import  Exceptions
from  main  import  diga_ola


def  test_quando_o_nome_for_composto_maior_que_5_letras():
    assert  diga_ola('Flávio Filipe') == 'Olá Flávio Filipe'


def test_quando_o_nome_for_menor_que_5_letras_nao_deve_permitir():
    with  pytest.raises(Exceptions.NomePequenoException):
        diga_ola('abc')


def teste_quando_inserir_numero_nao_deve_permitir():
    with  pytest.raises(TypeError):
        diga_ola('123')
def  test_nome_maior_que_100_letras():
    with  pytest.raises(OverflowError):
        nome = 'a'*100+'a'

diga_ola(nome)

Os trechos com with pytest.raises(...): irá verificar se o retorno do contexto analisado será o erro especificado por parâmetro.

Executando os testes

Execute na raiz do projeto:
pytest

Bot para Twitter com Node.JS (Erros e acertos)

Flávio Filipe — Mon, 18 Jan 2021 04:30:31 +0000

Resumo

Este artigo tem o intuito de apresentar o meu processo de desenvolvimento do Surta Não Bot, apresentando tanto a criação quanto os problemas enfrentados.
A biblioteca utilizada para fazer a conexão com twitter foi a Twit

Motivação

Após o lançamento da música de um amigo tive a ideia de criar um bot para o Twitter para divuga-lo. A proposta seria monitorar algumas hashtags específicas e comentar uma chamada para a música. O mesmo comportamento seria aplicado para quando o perfil fosse mencionado nos comentários.

Problema

Após feito, testado e enviado para o servidor de "produção" não levou muito tempo para que a conta fosse suspensa e marcada como span. Isso aconteceu por não ter lido as Regras e políticas do twitter.
Em uma de suas clausulas é alertado que será considerado span "se uma conta estiver tweetando para não seguidores de forma repetida e não solicitada ou se estiver envolvida em padrões de comportamento abusivo".
Abaixo apresento as etapas de criação do bot.

Etapa 1 - Credenciais no Twitter

Twitter Developers

Após criar um novo perfil no twitter (ou utilizar um existente) é necessário criar um novo app no Twitter Developers.
Nesta etapa será preciso informar o intuito do bot e fazer a descrição em inglês. Caso tenha dificuldade com o idioma, recorra ao bom e velho Google Tradutor.

Etapa 2 - Criação do projeto

Criei uma pasta chamada surta-nao-bot
Foi necessário baixar duas bibliotecas: Twit e dotenv. A primeira será utilizada para conectar a API do Twitter e a segunda para carregar as variáveis de ambiente do arquivo .env. Segue o comando para instalar ambas:

npm i twit
npm i dotenv

Neste primeiro momento será necessário criar três arquivos: bot.js, config.js e .env.

.env

Dentro deste arquivo insira os códigos de acesso gerado no Twitter Developers

consumer_key=
consumer_secret=
access_token=
access_token_secret=

config.js

Aqui será carregado as chaves de acesso criadas anteriormente para ser utilizada no projeto

require('dotenv').config();

module.exports = {
    consumer_key:process.env.consumer_key,
    consumer_secret:process.env.consumer_secret,
    access_token:process.env.access_token,
    access_token_secret:process.env.access_token_secret
}

bot.js

Este é o arquivo onde terá o core do nosso bot. Para testar vamos criar um código simples onde será pesquisado no twitter posts com a hastag "javascript"

const config = require('./config');
const twit = require('twit')
const Twit = twit(config);

function searchTweets(params){

    Twit.get('search/tweets', params, (err, data, response) => {
        let tweets = data.statuses;
        if(!err) {
            for(let dat of tweets){
                let retweetId = dat.id_str;
                console.log(retweetId);
            }
        }else{
            console.log(err);
        }
    })
}

console.log('Aqui!')
searchTweets({q: '#javascript'})

Execute o arquivo bot.js

node bot.js

Caso tudo ocorra bem até aqui, podemos prosseguir para a próxima etapa.
Caso dê algum erro confira as mensagens que serão exibidas no console. Um dos principais motivos poderá ser as chaves de acesso do Twitter.

Etapa 3 - Respondendo Tweets quando mencionado

Seguindo a documentação do Twit, usaremos o Twit.stream para "escutar" um filtro. Neste caso, será feito um filtro no @ da conta, para quando for mecionado possa responder o tweet. Veja o código a baixo do arquivo bot.js:

const config = require('./config');
const twit = require('twit')
const Twit = twit(config);

//Setting up a user stream
var stream = Twit.stream('statuses/filter', { track: '@surtanao_bb' });

stream.on('tweet', tweetEvent);

function tweetEvent(tweet) {
    // console.log(tweet)
    var reply_to = tweet.in_reply_to_screen_name;
    var text = tweet.text;
    var from = tweet.user.screen_name;
    var nameID = tweet.id_str;
    // params just to see what is going on with the tweets
    var params = { reply_to, text, from, nameID };
    console.log(params);

    let new_tweet = "It's me!!";
    if (from !== 'surtanao_bb') {
        new_tweet = 'Surta não @'+from+'!!! Ouça agora a nova música de Wander Luiz: https://bit.ly/SurtaNao';
    }

    var tweet = {
        status: new_tweet,
        in_reply_to_status_id: nameID
    }

    Twit.post('statuses/update', tweet, (err) => {
        if (err) {
            console.log("Something went wrong!", err);
        } else {
            console.log("It worked!");
        }
    });
}

No código a cima nós declaramos na variável stream com o filtro que queremos fazer, neste caso com o perfil @surtanao_bb

Logo a baixo no trecho stream.on('tweet', tweetEvent); é onde as coisas acontecem. A varíavel stream agora é uma instancia do Twit Stream, por isso possui o método on que recebe o evento que será "escutado" no primeiro parâmetro e a função que será executada no segundo, que recebe cada tweet encontrado.

O método tweetEvent recebe por parâmetero um objeto com os dados do tweet e logo no inicio colhe algumas informações, como o usuário que fez a postagem, o texto e o ID. Um pouco mais a baixo é motado a mensagem de resposta para enfim fazer a postagem utilizando o método post do Twit. Caso ocorra algum erro será exibido no console, se não, será impressa a mensagem "It worked!".

Para que funcione é necessário conceder permissão ao app, dentro do Twitter Developers, para ler e escrever mensagens. Eu apliquei a última opção "Read + Write + Direct Messages". Basta acessar seu app, na tela inicial acessar a opção "App permissions".

Bom, até este momento o bot deverá executar com sucesso!
Após este passo decidi inserir as opções de monitorar hashtags específicas para responder automaticamente, o que não deu muito certo, pois pouco tempo depois a conta foi identificada como span. Confira o commit da atualização caso queira ver o resultado.

Etapa 4 - Deploy na Heroku

Para fazer o deploy será necessário ter uma conta na Heroku e criar um novo app e ter instalado o heroku-cli.

Após configurado, dentro da pasta surta-nao-bot será necessário adicionar um novo remote para o heroku, isso permitirá fazer o deploy utilizando o git.

heroku git:remote -a nome-do-app-heroku

Ao exececutar o comando a cima será criado um novo origin do repositório. Você poderá conferir com o comando a baixo:

git remote -v

Para que o Heroku consiga executar a aplicação será necessário criar o arquivo Procfile na raiz do projeto. A principio criei este arquivo com o código a baixo:

worker: node bot.js

Além disso fiz a alteração no arquivo package.json para executar o comando npm start no arquivo bot.js. Segue o trecho de dentro do arquivo package.json:

...
"scripts": {
    "start": "node bot.js"
  },
...

E fiz o deploy utilizando o git

git push heroku master

Antes de enviar para o servidor da Heroku já havia enviado para o github, por isso foi necessário criar o arquivo .gitignore para que não fosse enviado o arquivo .env com as credenciais de acesso. Por isso, ao fazer o push na heroku será necessário criar as variáveis de ambiente dentro da própria plataforma. Segue a baixo o código do .gitignore.

.env
node_modules
.vscode
package-lock.json

Variáveis de ambiente na Heroku

Acesse o app e abra as configurações no menu settings
Dentro da sessão Config Vars crie as variáveis que estão no arquivo .env do projeto, sendo a key o nome da variável e o value as chave de acesso.

Problema 2

Até aí tudo bem, o código executou na heroku e o bot já estava funcionado. Porém ao acompanhar o arquivo de logs da Heroku com o comando heroku logs -a percebi que após 60seg o bot era finalizado. Pensei que fosse a opção gratuita da plataforma até encontrar a solução.
Em vários tutoriais os passos executados a cima pareciam funcionar, porém para que este tivesse sucesso eu precisei adicionar uma nova linha ao Procfile informando a web. Aparentemente todo app da heroku precisa ter algo do tipo, foi o que funcionou para mim. Segue o código do arquivo Procfile final:

web: echo "whatever"
worker: node bot.js

Pronto! Agora sim o bot estará funcionando na heroku sem parar. Para fazer o deploy faça o push:

git push heroku master

Testando

Para fazer o teste utilize uma outra conta e faça uma postagem mencionando o perfil do seu bot. Acompanhe os logs do servidor com heroku logs --tail.

Melhorias

Algumas melhorias foram feitas, como criar mensagens aleatórias para que seja exibidas nas respostas e a remoção da pesquisa pelas tags.

Coisas como likes e retweets poderão ser exploradas dentro da documentação do Twit

Para acompanhar as atualizações do bot confira o repositório no Github.

DEV Community: Flávio Filipe

Documentando código Python com Type Hints

Introdução

Tipo de dados

Vantagens da Tipagem Estática

Docstring

Decoradores para Funções e Métodos

Finalmente os Annotations

Type Hints

EXEMPLOS COM TYPE HINTS

Exemplo 1: Precisamos passar uma lista de palabras para um método fazer algum tipo de validação nelas. Assim, precisamos especificar o tipo de lista que estamos esperando:

Exemplo 2: Precisamos dar as boas vindas ao suário. Por isso iremos criar um método que recebe o nome e o status do usuário, se ele tiver o status ATIVO irá retornar a mensagem: Bem vindo <NOME>!. Mas se ele possuir o status SUSPENSO deverá retornar a mensagem: Usuário Suspenso!

Conclusão

[Python] Exceções - Transformando bugs em features

Índice

Erros e Exceções

Por que lançar e tratar exceções?

Bug vs Exceções

Tratando erros com o try/except

Lançando exceções

Lançando uma exceção

Exceções personalizadas

Conclusão

Bônus: pytest

Criando ambiente

venv

Ative o ambiente

Instalando o pytest

Arquivo te testes

Executando os testes

Bot para Twitter com Node.JS (Erros e acertos)

Resumo

Motivação

Problema

Etapa 1 - Credenciais no Twitter

Twitter Developers

Etapa 2 - Criação do projeto

.env

config.js

bot.js

Etapa 3 - Respondendo Tweets quando mencionado

Etapa 4 - Deploy na Heroku

Variáveis de ambiente na Heroku

Problema 2

Testando

Melhorias

Exemplo 2: Precisamos dar as boas vindas ao suário. Por isso iremos criar um método que recebe o nome e o status do usuário, se ele tiver o status ATIVO irá retornar a mensagem: `Bem vindo <NOME>!`. Mas se ele possuir o status SUSPENSO deverá retornar a mensagem: `Usuário Suspenso!`