DEV Community: Vinícius Muniz de Melo

Callable Python

Vinícius Muniz de Melo — Tue, 10 Jan 2023 13:45:24 +0000

Introduction

Python has a lot of magic methods that can be really confusing sometimes.
We often do not realize the real need for a particular method, or we don't know how to apply it in the real world.
In this post, I'll explain a real use of one of them, the infamous __call__.

Abstract Class

The Python language has abstract class support
Callabe, which helps us to create a class compatible with the Callable protocol, creating a class that inherits from Callable helps us in the correct implementation of the same.

To use this abstract class, you only need to import it from the abc library: from collections.abc import Callabe and inherit it in your own class.

usage

Let's use an example, using a Mapper directly from an ORM (in this case, [SQLAlchemy()]), for a domain object, or class. That is, we will transform the ORM fields into a Python object without any coupling or external dependencies.

Callable Class:

from .dog_domain import Dog
from collections.abc import Callable


class DogMapper(Callable):
    @staticmethod
    def to_domain(dog):
        return Dog(name=dog.name, legs=dog.legs, color=dog.color,) if dog else None

    def __call__(self, dog):
        return self.to_domain(dog)

ORM Class:

from app import db
from .dog_mapper import DogMapper


class Dog(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100))
    legs = db.Column(db.Integer)
    color = db.Column(db.Integer)

    @property
    def mapper(self):
        return DogMapper()(self)

Domain Class:

class Dog:
    def __init__(self, name, legs, color):
        self.name = name
        self.legs = legs
        self.color = color

    @clasmethod
    def create(cls, name, color, legs=4):
        return cls(name, color, legs,)

Explanation

In this case, we use the mapper property to initialize the mapper, and the conversion to the domain object automatically. This facilitates enough if we had to get some class by id, then import the Mapper and then perform the conversion in the end.

Done this way, callable is only used on demand, and when necessary. Thus, we do not carry out the conversion without a real need.

That way, we can use the mapper directly from the model, right after, such as:

dog = Dog.query.get(id=15).mapper

Conclusion

In this post I tried to demonstrate a real use of a Callable class, I hope that has helped!
If you have any questions or suggestions, don't hesitate to comment. 😉

See ya!

References

Hobbies Nao Projetos

Vinícius Muniz de Melo — Mon, 11 May 2020 13:40:33 +0000

Introdução

Na vida de uma pessoa da área de tecnologia, sempre pensamos um passo à frente
em nossas carreiras, no próximo projeto, na próxima grande mudança de emprego,
naquela palestra que te dará visibilidade ou mesmo naquela contribuição em
projetos Open Source que fará toda a diferença em algum momento no futuro.

Hoje quero dizer que isso, na verdade, não importa tanto!

Projetos Pessoais

Crescimento pessoal, evolução e grandes objetivos são as frases que todo coach
diz e, nós mesmos, já até internalizamos esse tipo de atitude sempre que iniciamos
algo ou para planejar nossas vidas e ações. Mas isso não é o que realmente importa.

Em um mundo cada vez mais preocupado com o ter, e não com o ser, estamos perdendo
oportunidades ótimas de nos desenvolvermos fora das telas do computador; hoje em dia o
diferente não é ter milhares de sites criados, um portfólio imenso ou contribuído em
inúmeros projetos Open Source, o diferente é fazer escalada nos sábados, andar de bicicleta
pro trabalho, fazer Ioga todas as quartas ou jogar tênis de mesa toda terça e quinta.

Vocabulário

Nosso vocabulário mundano tem diminuído muito com a extrema especialização que estamos vivendo,
cada vez mais as pessoas se juntam com outras pessoas similares, que falam e fazem sempre as
mesmas coisas e que, juntos, parecem mais uma colônia de formigas do que seres humanos únicos,
criativos e cativantes.

