DEV Community: DrxwHe4rt

Python Logging Config

DrxwHe4rt — Sat, 16 Jan 2021 02:17:36 +0000

Caso tenha você tenha começado a ler esse artigo e esta se perguntado "que diabos é logging?", deixo aqui os artigos anteriores para que fique por dentro (é de extrema importancia que leia os artigos anteriores a esse, para que tenha maior compreensão do que iremos fazer aqui).

E a parte 4 dessa serie de artigos sobre logging será esse que você esta lendo, onde iremos parametrizar todas as configurações de nosso logging em um arquivo especifico, para que fique tudo organizado.

Para começar, crie uma pasta na qual ira comportar os itens desse artigo, dê o nome que preferir a ela e após isso crie um arquivo app.py (dê o nome que preferir também).

Comece importando nosso modo de logs:

import logging

Por enquanto vamos deixar o arquivo app.py dessa forma e vamos criar outro arquivo chamado config.ini (também sinta-se a vontade para escolher o nome que desejar). É nesse arquivo que iremos adicionar nossas configurações.

Para que você entenda brevemente do que se trata, o arquivo com extensão .ini é divido em sessões que possuem propriedades, é muito útil para arquivos de configuração que não necessitam de muita complexidade. Segue a formatação de um arquivo de configuração desse tipo:

; Isso é um comentario

; As propriedades basicas de um arquivo desse tipo são as propriedades e essas contém um nome e um valor
nome=valor

; O arquivo, também pode ser divido por sessões, para que fique melhor organizado
[sessão]
nome=valor

Dito tudo isso, podemos começar a configurar o arquivo do nosso sistema de logs. Dentro do arquivo que criamos, vamos adicionar as seguintes sessões e propriedade:

[loggers]
; Por padrão o logger root ja é chamado pelo módulo logging, mas iremos deixar isso explicito
keys = root

[handlers]
; Aqui definimos o modo como nosso log irá operar
keys = FileHandler

[formatters]
; E aqui será o nosso formatador
; O formatador também ficara dentro desse arquivo
keys = simpleFormatter

; Aqui definiremos as configurações do nosso logger root
[logger_root]
; Indicamos o level de DEBUG apenas
level = DEBUG
; Especificamos o nome do logger que iremos atuar
qualname = root
; E dizemos que será um logger de arquivo
handlers = FileHandler

; propriedades do nosso arquivo de log
[handler_FileHandler]
; Especificamos a nossa classe
class = FileHandler
; O formatador
formatter = simpleFormatter
; Aqui definimos o nome e o modo de escrita 
args = ('LOG.log', 'w')
; write / w = sobrescreve o arquivo sempre que gera um log novo
; append / a (padrão) = agrupa todos os logs sem apagar o anterior

; Por ultimo, mas não menos importante
; Definiremos como irá atuar nossa string de formatação
[formatter_simpleFormatter]
format = Data/Hora: %(asctime)s | level: %(levelname)s | file: %(filename)s | mensagem: %(message)s

Como pode ver, deixei tudo comentado conforme fui decorrendo o arquivo, acredito que ficará mais facil de compreender, ao inves de dividir a explicação por partes.

Com o arquivo de configuração pronto, vamos voltar a app.py e terminar de escrever nosso codigo. Nós tinhamos acabado de importar nosso módulo, então vamos dar continuidade implementando as seguintes linhas:

# Além de importar o módulo logging
# Iremos importar outro modulo, chamado config
import logging.config

# Logo abaixo definiremos o arquivo de configuração
logging.config.fileConfig('config.ini')

Para um breve entendimento...

Ao importarmos logging.config abrimos um leque de possibilidades, quando se trata de configurações de log. Dentre o métodos de configuração, escolhemos o fileConfig ja que estamos trabalhando com um arquivo de configuração, mas o módulo carrega com si outras opções, como dictConfig que obtém a configuração de log atravéz de um dicionário, contamos também com a opção listen que inicia um servidor de soquete na porta especificada e escuta as novas configurações.

Dito isso, vamos finalizar nosso script adicionando as seguintes linhas:

# definido a instancia do objeto getLogger()
logger = logging.getLogger()
# Gerando log
logger.info('teste')

Nosso arquivo app.py completo ficará assim:

import logging
# Além de importar o módulo logging
# Iremos importar outro módulo, chamado config
import logging.config

