Montando APIs em minutos com Django Rest Framework

Olá!

Na última semana participei de uma live no canal do Eduardo Mendes falando um pouco sobre Django Rest Framework e como fazer aplicações de forma muito rápida e organizada.

Entre os temas abordados falei:

• Melhor estrutura para um projeto Django
• Por que utilizar Django Rest Framework
• Quais as vantagens do Django Rest Framework
• Como criar ViewSets
• Pra que serve serializers
• Quando usar GET, POST, PUT e PATCH

Não deixe de conferir!
Se ficar com alguma dúvida comente abaixo por favor!

Python can't find my module

When using Python, add your project module to PYTHONPATH:

export PYTHONPATH=$(pwd)

Jupyter + Pyspark: link

Precisando colocar o Pyspark pra trabalhar no Jupyter encontrei este link: https://blog.sicara.com/get-started-pyspark-jupyter-guide-tutorial-ae2fe84f594f

Muito bom e muito direto.

Diretamente ao ponto:

import findspark
findspark.init()

Python: condense dir file contents into one output file

Dica rápida: juntar conteúdo de todos os arquivos de um diretório em um unico arquivo de output:

import os


def condense_files(path, output_file_name=None):
    """Condense all file contents inside a path into one output file"""
    default_file_name = "CONDENSED"
    output_file_name = output_file_name or default_file_name
    file_list = os.listdir(path)
    if os.path.isabs(output_file_name):
        output_file_path = output_file_name
    else:
        output_file_path = os.path.join(path, output_file_name)
    if os.path.isfile(output_file_path):
        raise FileExistsError("Alread exists %s" % output_file_path)

    if os.path.isdir(output_file_path):
        output_file_path = os.path.join(output_file_path, default_file_name)

    with open(output_file_path, "w") as output_file:
        for file_name in file_list:
            with open(os.path.join(path, file_name), "r") as in_file:
                output_file.write(in_file.read())
    return output_file_path


if __name__ == '__main__':
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument('--input')
    parser.add_argument('--output')
    args = parser.parse_args()
    condense_files(args.input, args.output)

Random string generation Python and Django

Pure Python exemple:

import string
import random


def random_string(lenth=10):
    return ''.join(random.choices(string.ascii_uppercase + string.digits, k=10))

Ref.: https://stackoverflow.com/questions/2257441/random-string-generation-with-upper-case-letters-and-digits-in-python

If you are using Django, it ready to use in crypto module:

from django.utils.crypto import get_random_string

The raw code:

def get_random_string(length=12,
                      allowed_chars='abcdefghijklmnopqrstuvwxyz'
                                    'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'):
    """
    Return a securely generated random string.

    The default length of 12 with the a-z, A-Z, 0-9 character set returns
    a 71-bit value. log_2((26+26+10)^12) =~ 71 bits
    """
    if not using_sysrandom:
        # This is ugly, and a hack, but it makes things better than
        # the alternative of predictability. This re-seeds the PRNG
        # using a value that is hard for an attacker to predict, every
        # time a random string is required. This may change the
        # properties of the chosen random sequence slightly, but this
        # is better than absolute predictability.
        random.seed(
            hashlib.sha256(
                ('%s%s%s' % (random.getstate(), time.time(), settings.SECRET_KEY)).encode()
            ).digest()
        )
    return ''.join(random.choice(allowed_chars) for i in range(length))

Permissões customizadas no Django (2018)

Há alguns anos escrevi aqui um post sobre criação de permissões do Django com South. Hoje em dia as migrações estão integradas ao Django e as formas possíveis para criação de permissões são mais simples e mais elegantes.

Como documentado AQUI basta adicionar as permissões desejadas ao class Meta do model. Depois disso um make migrations e por fim migrate e pronto.

DJANGO CUSTOM PERMISSIONS 2018

Some years ago i wrote HERE about Django migrations using south. Since Django 1.4, migrations were integrated to it, and we have another way. You can check this out HERE in Django's documentation. Steps below!

1 - Models class Meta:

from django.db import models
from django.conf import settings


class UserProfile(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL, editable=False, on_delete=models.PROTECT)

    class Meta:
        permissions = (("can_read_own_contents", "Can read own contents"),
                       ("can_read_others_contents", "Can read others contents"),)

2 - Make migrations:

$ python manage.py makemigrations 
Migrations for 'user_profile': 
 user_profile/migrations/0001_initial.py 
   - Create model UserProfile

3 - Check migration data:

from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion


class Migration(migrations.Migration):
    initial = True

    dependencies = [
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
    ]

    operations = [
        migrations.CreateModel(
            name='UserProfile',
            fields=[
                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('user', models.OneToOneField(editable=False, on_delete=django.db.models.deletion.PROTECT,
                                              to=settings.AUTH_USER_MODEL)),
            ],
            options={
                'permissions': (('can_read_own_contents', 'Can read own contents'),
                                ('can_read_others_contents', 'Can read others contents')),
            },
        ),
    ]

4 - Migrate:


Done!

Configurando PySpark no PyCharm

Dica rápida de configuração do Apache Spark no Pycharm:

1 - Abra as configurações do projeto (File -> Settings)

2 - Em "Project Structure" clique em "+ Add Content Root"

3 - Navegue até o diretório de instalação do Spark no computador e clique em "python" e depois "ok"

4 - Navegue novamente até o diretório de instalação do Spark dentro de python/lib selecione o py4j e "ok" novamente

Deve funcionar!

Django Rest Framework ViewSets - Mais Fácil

Há cerca de um ano venho trabalhando diretamente com APIs em Django. As ViewSets do rest sempre me pareceram confusas, não entendia bem o modelo, mas me parece que as coisas ficaram mais fáceis agora, vou tentar explicar como usar uma ModeViewSet:

Passo 1 - O model:
Um model padrão do Django com um campo nome

from django.db import models
from messaging.managers import MessageManager


class MessageGroups(models.Model):
    name = models.CharField(max_length=30, unique=True)

    def __str__(self):
        return self.name

Passo 2: A View (ViewSet):
Um ViewSet com queryset padrão trazendo todos os grupos cadastrados

from rest_framework import viewsets

from messaging.models import MessageGroups
from messaging.serializers import MessageGroupSerializer


class MessageGroupViewSet(viewsets.ModelViewSet):
    serializer_class = MessageGroupSerializer
    queryset = MessageGroups.objects.all()

Passo 3: O Urls.py:
No URLs.py do app ou do projeto deve ser adicionada a chamada para DefaultRouter e registrar a url do ViewSet (e foi aqui que me embananei). Depois disso, o urlpatterns deve ser acrescido do router.urls. É muito simples, mas eu relamente me compliquei nessa parte

from django.urls import path, include
from rest_framework.routers import DefaultRouter

from messaging.views import MessageGroupViewSet

router = DefaultRouter()
router.register(r'api/message/groups', MessageGroupViewSet, base_name='message_group')

urlpatterns = [
    path('any_url', AnyViewClass.as_view()),] + router.urls

AND IT IS DONE!
Ele vai criar os métodos de listagem, criação, edição e exclusão para o model utilizando o serializer definido no ViewSet, muito simples. Os métodos podem ser sobrescritos, assim como as views comuns. Enfim, facilitou muito o meu trabalho que era basicamente um CRUD filtrando as mensagens e grupos relacionados ao usuário.