Àquela conversa no meio do cafézinho está cada vez mais rasa, não conseguimos deixar de tocar
no assunto trabalho, nós não somos os nossos trabalhos. Há muito mais vida fora do trabalho
do que dentro dele, nós trabalhamos para viver ou vivemos para trabalhar? Não existe mais nada
de interessante fora nossa bolha? E fora do nosso trabalho?

Sem falar nas nossas crenças, calorosas e opinativas. Sabemos de tudo mas, ao mesmo tempo, não
sabemos de nada. Não vivemos mais sem o Google ou o Wikipédia, nossas falas estão marcadas
por aquilo que ouvimos falar e não por aquilo que realmente vivenciamos ou sentimos.

Hobbies

E, talvez, a salvação desse destino sejam os Hobbies...

Criar novas formas de se divertir, experimentar uma caminhada na praia, ler um livro ao pôr do sol,
sair do computador.

Tentar entender o que o outro sente, realmente se importar com outras pessoas e não somente com o que
ela faz, com o que ela têm ou com quem ela anda.

Somos mais do que isso e podemos ser melhores do que estamos sendo.

A evolução na vida não se dá só por aquilo que entregamos, mas como entregamos, com empatia,
com respeito e entendendo a real necessidade do outro lado.

Que criemos novos Hobbies, novas formas de ver o mundo, novos horizontes, novas perspectivas
e não novos projetos!

Fim

Quer ver mais posts como esse?
Veja no meu blog

Callable Python

Vinícius Muniz de Melo — Sat, 09 May 2020 19:42:55 +0000

Introdução

Python tem diversos métodos mágicos que, às vezes, podem ser realmente confusos.
Muitas vezes não percebemos a real necessidade de um determinado método, ou não
sabemos como aplicá-lo no mundo real.

Nesse post, explicarei uma utilização real de um deles, o famoso __call__.

Classe Abstrata

A linguagem Python tem suporte à classe abstrata
Callabe,
que nos auxilia na criação de uma classe compatível com o protocolo Callable,
criando uma classe que herde de Callable nos auxilia na correta implementação da
mesma.

Para utilizar esse classe abstrata basta importá-la da biblioteca abc: from collections.abc import Callabe e herdá-la na sua própria classe.

Utilização

Nesse post, irei exemplificar com a utilização de um Mapper direto de um ORM (no
caso, SQLAlchemy), para um objeto, ou classe, de domínio.
Ou seja, iremos transformar os campos do ORM, para um objeto Python sem nenhum
acoplamento ou dependências externas.

Classe Callable:

from .dog_domain import Dog
from collections.abc import Callable


class DogMapper(Callable):
    @staticmethod
    def to_domain(dog):
        return Dog(name=dog.name, legs=dog.legs, color=dog.color,) if dog else None

    def __call__(self, dog):
        return self.to_domain(dog)

Classe ORM de exemplo:

from app import db
from .dog_mapper import DogMapper


class Dog(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100))
    legs = db.Column(db.Integer)
    color = db.Column(db.Integer)

    @property
    def mapper(self):
        return DogMapper()(self)

Classe de domínio:

class Dog:
    def __init__(self, name, legs, color):
        self.name = name
        self.legs = legs
        self.color = color

    @clasmethod
    def create(cls, name, color, legs=4):
        return cls(name, color, legs,)

Explicação

Nesse caso, utilizamos a property mapper para realizar a inicialização do
mapper, e a conversão para o objeto de domínio automaticamente. O que facilita
bastante caso tivéssemos que obter alguma classe por id, depois importar o
Mapper e depois realizar a conversão.

Feito dessa forma, o callable é utilizado somente sob demanda, e quando
necessário. Assim não realizamos a conversão sem que haja real necessidade.

Assim, podemos utilizar o mapper diretamente do model, logo na sequência,
como por exemplo:

dog = Dog.query.get(id=15).mapper

Conclusão

Nesse post tentei demonstrar uma utilização real de uma classe Callable, espero
que tenha ajudado!
Caso tenha alguma dúvida, ou sugestão, não hesite em comentar. 😉

Nos vemos por aí!

Referências

Mais posts como esse, olhe no meu blog