# Logo abaixo definiremos o arquivo de configuração
logging.config.fileConfig('config.ini')

# definido a instancia do objeto getLogger()
logger = logging.getLogger()
# Gerando log
logger.info('teste')

Agora, podemos executar nosso codigo. Digite no terminal:

python app.py

Após rodar o script, veremos que foi gerado o arquivo LOG.log com a seguinte mensagem dentro:

Data/Hora: 2021-01-14 12:39:34,687 | level: INFO | file: app.py | mensagem: teste

Conclusão

Talvez, esse artigo tenha ficado maior do que os anteriores e um pouco mais maçante, mas isso foi necessário para que obtivéssemos um melhor entendimento do que fizemos. Agora você ja conseguirá criar um gerador de logs mais "encorpado" e mais facil de ser mantido futuramente, pois segue a ideia da documentação oficial.

Python Logging Formatters

DrxwHe4rt — Thu, 14 Jan 2021 15:50:01 +0000

Esse artigo iremos aprender a formatar nossa mensagem de log e entregar uma experiencia melhor nesse quesito. Mas, primeiro vamos entender o que é um formatter.

Basicamente, eles configuram a ordem, a estrutura e o conteúdo finais da mensagem de log;
Se não houver formatação na mensagem, o padrão é usar a mensagem bruta;
Se não houver formatação na data, o formato de data padrão é: %Y-%m-%d %H:%M:%S;
A string de mensagem padrão é:

'%(asctime)s - %(levelname)s - %(message)s'

Vamos ver isso em pratica...

Comece criando o arquivo .py, no meu caso, irá se chamar app.py, sinta-se a vontade para colocar o nome que desejar. Após criar o arquivo, iremos importar o módulo logging:

import logging

Depois, vamos definir a nstancia do objeto getLogger():

logger = logging.getLogger()

E o nivel de criticidade do objeto:

logger.setLevel(logging.DEBUG)

Agora, chegamos no ponto em que gostariamos. É o momento de definir o nosso formatador:

formatter = logging.Formatter(
    '%(asctime)s:%(levelname)s:%(message)s'
)

Vamos utilizar a formatação padrão e ao decorrer do artigo vamos implementando essa colocação.

Apenas para método de praticidade, iremos utilizar o modo StreamHandler (visto no artigo anterior), dessa forma o log ficará somente no terminal e não salvará em nenhum arquivo:

sh = logging.StreamHandler()
sh.setLevel(logging.DEBUG)

Vamos finalizar nosso código dizendo ao módulo logging qual o nosso formatador, utilizando a função setFormatter:

sh.setFormatter(formatter)

Adicione uma simples mensagem para que nosso script gere um log a partir dela:

logger.debug('Olá.')

execute o nosso script:

python app.py

A saida deverá ser algo parecido com isso:

Vamos agora, dizer ao nosso formatador que queremos que ele mostre qual arquivo gerou o log. Para isso, implementaremos o seguinte parametro a nossa string: %(filename)s.

# sua variavel formatter deverá ficar dessa forma:
formatter = logging.Formatter(
    '%(asctime)s:%(levelname)s:%(filename)s:%(message)s'
)

Execute outra vez o script:

python app.py

O retorno será esse:

Pensando bem, essa data esta meio confusa, não esta?
Que tal se formatássemos a data então?
Veja:

a função Formatter contém uma variavel chamada datefmt, podemos usar ela para formatar a nossa data/hora e retornar algo mais user friendly. Dito isso, mudaremos o conteúdo da nossa variavel formatter adicionando o parametro datefmt da seguinte forma:

formatter = logging.Formatter(
    '%(asctime)s:%(levelname)s:%(filename)s:%(message)s',

    # Padrão de data: dia/mes/ano 
    # Padrão de hora: hora/minuto/segundos 
    # Sistema (am/pm)
    datefmt='%d/%m/%Y %I:%M:%S %p'
)

Execute o script e o seu resultado será esse:

Você pode embelezar um pouco mais sua string formatadora e deixa-la da seguinte forma:

formatter = logging.Formatter(
    'Data/Hora: %(asctime)s | level: %(levelname)s | file: %(filename)s | mensagem: %(message)s',

    # Padrão de data: dia/mes/ano 
    # Padrão de hora: hora/minuto/segundos 
    # Sistema (am/pm)
    datefmt='%d/%m/%Y %H:%M:%S %p'
)

Tendo como resultado:

Conclusão

Vimos nesse artigo que podemos formatar nossa log e deixa-lo mais amigável para quem for lê-lo (normalmente, será um desenvolvedor). Lendo a documentação você irá perceber que existem outras formas de realizar essa formatação, mas procurei um jeito mais didático de mostrar como se faz.

Python Logging Handlers

DrxwHe4rt — Wed, 13 Jan 2021 20:55:15 +0000

No artigo anterior vimos como podemos gerar mensagens de erro, aviso e informativas do sistema. Agora, iremos aprofundar um pouco mais nesse assunto e iremos entender o que são os Handlers.

Os principais Handlers são:

StreamHandler: Retorna a mensagem/log no terminal;
FileHandler: Envia o log para um arquivo definido pelo desenvolvedor;
NullHandler: não faz nenhuma formatação ou saída. É essencialmente um manipulador no-op (sem operação).

Na documentação oficial podemos contar um numero maior de Handlers, mas nesse artigo iremos usar apenas o StreamHandler e o FileHandler.

Vamos começar criando nosso arquivo .py, no meu caso irá se chamar app.py, mas pode atribuir o nome que desejar. Após isso, iremos começar a escrever o nosso codigo...

# Comece importando o módulo logging

import logging

Agora, vamos definir nossa instancia do objeto getLogger() e o nivel de nosso log (nesse caso iremos definir o nivel de DEBUG).

logger = logging.getLogger()
logger.setLevel(logging.DEBUG)

Vamos então definir as propriedades do nosso handler:

# Vamos começar testando o FileHandler
# O nome do nosso arquivo de log será LOG.log
fh = logging.FileHandler('LOG.log')

# Definindo o level do nosso handler
# Nesse caso, também será DEBUG
fh.setLevel(logging.DEBUG)

Após definirmos as propriedades, de fato iremos criar o nosso handler:

logger.addHandler(fh)

Por fim, vamos criar uma simples saida de texto para o nosso logger:

logger.debug('Olá, sou a mensagem de log dentro do seu arquivo.')

Execute usando o script:

sh python app.py

Depois de executar o codigo, olhe na raiz da pasta que agora terá um arquivo com o nome LOG.lg contendo o seguinte conteúdo:

Agora, iremos testar o modo StreamHandler. Para isso iremos mudar apenas uma linha do codigo:

# de
fh = logging.FileHandler('LOG.log')

# para
fh = logging.StreamHandler()

O restante do código pode manter da forma como estava. Se preferir, pode apagar o arquivo LOG.log para perceber que utilizando o StreamHandler o arquivo não será criado.

Rode no terminal:

sh python app.py

O seu retorno será no próprio terminal:

O modo StreamHandler é usado, especialmente, para que os desenvolvedores tenham um retorno visual mais rapido, é comum o StreamHandler ser usado juntamente ao FileHandler.

Concluindo

Você tem varios manipuladores de logs disponives, hoje utilizamos os mais comuns, pois a usabilidade é, basicamente, a mesma, só muda a forma como você irá aplicar em seu ambiente.

Gerando Logs com python

DrxwHe4rt — Mon, 11 Jan 2021 21:53:33 +0000

Nesse artigo, iremos trabalhar com a geração de logs em python, utilizando o módulo logging.

Retirado da documentação oficial do python: "Este módulo define funções e classes que implementam um sistema de registro de eventos flexível para aplicativos e bibliotecas."

O que a descrição acima quer dizer?

Bem, imagine o seguinte cenário: Temos uma função que realiza retorna o nome completo de uma pessoa, os parâmetros dessa função são primeiro_nome e ultimo_nome, ambos aceitam strings como entrada, mas imagine que, por um motivo de força maior (pense nessa situação como algo para mérito de compreensão) a entrada seja do tipo booleano (True/False), nesse caso teríamos um erro e gostaríamos que o sistema reportasse essa mensagem de erro para nós. E é para isso, que temos esse módulo no python.

Vamos abordar o exemplo acima de forma pratica

Crie uma pasta para armazenar nosso codigo;
Crie um arquivo chamado app.py.

Dentro do nosso arquivo app.py iremos importar o módulo logging:



import logging

Feito isso, iremos definir a formatação do nosso log:



'''
   A formatação abaixo permite personalizarmos
   a forma como o log será mostrado para nós.
'''
# DateTime:Level:Arquivo:Mensagem
log_format = '%(asctime)s:%(levelname)s:%(filename)s:%(message)s'

Em seguida, definiremos as configurações do log e sua instancia:



'''
   Aqui definimos as configurações do modulo.

   filename = 'nome do arquivo em que vamos salvar a mensagem do log.'
   filemode = 'É a forma em que o arquivo será gravado.'
   level = 'Level em que o log atuará'
   format = 'Formatação da mensagem do log'
'''
logging.basicConfig(filename='exemplo.log',
                    # w -> sobrescreve o arquivo a cada log
                    # a -> não sobrescreve o arquivo
                    filemode='w',
                    level=logging.DEBUG,
                    format=log_format)

'''
   O objeto getLogger() permite que retornemos
   varias instancias de logs.
'''
# Instancia do objeto getLogger()
logger = logging.getLogger('root')

O módulo contém varios tipos de niveis de mensagens:

Level	Numeric value
`CRITICAL`	50
`ERROR`	40
`WARNING`	30
`INFO`	20
`DEBUG`	10
`NOTSET`	0

Até aqui definimos as configurações do nosso log, agora vamos colocar isso tudo em pratica, de fato.

Vamos fazer uma função que receba o primeiro_nome e o segundo_nome de uma pessoa e retorne o log dessa função no nosso arquivo exemplo.log (definido logo acima):



def add(primeiro_nome: str, segundo_nome: str) -> str:
    """
        Essa função recebe o primeiro nome e o segundo nome de uma pessoa e retorna o nome completo dela.
    """

    # Aqui, verificamos se os parametros passados são do tipo string (str)
    if isinstance(primeiro_nome, str) and isinstance(segundo_nome, str):
        logger.info(f'{primeiro_nome} {segundo_nome}')
        return primeiro_nome + segundo_nome
    else:
        logger.error(
            f'{primeiro_nome} type: {type(primeiro_nome)} - {segundo_nome} type: {type(segundo_nome)}'
        )

Segue nosso codigo completo:



import logging


'''
   A formatação abaixo permite personalizarmos
   a forma como o log será mostrado para nós.
'''
# DateTime:Level:Arquivo:Mensagem
log_format = '%(asctime)s:%(levelname)s:%(filename)s:%(message)s'
'''
   Aqui definimos as configurações do modulo.

   filename = 'nome do arquivo em que vamos salvar a mensagem do log.'
   filemode = 'É a forma em que o arquivo será gravado.'
   level = 'Level em que o log atuará'
   format = 'Formatação da mensagem do log'
'''
logging.basicConfig(filename='exemplo.log',
                    # w -> sobrescreve o arquivo a cada log
                    # a -> não sobrescreve o arquivo
                    filemode='w',
                    level=logging.DEBUG,
                    format=log_format)

'''
   O objeto getLogger() permite que retornemos
   varias instancias de logs.
'''
# Instancia do objeto getLogger()
logger = logging.getLogger('root')

def fullname(primeiro_nome: str, segundo_nome: str) -> str:
    """
        Essa função recebe o primeiro nome e o segundo nome de uma pessoa e retorna o nome completo dela.
    """

    # Aqui, verificamos se os parametros passados são do tipo string (str)
    if isinstance(primeiro_nome, str) and isinstance(segundo_nome, str):
        logger.info(f'{primeiro_nome} {segundo_nome}')
        return primeiro_nome + segundo_nome
    else:
        logger.error(
            f'{primeiro_nome} type: {type(primeiro_nome)} - {segundo_nome} type: {type(segundo_nome)}'
        )

fullname('Wendrew', 'Oliveira')
fullname('Wendrew', True)

O retorno desse codigo ficará dentro do arquivo exemplo.log no mesmo caminho do arquivo app.py e terá a seguinte forma:

Esse é o modo mais convencional de retorno de mensagens aos desenvolvedores, quando o sistema ja esta em produção

Flask Command Line Interface

DrxwHe4rt — Thu, 31 Dec 2020 14:55:48 +0000

Nesse artigo, iremos explorar o CLI do micro-framework flask. Para quem não conhece, o flask é um framework web, está para o python assim como o express está para o node.

Entendendo o CLI...

Ao instalar do Flask, automaticamente, será instalado uma interface de linha de comando Click, em seu virtualenv (ambiente virtual);
Click é um pacote feito para criar comandos personalizados para sua aplicação Flask escrevendo o minimo possivel.

Semelhante aos comandos que o framework django possui para criar super-usuarios, criar apps, etc. o Click possibilita fazermos isso e o melhor é que podemos ir além e criar nossos proprios comandos, agilizando o desenvolvimento de nossos projetos.

Dependencias

Virtualenv
Flask

OBS: Irei partir da premissa de que você ja esta familiarizado com a configuração do ambiente e instalação das dependencias.

Sua estrutura de pastas deve ficar parecida com a minha:

Dentro do arquivo __ init __.py escreva o codigo da seguinte forma:


# flask imports
from flask import Flask


def create_app():
    '''
        Função para criar um aplicativo Flask
    '''

    # Instanciando a o objeto Flask()
    app = Flask(__name__)

    # retornando o objeto app
    return app

Agora, dentro do arquivo settings.py iremos criar o nosso comando. O mesmo será responsável por criar apps em nossa aplicação, sem precisarmos criar arquivo por arquivo.

Contextualizando...

Como flask é um micro-framework, o mesmo vem apenas com o basico para criarmos uma aplicação web, dessa forma, não temos tantas ferramentas prontas, como o django, por exemplo. No django, ao executarmos o comando django-admin startapp criamos uma app dentro do diretorio em que você esta, contendo dentro dessa app os arquivos necessários para que possamos trabalhar, agilizando o processo de criação de nossa aplicação.

Dito isso, iremos fazer algo parecido para nossa aplicação flask, sem muita complexidade e de forma intuitiva, para que vocês possam ver como funciona o CLI do Flask.

Dessa forma, dentro do arquivo settings.py, iremos inserir o seguinte codigo:

# python imports
import os
import subprocess

# flask imports
import click
from flask import request, Blueprint


# Registrando blueprint
bp_settings = Blueprint('settings', __name__)

@bp_settings.cli.command("startapp")
@click.argument("name")
def create_folder_app(name):
    '''
        Essa função cria uma app dentro
        do projeto, ja com os arquivos
        necessarios para trabalhar.

        Exemplo: flask startapp <nome_da_app>

        Dentro da pasta contém os arquivos: 
            - '__init__.py' -> arquivo __init__.py 
            dentro de um subdiretório será sempre o 
            primeiro a ser executado quando um módulo 
            dentro deste subdiretório for chamado;

            - 'views.py' -> arquivo responsavel por
            conter a logica de cada app;

            - 'models.py' -> arquivo que contém uma classe
            que abstrai em modelo uma tabela do banco de dados;

            - 'forms.py' -> arquivo que pode ser usado
            para abstrair os forms HTML, utilizando a 
            lib Flask-WTForms.

        Foi utilizado a função click do 
        flask, responsável por criar
        comandos e argumentos para a 
        aplicação.
    '''

    # Atribuindo o argumento recebido
    # na variavel "name"
    name=name

    try:
        # Acessando a pasta 'app'
        here = os.path.dirname(os.path.dirname(__file__))

        # Setando o caminho e o nome
        # dos arquivos que serão criados
        filepath_init = os.path.join(here, f'{name}', '__init__.py')
        filepath_views = os.path.join(here, f'{name}', 'views.py')
        filepath_models = os.path.join(here, f'{name}', 'models.py')
        filepath_forms = os.path.join(here, f'{name}', 'forms.py')

        # Criando pasta
        os.mkdir(os.path.join(here, f'{name}'))
        try:
            # Criando os arquivos
            f = open(filepath_init, 'w')
            f = open(filepath_views, 'w')
            f = open(filepath_models, 'w')
            f = open(filepath_forms, 'w')

            print('App criada com sucesso')
        except IOError as e:
            print(e)
    except IsADirectoryError as e:
        print(e)

Resumidamente, o codigo acima cria uma app dentro da pasta app do projeto, contendo os arquivos comumente usados, sendo eles, __ init __.py, views.py, models.py, forms.py.

Agora, vamos voltar para nosso arquivo __ init __.py e adicionar o seguinte trecho de código:


 # flask custom commands
 with app.app_context():
     from .settings import create_folder_app
     app.cli.add_command(create_folder_app)

O arquivo __ init __.py completo ficará assim:


# flask imports
from flask import Flask


def create_app():
    '''
        Função para criar um aplicativo Flask
    '''

    # Instanciando a o objeto Flask()
    app = Flask(__name__)

    # flask custom commands
    with app.app_context():
        from .settings import create_folder_app
        app.cli.add_command(create_folder_app)

    # retornando o objeto app
    return app

Agora, vamos exportar nossas variaveis de ambiente, para que a aplicação flask funcione corretamente. Siga os passos:

Em seu terminal, dentro da pasta projeto, digite consecutivamente:

export FLASK_APP=project
export FLASK_ENV=Development
export FLASK_DEBUG=True

Feito isso, ja podemos executar o seguinte comando no terminal, para, de fato, utilizarmos nosso comando:

flask startapp projeto/usuarios

O comando acima irá criar nossa app dentro da pasta projeto.

Após executar o mesmo, a seguinte ordenação de pasta será criada:

Pronto, agora ja conseguimos agilizar um de nossos procedimentos diarios no desenvolvimento de uma aplicação flask.

Considerações finais

O intuito desse artigo foi mostrar a liberdade que temos com o flask e o quanto o mesmo é expansível a modo de facilitar a nossa vida no dia a dia.

100 days of code — Dia 13

DrxwHe4rt — Mon, 30 Nov 2020 21:38:07 +0000

(30/11/2020)

[Nos finalmente...]

Esse semana, provavelmente, estaremos finalizando o projeto e hospedando o mesmo. Foi um mês de desenvolvimento e o conteudo pedido esta sendo entregue na data regulamentar, agora só temos que alinhar alguns detalhes e decidir a melhor hospedagem para o sistema.

Terminei de ler o livro do Machado de Assis (O alienista) e o livro "o que é o racismo". Deixarei para ler o livro "Uma carta de amor" futuramente, então irei retira-lo da lista de livros que estou lendo e começarei a ler o livro "histórias sobre ética".

O que é racismo: 82/82 páginas;
Histórias sobre ética: 0/12 capitulos;
O Alienista: 13/13 capitulos;

Se hidratem, comam frutas, leiam bastante, a terra não é plana, vacinas salvam vidas e bolsonaro vai tomar no cu.

100 days of code — Dia 12

DrxwHe4rt — Wed, 25 Nov 2020 14:25:59 +0000

(24/11/2020)

[ideia bem pensada, ideia bem executado...]

Em contra-partida, ao dia anterior, hoje, tivemos a ideia de fazer tudo em apenas um lugar e fazer tudo dinamico, de uma forma que, se o usuário for funcionario, terá acesso basico ao ponto eletronico, ou seja, irá apenas registrar o ponto. Porém se for supervisor/diretor, também terá a funcionalidade de aprovar/reprovar os pontos de cada funcionario e organizar todo o setor.

Podemos dizer que, 90% da tela esta finalizada!

Hoje , também não li nada :(

O que é racismo: 40/82 páginas;
Uma carta de amor: 0/9 capitulos;
O Alienista: 5/13 capitulos;

Se hidratem, comam frutas, leiam bastante, a terra não é plana, vacinas salvam vidas e bolsonaro vai tomar no cu.

100 days of code — Dia 11

DrxwHe4rt — Wed, 25 Nov 2020 14:16:10 +0000

(23/11/2020)
[ideia mal pensada, ideia mal executada...]

Juntamente ao cliente, tivemos a ideia de criar duas telas, uma para o funcionario bater o ponto e outra de uso restrito aos supervisores do setor/diretores, na qual os mesmos poderiam validar os horarios de ponto de cada funcionario e validar/invalidar cada ponto, adicionar comentario, etc. O que não havíamos pensado é que tudo isso poderia ser feito em apenas um lugar, além de economizar processamento, gastaríamos muito menos tempo, porém, todavia, entretanto, só fui perceber isso dps de finalizar quase tudo, mas nesse ponto, ja havia perdido um dia de trabalho. Na realidade, eu prefiro dizer que foi conhecimento adquirido...

Esse foi o resumo do que eu tenho planejado até quarta-feira para fazer.

Sobre minha leitura, li 5 capítulos do livro do Machado de Assis (O Alienista).

O que é racismo: 40/82 páginas;
Uma carta de amor: 0/9 capitulos;
O Alienista: 5/13 capitulos;

Se hidratem, comam frutas, leiam bastante, a terra não é plana, vacinas salvam vidas e bolsonaro vai tomar no cu.

100 days of code — Dia 10

DrxwHe4rt — Wed, 25 Nov 2020 13:57:34 +0000

(20/11/2020)

[Batendo ponto!]

Na sexta-feira, comecei a desenvolver a App que será responsável por gerenciar os horarios de entrada/almoço/saida dos funcionarios. Com certeza será a parte mais importante do sistema.

Apenas estruturei a ideia e conversei com o cliente sobre como tudo irá funcionar, abordamos alguns exemplos, passei algumas idéias e chegamos a um ponto final, sobre esse módulo do sistema.

Hoje, infelizmente, não li nada :(

O que é racismo: 40/82 páginas;
Uma carta de amor: 0/9 capitulos;
O Alienista: 0/13 capitulos;

Se hidratem, comam frutas, leiam bastante, a terra não é plana, vacinas salvam vidas e bolsonaro vai tomar no cu.

100 days of code — Dia 9

DrxwHe4rt — Fri, 20 Nov 2020 19:01:15 +0000

(19/11/2020)

[Terminei o calendario]

Finalmente terminei o calendario, cara que trabalho sensacional, dediquei cada segundo dessa semana de trabalho para desenvolver algo do zero (quem sabe eu não disponibilizo um modulo disse só no github). Porém, como dito, foi preciso dedicar cada segundo de trabalho, ontem, por exemplo, fiquei das 9hrs da manhã até as 21hrs da noite trabalhando (não se preocupe, eu sei que não é ideal).

Em segundo plano, estou estudando Emacs, pois que fazer uma integração com Emacs + python, mas esse assunto fica para um proximo artigo.

A novidade é que terminei de ler o livro sapiens que, por sinal, foi um dos melhores livros que ja li em toda a minha vida. Acrescentei mais dois livros para a lista de livros que estou lendo no momento, segue atualização abaixo:

Sapiens: 428/428 páginas;
O que é racismo: 40/82 páginas;
Uma carta de amor: 0/9 capitulos;
O Alienista: 0/13 capitulos;

O livro "Uma carta de amor" é um romance do escritor Nicholas Sparks, é a primeira vez que leio romance;
"O Alienista" é um classico do Machado de assis, que eu queria ler a muuuuuuuuito tempo.

Se hidratem, comam frutas, leiam bastante, a terra não é plana, vacinas salvam vidas e bolsonaro vai tomar no cu.

100 days of code — Dia 8

DrxwHe4rt — Thu, 19 Nov 2020 01:45:42 +0000

(18/11/2020)

[fullcalendar + django]

Hoje, trabalhei com algo que não havia usado antes, utilizei o FullCalendar, que é um conjunto de ferramentas em javascript para trabalhar com calendários. Fiz uma integração com o framework Django, onde o django ficou responsavel por gerenciar as views e com js fiz as funções para consumir o retorno das views. Como eu não havia feito esse tipo de integração antes, acabou tomando meu dia todo, mas ainda consegui ler um pouco, assim que acordei de manhã.

Sapiens: 386/428 páginas;
O que é racismo: 40/82 páginas;

Se hidratem, comam frutas, leiam bastante, a terra não é plana, vacinas salvam vidas e bolsonaro vai tomar no cu.

100 days of code — Dia 7

DrxwHe4rt — Tue, 17 Nov 2020 21:01:15 +0000

(17/11/2020)

[Hoje foi super produtivo]

Hoje tive um daqueles dias em que acordamos inspirados. Consegui aplicar todas as regras de negocio do sistema e agora os usuários estão 100% separados por tipos (explicados em um dos artigos anteriores) e, agora também estão, separados por grupos (os grupos são, nesse caso, as empresas. Cada usuário terá um grupo, ou seja, cada usuário fara parte de um grupo. É uma relação de varios usuários para um grupo).

Ainda não li os livros hoje, mas segue abaixo como esta a leitura:

Sapiens: 361/428 páginas;
O que é racismo: 40/82 páginas;

A partir de amanhã, começarei a desenvolver a agenda da aplicação e será uma parte muito desafiadora pra mim, pois nunca desenvolvi uma agenda. Então, é isso!

Se hidratem, comam frutas, leiam bastante, a terra não é plana, vacinas salvam vidas e bolsonaro vai tomar no cu.