DEV Community: Valery C. Briz

Conseguir tu primer trabajo en Tech 🔥

Valery C. Briz — Sat, 03 Jun 2023 11:51:43 +0000

Hace unos días me invitaron a impartir una charla sobre el proceso para poder conseguir un trabajo en la industria tech a personas que están empezando en el area.

En la charla me he enfocado en hacer énfasis en los consejos y recomendaciones que a mi misma me han ayudado a lo largo de mi carrera y los recursos que son de mucha utilidad para conseguir un portafolio que destaque sobre los demás.

Este es el resumen de la presentación con links y tips 🔥

Proceso de selección en tech

El proceso de selección varía entre una empresa/proyecto a otro pero la mayoría de procesos siguen un orden similar al siguiente:

Currículum vitae

Este primer paso es muy importante por que es la puerta de entrada al proceso de selección y tomando en cuenta que la cantidad de cv's que reciben los reclutadores para posiciones junior son bastante altas, realmente tenemos que sobre salir de entre todos para poder tener una oportunidad.

En este artículo no me enfocaré en el formato del cv sino mas bien en la sección de experiencias previas.

Cuando estamos a penas entrando a un area nueva es común que no sepamos que incluir en esta sección, sin embargo hay una gran cantidad de recursos que nos pueden servir para generar experiencias completamente validas para el cv.

Contribuír a proyectos de código abierto

Este tipo de experiencia puede aportar bastante solidez a nuestro cv ya que no solo podemos comprobar que hemos desarrollado parte de un proyecto sino que la empresa puede revisar el código que hemos aportado y verificar que es de calidad.

Las principales plataformas donde podemos encontrar proyectos de código abierto son:

A demás esta página recoge un listado de filtros con los cuales podremos encontrar issues o "necesidades" que tienen los proyectos, etiquetados con un nivel "bajo" de experiencia o que son buenos para personas que contribuyen por primera vez:
https://www.firsttimersonly.com

Hackatones

Los hackatones son eventos en los que un grupo de personas se reunen fisicamente o virtualmente para desarrollar una o varias ideas en un tiempo determinado.

Estas experiencias también son bastante valoradas porque no solo se trata de desarrollar código sino de desarrollar una idea y de trabajar en equipo. Cualidades muy valoradas al momento de buscar developers.

Aquí puedes encontrar listados de hackatones que sucederán a lo largo del año:

Competencias y ejercicios

Existen una gran cantidad de sitios donde podemos encontrar ejercicios o ideas de desarrollo de software que podemos desarrollar y subir a nuestro repositorio de preferencia para utilizarlo como portafolio.

Aquí listo algunas de ellas:

También existen comunidades como Hablemos Python donde se promueve el desarrollo de proyectos realizados por la comunidad y que aportan justamente esa experiencia de desarrollo en equipo para personas de todos los niveles y con conocimientos en distintas tecnologías, ya que la mayoría de proyectos necesitan diversidad de perfiles para poder completarse.

Entrevista inicial con RH

Una vez que has sido seleccionadx para empezar el proceso de selección, vendrá la primera entrevista con recursos humanos, usualmente querrán conocer un poco sobre tí y sobre tu experiencia previa.

Aquí es donde utilizaremos todo lo que aprendimos al desarrollar los proyectos anteriores para demostrar los conocimientos con los que contamos.

Muchas veces en este punto van a preguntarte cual es tu expectativa salarial, aquí podemos tener puntos de vista diferentes, ya que hay personas que prefieren no responder a este tipo de preguntas, lo cual es completamente valido.

Pero algunas otras personas prefieren establecer una cantidad mínima, por lo que si la empresa no puede pagarte esa cantidad y tu no estas dispuestx a negociarla, el proceso de selección ya no continuaría. Esto puede ser bueno si no quieres invertir tu tiempo en las entrevistas y pruebas técnicas, si al final no se podrá realizar el acuerdo.

Asi que mi recomendación para este paso es que investigues a la empresa, su valores y sus productos o servicios, para poder saber si es una empresa que encajaría con tu forma de pensar y también para descartar a posibles empresas con culturas laborales tóxicas.

Un sitio que puede servir para investigar salarios y opiniones es https://www.glassdoor.es, también puedes buscar en linkedin y en plataformas como github.

Pruebas técnicas

Existen una gran cantidad de pruebas técnicas, aquí hablaré un poco de los tipos de pruebas a las que me he enfrentado yo.

Resolver un problema con código en tiempo real (ó con límite de tiempo)

En este tipo de prueba lo más importante es entender el problema y explicarle a la persona que entrevista, como planeamos resolverlo, aún a pesar de que el código no funcione.

Si la posición requiere conocer sobre Testing tendrás que desarrollar con TDD en está prueba.
Algunos sitios donde podras encontrar ejercicios para practicar:

Resolver un problema con código de forma asíncrona

En este tipo de prueba nos envían un problema el cual tenemos que resolver y usalmente tendremos algunos días o una semana para hacerlo, con todas las herramientas que tengamos a nuestro alcance.

Lo más importante en este caso es utilizar buenas prácticas y si hay código previo en el proyecto, es importante identificar errores o mejoras que se puedan hacer.

Si después de lograr esto te queda tiempo, has todos los tests que puedas.

En la entrevista de revisión del código, propón mejoras en el código y si no te dió tiempo de hacer algo, explicales que te hubiese gustado implementar si tuvieras más tiempo.

Algunos repositorios donde podemos encontrar código de este tipo para practicar:

Pair programming

En este caso es muy importante comunicarte con la persona que te entrevista y preguntarle constantemente su opinión sobre lo que propones ya que ellos te han dicho que es un pair programming y esperan que actues "de forma natural" como si fuese un día normal de trabajo.

Normalmente se requiere que propongas mejoras al código si es que ya existe.

Resolver un problema de forma conceptual

En este caso la comunicación es muy importante, explicar con detalle los conceptos que te preguntan y casos de aplicación puede hacer la diferencia.

No supongas nada, mejor pregunta para estar segurx de que es lo que quieren escuchar.

Entrevista de cultura laboral

Algunas empresas realizan este tipo de entrevistas donde se trata de entender si tu podrías encajar en el equipo pero también si a tí te hace sentido la empresa. Esta entrevista es muy util para hacer todas las preguntas que tengas sobre el día a día en la empresa y de cuales son las opciones de crecimiento que podrían existir.

Comunidades

Finalmente algo que siempre le recomiendo a las personas que están en busqueda de trabajo es asistir y formar parte de una o varias comunidades de tecnología.

Existen comunidades en todo el mundo, algunas tienen actividades en persona y otras actividades virtuales. De cualquier forma, formar parte de una comunidad puede ayudarte a crecer tu red de contactos, aprender de personas que están en distintos niveles en areas similares a la tuya y también para compartir tu experiencia.

A demás es justo en estas comunidades donde surjen muchos proyectos o eventos en los que es posible participar y que también pueden aportar en tu cv, por ejemplo voluntariados y contribuciones a proyectos open source.

Muchas de estas comunidades puedes encontrarlas en:

También puedes seguirles en twitter, linkedin y facebook para estar al pendiente de las actividades y noticias de la comunidad.

¡Espero que estas recomendaciones puedan ayudarte!

Bulk load to Elastic Search with PySpark

Valery C. Briz — Thu, 01 Jun 2023 14:28:31 +0000

If you use Spark to transform your data and you are planning on load it directly from spark to Elastic Search then perhaps this short article is for you.

Not so long ago I was in the same situation and started reading the Elastic search documentation to build my PySpark job, but to be honest at the end of my reading I felt like I still had a lot of questions about it.

So thanks to the help of multiple questions answered in StackOverflow and other forums I was able to implement a PySpark job that actually works.

That is why I decided to write this small tutorial and to explain a little bit what are the options available.

If you want to check the full code then you can find it in this Gist.

Connection parameters

The base parameters we need to send in order to connect to Elastic.

df.write.format("org.elasticsearch.spark.sql") \
.option("es.nodes", <elastic_host>) \
.option("es.port", <elastic_port>)

If you are using a cloud environment like AWS or Google Cloud you would also need to add the following options.

.option("es.nodes.wan.only", "true") \
.option("es.nodes.discovery", "false")

Authentication and SSL

This part will depend a little bit on the kind of configurations you currently have on your Elastic Search instance but these are the main options:

SSL enabled or disabled:

This option set as true well enable the ssl for the connection.

.option("es.net.ssl", "true") \

Authentication by user name and password:

If you choose to use the authentication by user name and password then these two need to be added.

.option("es.net.http.auth.user", <user_name>) \
.option("es.net.http.auth.pass", <password>) \

Authentication by ApiKey:

A better way to authenticate is to create an ApiKey and use the Bearer header as an option.

AUTH_TOKEN = f"ApiKey {API_KEY}"
.option("es.net.http.header.Authorization", AUTH_TOKEN) \

Use of a SSL Certificate:

This one can be a little bit tricky since you need to load the .jks truststore file of your Elastic Search instance to all of the cluster nodes and then add the following options.

.option("es.net.ssl.truststore.location", <truststore_location>) \
.option("es.net.ssl.truststore.pass", <truststore_pass>) \
.option("es.net.ssl.cert.allow.self.signed", "true")

Remember that this trustore_location most be accessible from your Spark application, otherwise it will fail.

Index resource options

WRITE_MODE = "append"

# If you want to create the index if it doesn't exists
.option("es.index.auto.index", "true") \
# This is the type of index loading ['update', 'index', 'create'...]
.option("es.write.operation", "index") \
# This is the actual name of the index
.option("es.resource", <elastic_index>) \
# Mapping for the _id field in Elastic
.option("es.mapping.id", "id") \
# Save all the empty values as null
.option("es.field.read.empty.as.null", "true") \
# The write mode can be 'append' or 'overwrite'
.mode(WRITE_MODE) \

In general the configurations for the spark elastic loader are self explanatory, we just need to find the correct options for our specific case.

Hope this can help you!

3 Data Engineering Pitfalls

Valery C. Briz — Wed, 07 Jul 2021 16:54:32 +0000

Cuando diseñamos o mantenemos una infraestructura de datos hay múltiples pain points que pueden resolverse antes de que sea muy tarde… algunos de ellos son bastante obvios pero quizás no les damos importancia, otros son más difíciles de reconocer, hasta que ya estamos muy dentro y la dificultad para salir de ello es gigantesca. Partiendo de esta base, a lo largo de este artículo les describo tres de las trampas más comunes en ingeniería de datos.

1. Arquitectura completamente serverless

Antes que nada debo aclarar que en este caso específico me refiero a serverless del tipo AWS Lambda. ya que actualmente existen una gran cantidad de soluciones efectivas en las distintas clouds que son serverless pero enfocadas a Data workflows como Data flow o AWS Glue.

Las principales ventajas de los servicios serverless (como Lambda) son el fácil despliegue de la lógica de negocio en un «contenedor» listo para escalar de forma automática y a demás lo barato que puede ser pagar unicamente por el tiempo de ejecución, pero…

Es justo allí donde está la trampa, porque hasta ahora todas las ventajas que trae consigo serverless suena genial pero que sucede cuando la pequeña lógica de negocio que utilizamos al inicio dentro del serverless empieza a crecer en tamaño y en complejidad?

Anteriormente mencionamos que el costo de serverless es únicamente por el tiempo de ejecución, pero que sucede si el tiempo de ejecución es tan largo que el servicio casi nunca esta en modo «reposo» o sin consumo de recursos. Y luego claro para poder solventar la complejidad de los pipelines empezamos a crear más y más apps serverless con dependencias entre sí.

Aunado a todo esto, reintentar la ejecución de un pipeline que ha fallado ya sea parcial o completamente, tomando en cuenta todas estas dependencias es en la mayoría de los casos una tarea manual y muy desgastante.

¡Boom!

Sí, boom… cuando se rompe la infraestructura porque es casi imposible mantenerlo a largo plazo a medida que sigue creciendo y solamente queda migrar a una infraestructura más robusta.

2. Monitoreo

Muchos de ustedes habrán sentido ya esa satisfacción de deployar finalmente la última pieza de su genial pipeline, luego de meses de trabajar en ella y arreglar los errores, finalmente está funcionando y los stakeholders están satisfechos con el servicio que se completó.

Parece que ya no hay mucho más que hacer acá, hasta que se requieran cambios o agregar características nuevas al servicio.

¡Cuidado!

Esta es una trampa que sucede principalmente en proyectos o equipos que están en sus comienzos y tienen demasiado trabajo. Y entonces pensamos que es suficiente con guardar los logs de los distintos procesos y dejamos para después la integración de un verdadero sistema de monitoreo.

Estrategias para monitoreo hay muchas, lo importante es darles el tiempo adecuado para analizar en que partes del proyecto es crucial tener un monitoreo activo que pueda ayudarnos a prevenir o al menos a identificar rápidamente los errores que posiblemente ocurrirán.

La mayoría de las veces tardamos mucho más tiempo buscando una solución a un error que montando un sistema de monitoreo que agilizará la solución de estos errores, incluso es muy probable que podamos evitar las consecuencias de un error que puede impactar muchos otros sistemas con tan solo montar alertas adecuadas en el sistema de monitoreo.

3. Arquitectura de datos sin gobernanza

Aunque el tema de la gobernanza de datos no es algo nuevo, aún se nos hace difícil acostumbrarnos a darle el tiempo necesario a establecer y mantener una gobernanza de datos adecuada.

Así que empezaremos por identificar si en su infraestructura existe una gobernanza de datos o no.

Los principales síntomas de una falta de gobernanza son los siguientes:

Toda la data cae al mismo bucket o espacio.
Data de múltiples versiones con estructuras distintas en el mismo espacio.
No existen reglas o políticas establecidas sobre cómo y dónde guardar la data.
Los pipelines mezclan workflows que no tienen relación directa en tema o dominio.
Es difícil hacer modificaciones en los workflows existentes.
No hay documentación sobre los catálogos de datos.
No existen entornos (como data lake, data warehouse, etc) específicamente para desarrollo/pruebas.

Algunas de las consecuencias de la falta de gobernanza son por ejemplo tener una gran cantidad de data duplicada dentro del data lake debido a que la falta de orden hace casi imposible identificar estos duplicados. Cuando hablamos de Big Data esta duplicación puede impactar directamente en los costos no solo de almacenamiento de datos sino también en costos de ejecución ya que mientras más data tengas, más tardan los procesos en transformar y por ende gastan más recursos.

Gobernanza es el proceso de manejar la disponibilidad, usabilidad, integridad y seguridad de los datos en un sistema, basado en estándares internos y políticas de control de los datos.

Disponibilidad: Asegurarse de que los datos sean accesibles de una forma fácil y eficiente dependiendo de quien sea el consumidor de estos.
Usabilidad: Esto implica que los datos resultantes al final del proceso realmente se puedan utilizar para lo que sean necesarios por ejemplo, si son archivos xml o protobufs, poder convertirlos a un formato en el que sea posible consumirlos con queries o por medio de alguna interfáz a la que los consumidores tengan acceso.
Integridad: Debemos estar seguros de que los datos que obtuvimos están completos y no están sucios.
Consistencia: Asegurarse de que en caso de haber diferentes versiones o cambios repentinos, por ejemplo al consumir datos desde una fuente externa, esto no debe afectar el actual funcionamiento y pueda existir una transición hacia nuevas versiones.
Seguridad: No solo mantener los sistemas, conexiones y servers seguros con firewalls, vpns y muchas otras herramientas que tenemos ahora en la nube sino también poder estar seguros de que a pesar de que tengamos un data lake privado, se limite el acceso a datos de producción sensibles a los usuarios que realmente los necesitan y en caso de ser datos muy delicados, tener una estrategia como la encriptación. También tener la opción de borrar los datos en caso de que un cliente lo pida ya que es su información y que “el desorden” no sea impedimento.

Algunas de las estrategias para implementar o mejorar la gobernanza de datos son las siguientes:

Establecer políticas de uso de los datos.
Crear y actualizar los catálogos de datos.
Crear y actualizar las definiciones/diccionarios de datos.
Establecer políticas de Seguridad de los datos.
Reconocer los Data Domains dentro de la organización.

¿Un Data Domain?

Es una colección de información y procesos relacionados a esa información que son independientes de otras colecciones o procesos y se consume por medio de su propia interfaz.

Conclusiones

En base a lo comentado, estas son algunas de las conclusiones que he obtenido:

Empieza pequeño (Metodología Lean). Solo puedes controlar lo que puedes medir. Define quienes son las personas responsables de cada proyecto o dominio.
La Gobernanza es un trabajo en equipo que requiere de todas las partes involucradas para que pueda funcionar.
Educa a las personas involucradas en los proyectos para que siempre estén al tanto de las políticas y planificación.
Mapea y documenta.
Desarrolla definiciones estandarizadas.
Identifica los dominios de datos.

Originalmente publicado en:
https://planetachatbot.com/3-trampas-en-ingenieria-de-datos/

¿Quienes son las PyLadies?

Valery C. Briz — Sat, 24 Oct 2020 20:21:14 +0000

En el marco de las elecciones del Consejo Global (Mundial) de PyLadies, la comunidad del Lenguaje de Programación Python ha tenido un gran movimiento en las redes sociales acerca del tema, por lo que últimamente se acercaron muchas personas a preguntarme de qué se trataban las elecciones y quienes eran PyLadies?

Cuando yo empecé a organizar meetups sobre el lenguaje Python en Guatemala, lo único que sabía sobre la comunidad era que habían muchos más grupos alrededor del mundo y que no necesitas tener cierto nivel de experiencia para ser organizadora/or de un “capítulo” en tu ciudad, lo más importante es tener el compromiso de liderar la comunidad sin dejarla morir, de ser constante y que lo que te mueve es el simple deseo de aprender y compartir conocimiento con otras personas.

Las distintas comunidades de Python alrededor del mundo pueden definirse como grupos de personas que se reúnen cada mes a platicar sobre un tema relacionado al lenguaje Python, herramientas, estrategias y vivencias del día a día en el trabajo o el estudio como desarrollador/a de software.

¿La finalidad? aprender y compartir el conocimiento para que más personas tengan acceso a crecer como desarrolladores/as de software. Para algunas personas puede parecer un poco extraño que alguien quiera compartir conocimiento, tiempo y esfuerzo gratis, pero déjenme decirles que el simple hecho de enseñar, te hace aprender, además de que poder compartir deja una huella imborrable que, al menos en mi caso, le da un sentido muy importante a mi día a día.

PyLadies se enfoca en crear espacios en los que todas las personas que se identifiquen como chicas puedan sentirse cómodas para compartir y aprender sobre este lenguaje de programación que en los últimos años ha tomado mucho auge.

Para lograrlo organizamos una gran variedad de actividades como talleres, meetups, congresos, etc. Una de las cosas que más me gustan de PyLadies es que se rige por un código de conducta establecido desde sus comienzos, en el que queda claro que debemos respetar a los demás, de lo contrario la persona que irrespeta no será admitida para asistir en futuras actividades.

Pero no se refiere únicamente a actitudes extremas de falta de respeto sino también al simple hecho de ser excluyente con personas que tienen menos experiencia en el tema, o a burlarse de los demás, porque en PyLadies pensamos que no existen preguntas tontas y que de hecho la diversidad es muy importante si un equipo o grupo de personas quieren crecer en cualquier ámbito.

La importancia de comunidades como la de PyLadies en el mundo cada día toma más importancia, cada día crece más y esto en consecuencia genera un aumento de la diversidad en el ámbito estudiantil y laboral, es por ello que un grupo de líderes a nivel mundial de los distintos capítulos de PyLadies se reunieron en 2019 en el evento de PyCon USA y platicaron sobre la necesidad de un Consejo Global que tomara el liderazgo del futuro de PyLadies, con lo cual se realizaron las primeras elecciones para formar el primer Consejo Global.

Aunque aún queda mucho por definir en los objetivos de este grupo que liderará a PyLadies a nivel mundial, queda claro que es un primer paso certero para que la comunidad siga creciendo y fortaleciéndose en el camino para empoderar a más chicas en el área de tecnología.

How to Go Serverless like a Pro — Cloud Academy

Valery C. Briz — Sun, 14 Jun 2020 03:35:12 +0000

Originally posted on cloudacademy.com

So, ...no servers?

Yeah, I checked and there are definitely no servers.

Well…the cloud service providers do need servers to host and run the code, but we don't have to worry about it. Which operating system to use, how and when to run the instances, the scalability, and all the architecture is managed by the provider.

But that doesn't mean there's no management at all. It's a common misconception that in a serverless paradigm, we don't have to care about monitoring, testing, securing, and other details that we are used to managing in other paradigms. So let's explore the main characteristics that we need to take in consideration when building a serverless solution.

First, why serverless?

One of the great advantages of serverless is that you only pay for what you use. This is commonly known as "zero-scale" which means that when you don't use it, the function can be reduced down to zero replicas so it stops consuming resources — not only network I/O, but also CPU and RAM — and then brought back to the required amount of replicas when it is needed.

The trigger of a function on an AWS Lambda can be an API gateway event, a modification on a DynamoDB table or even a modification on an S3 file as defined in What Are AWS Lambda Triggers? But to really save money on serverless, you need to take into consideration all of the services that a Lambda needs to work. Serverless architecture provides many advantages, but it also introduces new challenges. In this article, we'll provide best practices when building a serverless solution.

To deep dive into building, deploying, and managing the serverless framework, check out Cloud Academy's Serverless Training Library. It's loaded with content and hands-on labs to give you the practical experience you need to integrate serverless architecture into your cloud IT environment.

Monitoring the Lambda

A common mistake is to confuse zero administration with zero monitoring. On a serverless environment, we still need to pay attention to the metrics, and these will be a bit different from the traditional ones like CPU, memory, disk size, etc. Lambda CloudWatch Metrics provides very useful metrics for every deployed function. According to the AWS documentation, these metrics include:

Invocation Count: Measures the number of times a function is invoked in response to an event or invocation API call.
Invocation Duration: Measures the elapsed time from when the function code starts executing to when it stops executing.
Error Count: Measures the number of invocations that failed due to errors in the function (response code 4XX).
Throttled Count: Measures the number of Lambda function invocation attempts that were throttled due to invocation rates exceeding the customer's concurrent limits (error code 429).
Iterator Age: Measures the age of the last record for each batch of records processed. Age is the difference between the time the Lambda received the batch, and the time the last record in the batch was written to the stream. This is present only if you use Amazon DynamoDB stream or Kinesis stream.
DLQ Errors: Shows all the messages that Lambda failed to handle. If the event was configured to be handled by the DLQ, it can be sent again to the Lambda function, generate a notification, or just be removed from the queue.

Besides the default metrics, there are plenty of monitoring services like Dashbird, Datadog, and Logz.io that can be integrated, so we can have additional metrics for a better logs visualization.

Right now, everything seems very clear and straightforward, right? We have some new metrics and configurations to learn, but it is pretty similar to our traditional structures.

But what about tests? Can we even make local tests for serverless?

Tests

Local testing

Since we don't manage the infrastructure anymore, can we run it locally? If so, how can we do that?...

keep reading on cloudacademy.com

Django Queries Optimization

Valery C. Briz — Mon, 30 Mar 2020 00:00:43 +0000

Have you ever asked yourself, is this the best way of doing this query? or is there a more efficient way?

When we have a project with one or more recurrent or long blocking queries we need to take into big consideration that this query might slow down our application or even make the database crash.

Some of this times the trick is to use the available options of the ORM and some times the best way is to write a SQL customized query, but how to know what’s the best in each case?

In this article I’ll show you a series of best practices recommended by Django documentation and by experience so you will have an idea of some of the options out there to optimize your code!

Before deciding what to use you have to know that you may want to optimize the queries for speed or for memory or both, depending on your requirements. But sometimes optimizing for one will affect the other. Also, the tasks that are processed by the database might not have the same resources cost than those made by a Python process. It is up to you to decide what your priorities are and where the balance must lie so you can improve the server resources according to it.

Having the Following Schema

class User(models.Model):
  id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
  name = models.TextField()
  email = models.TextField()
  age = models.PositiveSmallIntegerField()
  team = models.ForeignKey(Team, on_delete=models.PROTECT, related_name='users', null=True)

class Team(models.Model):
  location = models.TextField()
  name = models.TextField()

First than nothing you have to understand that Querysets are Lazy, but what does it means?

It means that the act of creating or declaring a Queryset doesn’t involve any database activity. So you can add filters and conditions line after line and the Queryset won’t be executed until you actually ask for the information, for example:

user_query = User.objects.filter(name="Ana") # Filter the users by the name "Ana"
user_query = user_query.filter(age__lte=50) # Then get only the users where the age is less than 50
user_query = user_query.exclude(email__isnull=True) # And exclude the users that doesn't have an email
print(user_query)

Now in these lines of code, the database gets only one hit in the line print(user_query) which is very useful when you want to add a lot of conditions before the execution but be careful because there are some other methods that might hit the database right away, like:

# Iteration
for user in User.objects.all():
  print(user.name)

# Slicing
User.objects.all()[:10]

# Pickling or Caching
pickle_str = pickle.dumps(user_queryset)
user_queryset = pickle.loads(pickle_str)
len(user_queryset._result_cache)   

# Methods like repr(), len(), list(), bool()
 user_list = list(User.objects.all())
 # or a boolean condition like:
 if User.objects.filter(name="Ana"):
   print("There is at least one user who's name is Ana")

It also means that you have to distinguish which queries are cached so it won’t hit the database again and which will no matter if the query is repeated for example:

# Create the query filtering users with email myemail@gmail.com
users = User.objects.get(email="myemail@gmail.com")
users.name # Hit the database and retrieve the name value
users.name # cached version, no database access  

# Create the query filtering teams named tigers
team = Team.objects.get(name="tigers")
team.users.all() # query performed
team.users.all() # query performed again

So if you need to iterate over a huge dataset and then perform some action with the values a posible solution is to use an iterator().

for user in User.objects.exclude(email__isnull=True).iterator():
   print(user.name)

It will hit the database just once fetching the matching rows but use iterator() with caution, and make sure that your code is organized to avoid repeated evaluation of the same huge Queryset.

A way to avoid the excess of memory usage when the dataset is huge is to execute a boolean condition before populating the whole dataset.

user_queryset = User.objects.all()
 # The first hit to the database confirms if at least one object exists.
 if user_queryset.exists():
   # Another database hit to start fetching the rows in batches.
   for user in user_queryset.iterator():
     print(user.name)

But don’t abuse of the exists(), count() methods because each time you call them a new hit is performed.

We also could retrieve everything at once if we know we’ll certainly need it, to do this we can use prefetch_related() or select_related() so we can get the related fields in other objects and the correct object all at once.

Team.objects.all().prefetch_related('users')

This will return a Queryset that will automatically retrieve, in a single batch, related objects for each of the specified lookups.

Now you have select_related() that returns a Queryset that will look for the foreign-key relationships, selecting additional related-object data when it executes its query. This is a performance booster which results in a single more complex query but means later use of foreign-key relationships won’t require database queries, for example if you need all the user for the team.

# Hits the database
 team_queryset = Team.objects.get(name="tigers")
 # Hits the database again to get the related User objects
 user = team_queryset.user

So rather than doing that you can do this:

# Hits the database
 team_queryset = Team.objects.select_related("user").get(name="tigers")
 # The second line doesn't hit the database, because team_queryset.user  has been previously prepopulated
 user = team_queryset.user

Another way to make a query faster is to retrieve individual objects using a unique, indexed column. As in any other ORM, the query will be quicker because of the underlying database index. Also, the query runs much slower when there are multiple objects matching the filter; having a unique constraint on the column guarantees this will never happen.

user_queryset = User.objects.get(id=10)

Don’t order results if you don’t care. Sometimes Django orders the dataset even if we didn’t ask for that but we can disable it on a Queryset by calling order_by() with no parameters.

user_queryset = User.objects.all().order_by()

Use defer() and only() if you only need certain fields on a dataset to avoid loading all of the fields. Note that if you do use them later, the ORM will have to go and get them in a separate query, making this a pessimization if you use it inappropriately.

# This query retrieves all of the rows on the dataset but only the "name"  field
 user_queryset = User.objects.all().only("name")

Logging All SQL Queries

A pretty useful tool is the ORM logger, this will enable you to inspect all of the queries and also get the time of the execution. To enable this you’ll need to add a few things to your LOGGING configuration in your settings.py. First, you’ll need a handler. The example below logs everything at DEBUG level to the console.

LOGGING = {  
   'handlers': {  
     'console': {  
       'level': 'DEBUG',  
       'class': 'logging.StreamHandler',  
     },  
   },  
 }

Next, you’ll need to add a logger that logs to this handler:

LOGGING = {
   'loggers': {
     'django.db.backends': {
      'level': 'DEBUG',
      'handlers': ['console'],
     },
  },
}

Once the above is set up, you should see a stream of SQL queries in your console output every time you hit the database.
Conclusion

There isn’t a perfect query or a general answer to utilizing the ORM. You should first seek to make your code clear and then work on optimizing it and take into big consideration that some practices may speed up the database processes but spend lots of memory so, be careful and analyze what is the best for your app and your resources.

Originally posted in https://icodemag.com/django-queries-optimization/

Understanding Python Datetime Handling — Cloud Academy

Valery C. Briz — Thu, 08 Aug 2019 16:49:31 +0000

Photo by Aron Visuals on Unsplash

Communicating dates and times with another person is pretty simple… right?

“See you at 6 o’clock on Monday” sounds understandable.

But was it a.m. or p.m.? And was your friend in the same time zone as you when you said that? When we need to use and store dates and times on Python, we have the same issues — and even more — since we can express a date and time in many ways. For example:

“July 15, 2019 07:05 pm”
“2019-15-07 19:05:53 CDT”
“2019-07-15T23:05:53.256587-05:00”
1563231953

All of these strings and even the integer expresses the exact same date and time, but they all look very different one from another, right? In this article, we’ll discuss Python datetimes best practices to reduce the complexity when using, formatting, and storing datetimes on a daily basis. Here are the highlights of what we’ll cover:

To dive deeper into the basic fundamentals of Python, check out Cloud Academy’s new Python for Beginners Learning Path. It’s designed for people new to programming, providing an ideal entry point for people wanting to learn how to program with the Python scripting language.

Python datetimes best practices

When we talk about a Python datetime format standard, we mean the ISO 8601 (Date and Time Format). This format is used in most of the databases and it has the following structure:

YYYY-MM-DDThh:mm:ss.sss +00:00

or

YYYY-MM-DDThh:mm:ss.sss TZ

But when we show it to the user, we might want to change the way it looks. This is because if we use a tool to get it from the user — like a calendar or select inputs — it can also vary on the way the data is sent to the backend.

Creating a Python parser

Luckily, Python has a parser that understands pretty much all of the cases of a string formatting. For example:

Using the following libraries:

from dateutil.parser import parse import datetime as dt from dateutil.tz import tzutc

The parser will actually recognize parameters like these written as text:

first_date = parse('January 31, 2010') print(type(first_date), first_date)

The type of the object looks like this:

>> parse("<class 'datetime.datetime'> 2010-01-31 00:00:00")

And the object created looks like this:

>> datetime.datetime(2010, 1, 31, 0, 0)

The parser can also understand standard notations like “Sat” for Saturday:

second_date = parse("Sat Oct 11 17:13:46 UTC 2003") print(type(second_date), second_date) >> <class 'datetime.datetime'> 2003-10-11 17:13:46+00:00 >> datetime.datetime(2003, 10, 11, 17, 13, 46, tzinfo=tzutc())

We can also directly create a datetime object without the format as following:

my_new_datetime = dt.datetime(2001, 1, 31, 10, 51, 0) print(my_new_datetime) >> 2001-01-31 10:51:00

Creating a Python datetime with a Unix timestamp

There’s yet another way to create a Python datetime with a unix timestamp.

The unix timestamp is a system for describing a point in time. It is the number of seconds that have elapsed since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Every day is treated as if it contains exactly 86400 seconds, so leap seconds are to be subtracted since the epoch. It is used widely in Unix-like and many other operating systems and file formats. _(Wikipedia, 2019) _.

The main characteristic of this format is that we get a datetime stored as an integer. So we can directly convert the Unix timestamp to a Python datetime object with the “fromtimestamp” method as follows:

from_unix_datetime = datetime.datetime.fromtimestamp(528756281) print(from_unix_datetime) >> datetime.datetime(1986, 10, 4, 2, 14, 41)

Or backwards:

from_datetime_timestamp = dt.datetime.timestamp(from_unix_datetime) print(from_datetime_timestamp) >> 528756281.0

Setting the Python datetime time zone

Now an optional — but important — parameter to include is the time zone of the datetime. The default time zone is UTC or the one set on your project. However, if the datetime is captured at a local time (let’s say central time for example) and the database that stores this information has UTC time, then it will have a difference of five hours. This can create a conflict if the server that retrieves this datetime is on eastern time (ET). If you didn’t set the time zone on the creation, there’s a way to add it after with a as following:

my_new_datetime.replace(tzinfo=dt.timezone.utc)

Or we can set it on the creation:

dt.datetime(2001, 1, 31, 10, 51, 0, tzinfo=tzutc())

Another thing to take in consideration is the way you import the datetime library, sometimes on the code we need to call the base datetime library and sometimes we need the datetime.datetime which contains different methods. To avoid this, we can call datetime as dt and datetime.datetime as datetime or to call it directly from dt.datetime.

from datetime import datetime import datetime as dt

Creating datetime ranges

Following with the common Python mistakes, there’s one mistake that happens silently, but it can affect us if we need an exact range of datetimes and our visual calendar tool doesn’t have time selection but only date selection. When we need a datetime range starting from 00:00:00, we can easily add it to the initial date as follows:

today_datetime = dt.datetime.today() # Create a new datetime with today parameters rounded_date = today_datetime.replace(hour=0, minute=0, second=0, microsecond=0) print(rounded_date) >>2019-07-26 00:00:00

We can also add or subtract time to our datetime with a timedelta. The number of days will initialize a new timedelta with a time of 30 days.

time_delta = dt.timedelta(days=30) print(dt.datetime.today() + time_delta) >> 2019-08-25 18:46:02.274584

Or compare two datetimes subtracting one from another:

last_week_day = dt.datetime.today() - dt.timedelta(days=7) print(last_week_day) >> 2019-07-19 18:49:43.580625

That was easy right? Now let’s use an even easier tool to get single datetime parameters:

Getting the current date

Get the current day of the month:

my_dt = dt.datetime.today() my_dt.day >> 31

Get the current day of the week (in this case, it is Friday):

my_dt.isoweekday() >> 5

Get the current month of the year (in this case, it is February):

my_dt.month >> 2

Get the year:

my_dt.year >> 2019

Finally, an issue that we don’t usually take in consideration: What happens when we set a datetime object as a value on a payload and then we send this as the data of a request?

current_datetime = dt.datetime.today() requests.get(url="http://test_endpoint.com", json={ "date": current_datetime}) >> TypeError: Object of type datetime is not JSON serializable

Most of the Python requests libraries won’t accept a datetime, date, or time type object. First, we need to convert it to a string or integer. Since the standard is the ISO 8601 format, we will simply do the following:

requests.get(url="http://test_endpoint.com", json={"date": current_datetime.isoformat()})

Next steps

Once you have the foundational knowledge of datetimes in Python, it will get a lot more easy to work with. After you learn the basics, you’ll be ready to jump into Cloud Academy’s Pythonic Programming Learning Path. This learning path will help you master the advanced features of the Python language to ensure your code clean, concise, readable, and maintainable — or “pythonic”.

Originally published at https://cloudacademy.com on August 8, 2019.

Web Scraping for Data Scientists (With No Web Programming Background)

Valery C. Briz — Tue, 06 Aug 2019 16:22:36 +0000

Image by Alfons Schüler from Pixabay

originally posted at: https://icodemag.com/web-scraping-for-data-scientists-with-no-web-programming-background/

Nowadays data has a very important role in the industry and the need to obtain this data is becoming increasingly high. A big part of this information can be obtained through the internet. Some data is expressed, for example, as comments or hashtags on social networks other can be found as plain texts on web pages and other can be tables at “old” websites with no more format than simple HTML.

But regardless of the format, what we really care is the information we can obtain from this source, information that we can analyze to learn about our customer for example or increase the amount of data in our database for a further use. Sometimes the sites provide us with the information through APIs or by making available documents that we can easily download, but sometimes there is no other way to obtain it than by inspecting and copying this information directly from the website.

So far everything is happiness, but what happens when the information we need to obtain is distributed in hundreds or thousands of different pages or routes and is also all messy.

That’s the time when automation of the inspection and extraction of the data comes to the scene!

Web Scraping

Basically scraping is a technique to capture data from a web site and store it into a machine.

We could get the whole code of a web page with a GET request and then manually inspect, order and store it on a database, but Python provides us with some useful solutions to make it easier. One of this options is the Web Crawling Framework Scrapy. One of it’s main advantages is that it was built on top of Twisted which makes it asynchronous and faster. In the other hand we have Beautiful Soup its name comes from the expression “tag soup” which describes a messy and unstructured HTML. We would be using this library since it is vert handy and also helps a lot when the site we are trying to scrape is a real mess (which is a lot of the cases).

Beautiful Soup can get the whole HTML code of the page and store it as an object easier to filter by tags, id’s and DOM’s.

But first you might not know what a DOM is, so let’s start with a basic HTML class.

The DOM is a W3C (World Wide Web Consortium) standard. It’s basically a document object model that can define the properties, methods and events of an HTML element. So a DOM looks like this:

As said before, on a DOM we can have properties like an id , a class or a href and a really basic HTML page would look like this:

<!DOCTYPE html>
<html>
  <body>
    <h2>Finding HTML Elements by Tag Name</h2>
    <div id=”main”>
      <p>The DOM is very useful.</p>
      <p>This example demonstrates the <b>getElementsByTagName</b> method.</p>
    </div>
    <p class=”demo”>demo</p>
  </body>
</html>

The DOM is very useful. So for this HTML page the tags or properties would be:

id = “main”
class = “demo”

And our DOM’s would be:

html
body
h2
div
p
b

The combination of these DOM’s and its assigned properties would be the ones that will make our search easier.

If you want to learn a bit more about HTML you can find a lot of information on the W3Schools website.

Now we are ready to code!

First we need to install the Beautiful Soup library and a HTTP requests library in this case wi’ll use urlib3 :

pip install bs4

pip install urllib3

For example purposes we’re going to use the following site for the scrape:

**page\_url = “http://example.webscraping.com/”**

Before start doing requests to a web page we are going to manually navigate to the root of the site and look for robots.txt (https://example.webscraping.com/robots.txt).

The robots.txt is a file that every site should have to let bots know which pages are allowed to inspect and which are not. Also it can specify how many requests per second a crawler can do on the site. It is ethical to follow this instructions and not to hit unnecessarily the server while scraping it.

The first thing we need is to get the whole page source code. It’s recommendable to get it all on a single request, close the connection and then iterate multiple times if needed to find the information we are looking for. It is not only faster but also better for the server we are scraping.

from bs4 import BeautifulSoup
import urlib3
http = urllib3.PoolManager() #instanciate the http requests library
response = http.request(‘GET’, page\_url) #make the request to the page
soup = BeautifulSoup(response.data, ‘html.parser’) #store the code as a soup object

This Soup object has all of the page HTML code, so let’s try doing some search. To know what to look for we can do a dynamic inspection on the page making a right click and then select “ Inspect the Element “. Almost all the web browsers has this option. There we can see that the whole block of HTML code containing the first countries has a tag class called span12 , now applying that to our code we have:

dom_name = “div”

tag_name = “class”

tag_value = “span12”

span12_object_array = soup.find_all(dom_name, attrs={tag_name: tag_value})

This code will return an array containing all the divs found with a span12 class and all the children DOMs inside it, which visually would be the flags and the names of the countries.

If we want to get the link of the images of the flags we can apply the following search to our already filtered “ div span12 ” array:

img_dom_name = “img”

img_attr_name = “src”

for div_item in span12_object_array:

img_object_array = div_item.find_all(img_dom_name)

img_src_array = [current_item.get(img_attr_name) for current_item in img_object_array] #This is a list comprehension to simply get each found image source url in order

Now we can print this to see what is every image link:

print(img_src_array)

Finally you can store the information to a data base or directly download the images.

Insights

A well done scraping won’t cause a problem for the server that stores the information we need, this is important principally for ethical reasons. In the same line we can optimize our code to perform faster operations locally and ask for different information in the future with small changes.

Also an efficient and reusable code will be easier to maintain and would minimize our code time in the future.

This is a basic approach to the scraping methods, after understanding this it would be easier to scrape any site even if we find some messy and not ordered HTML code containing the information.

originally posted at: https://icodemag.com/web-scraping-for-data-scientists-with-no-web-programming-background/

Qué es Blockchain

Valery C. Briz — Tue, 05 Mar 2019 19:23:46 +0000

Breve introducción a blockchain

Hace un mes comencé a trabajar en Prescrypto. Dentro de las muchas habilidades y conocimiento que he adquirido, hay uno particularmente que ha llamado mi atención todo este tiempo: la aplicación de Blockchain en la generación de recetas electrónicas. Esta historia empieza varios años antes.

En mis primeros años de universidad…

Escuché por primera vez el término Blockchain. Desde entonces casi siempre lo escuché cuando hablaban de Bitcoin. Investigando descubrí que era una moneda electrónica pero su procedencia y usabilidad me eran desconocidos, muchos pensaban que se usaba solamente en la deep web. Con el tiempo aparecieron empresas e instituciones que la adoptaron, lo que puso al alcance del público más información sobre cómo funcionaba ésta nueva tecnología que rompía con los esquemas de transacciones de dinero o datos.

Para tener más claridad sobre Blockchain, comencé leyendo sobre conceptos relacionados con la forma cómo se realizaba la minería de Bitcoins. Ingenuamente creí que ése era el camino, el resultado fue entender que la minería es únicamente una parte del todo. Apenas había logrado comprender una pieza del rompecabezas de muchas más piezas de las que imaginé al inicio. Después de muchas lecturas, conversaciones y meditaciones, logré juntar las partes y entender mejor a qué refería el concepto de la tecnología Blockchain.

Varios años después…

Llegué a Prescrypto con un concepto más claro sobre este tipo de tecnología y su funcionamiento. Y el conocimiento que me compartió el equipo y las experiencias que viví durante el primer mes de trabajo me ayudaron, ¡finalmente!, a comprender cómo funciona Blockchain como un todo. Así como que el uso de esta tecnología, fuera de los sistemas de transacciones monetarias -como originalmente inició-, es muy amplio pues al integrarla en otros procesos puede resolver muchas situaciones complejas relacionadas con la transmisión de información.

Reto: ¿de qué se trata mi trabajo?

Pregunta recurrente cuando platico con mi familia y amigos. Explicarles de qué se trata mi trabajo es un reto que siempre empieza con cinco palabras: ¿has escuchado hablar sobre Bitcoin?

Sí es la respuesta usual. Me sorprende que conozcan el término sin importar la edad o el área en la que se desenvuelven. Sin embargo, la noción que la mayoría tiene suele ser vaga. Ante eso, decidí idear una forma de explicar de manera concreta y general qué es Blockchain.

Después de varias pruebas con diferentes conejillos de indias, el resultado fue que ya no me ven con cara de susto al finalizar mi explicación. Tampoco me enredo tanto ni doy detalles que puedan confundirlos. Les hablaré de esta tecnología porque la utilizo todo el tiempo en mi trabajo.

¿Qué es Blockchain?

Blockchain se traduce al español como “cadena de bloques”, y cada uno de ellos contiene información. Esta tecnología es utilizada en la transmisión y almacenamiento de datos que se encriptan para garantizar su seguridad. Esto quiere decir que ellos cambian a una forma de texto incomprensible a simple vista protegiéndose de miradas ajenas.

Ya que un paquete de información o datos es encriptado, éste se convierte en un bloque que es unido, en cadena, a otro. La unión hace que entre ellos compartan información, como la posición en la que están respecto a los otros bloques. Imaginemos que la información encriptada es literalmente una pieza con forma única como la siguiente:

Si a la nueva pieza le agregamos la información sobre la pieza anterior, la nueva se modificará un poco para poder encajar perfectamente con la anterior:

Pieza a pieza, o bloque a bloque, se va armando una cadena de información encriptada. Un bloque nuevo siempre será añadido al final de la cadena, no en otro lugar de ésta. Cuando un nuevo bloque es ingresado a una cadena se genera una llave única que servirá para desencriptar solamente la información de ese bloque, este proceso es conocido como minar y lo realiza un tercero que no tiene conocimiento de la información contenida en el bloque. La llave generada sólo es conocida por el usuario que añade el bloque a la cadena. La cadena puede recorrerse pieza por pieza hasta llegar a la que necesitamos. Tanto la cadena como cada pieza son inmutables, lo que quiere decir que no pueden ser cambiadas o borradas una vez que se forman.

¿Es posible cambiar alguno de los bloques?

Para agregar un bloque a la cadena éste debe contener información del bloque al que se une, esto provoca que el nuevo bloque cambie su forma original y tenga una nueva que encaje perfectamente con el último bloque de la cadena. ¿Lo recuerdan, cierto? Si un bloque es alterado, la información encriptada cambia, lo que provoca que ya no encaje con el bloque anterior.

Y así sucesivamente cada pieza quedará alterada causando que toda la cadena tenga un error que podrá ser detectado inmediatamente como una alteración fuera de lo normal en la cadena. A continuación podemos la cadena original arriba y abajo la cadena alterada en la pieza azul:

¿Qué es un sistema distribuido?

Esta forma de unir y formar cadenas de información encriptada garantizan la seguridad en la transmisión de datos. Otra muy importante es que Blockchain es un sistema distribuido. Esto quiere decir que la copia exacta de una cadena está guardada simultáneamente en más de un sitio sin que exista un master, o fuente original, en específico. Cada uno de estos sitios puede comprobar la fiabilidad de la cadena y de cada pieza nueva que ingresa a la misma.

Si hubiese una alteración en algún bloque, como en el ejemplo del bloque azul, y ésta haría cambiar la cadena completa para que todos los bloques volviesen a encajar correctamente. Esto sería complicado porque tendría que ocurrir simultáneamente en cada uno de los sitios donde la cadena está guardada.

Por si fuera poco, si un usuario quiere obtener la información de una de estas piezas debe de desencriptarla con la llave (única) que se generó al unir el bloque a la cadena. No está de más decir que esta llave únicamente servirá para esa pieza ya que cada una tiene su propia llave.

Blockchain es…

Como pueden ver, Blockchain es un sistema muy seguro de guardar información sensible pero debido a su forma de ordenar la información y hacerla fácilmente rastreable (media vez se cuente con los accesos necesarios) también puede ser útil en casos en los que se debe guardar información interconectada de forma compleja, aunque esta información no sea necesariamente sensible.

Espero que esta explicación general pero concreta ayude a comprender de qué se trata Blockchain o, si ya era claro el concepto pero no cómo explicarlo, ahora sea más fácil hacerlo.

Originalmente publicado en http://blog.prescrypto.com/2018/08/04/mi-primer-mes-en-prescrypto/

Reactive Programming in Python-Auth0

Valery C. Briz — Fri, 26 Jan 2018 22:02:20 +0000

Why Reactive Programming?

In a way, reactive programming isn’t a new thing. Our typical click events are an asynchronous data stream which we can observe and trigger actions from it. That’s how it works, but Reactive Programming makes things so much easier by adding a toolbox of operators to filter, create, transform, and unify any of those streams. In just a few lines of maintainable code, we can have web sockets that receive multiple requests and handle them on an asynchronous process that serves a filtered output.

Web applications contain lots of database operations, network calls, nested callbacks, and other computationally expensive tasks that might take a long time to complete (or even block other threads until it’s done). This is where Reactive Programming enters, it gives us the facility to convert almost anything to streams (like variables, properties, user inputs, caches, etc) to manage it asynchronously. Besides that, it also gives us an easy way to handle errors. A task that is usually hard task within asynchronous programming. Reactive Programming makes our code more flexible, readable, maintainable, and easy to write.

What Does Reactive Programming Really Means?

The main difference between Event-Driven programming and Reactive Programming is the real trigger of the action. While the Event-Driven programming focuses on handling any event (such as a button click) to trigger the corresponding action, Reactive Programming wraps data into the reactive system as events. This enables us to do things like listening to user inputs as events that trigger actions only if the input changed from the previous one.

“Reactive, in Reactive Programming, means a dynamic reaction to change in streams.”

Reactive Programming is a programming paradigm oriented around data flows and the propagation of change. This means that, when a data flow is emitted by one component, the Reactive Programming library will automatically propagate those changes to other components until it reaches the final receiver.

How Does Reactive Programming Works?

Let’s take into consideration ReactiveX, the most famous implementation of the Reactive Programming paradigm. ReactiveX is mainly based on two classes: the Observable and Observer classes. The Observable class is the source of data streams or events and the Observer class is the one that consumes (or reacts to) the emitted elements.

Observables in Reactive Programming

An Observable packs the incoming data so it can be passed from one thread to another. The Observable can be configured so it regulates when to supply data. For example, it could be triggered periodically or only once in their life cycle. There are also various functions that can be used to filter or transform the observable so the observer only emits certain data. All this is used instead of callbacks, which means that our code becomes more readable and less fallible.

from rx import Observable, Observer 

source = Observable.from_list([1,2,3,4,5,6])

It’s common to use Observables in a way that it doesn’t give data until some Observer subscribes to it. Known as "call by need", this is an evaluation strategy which delays the evaluation of an event until its value is needed.

Observers in Reactive Programming

The Observer consumes the data stream emitted by the Observable. An Observable can have multiple Observers so each data item emitted will be received by each Observer. The "listening" to the stream is called subscribing. Observers subscribe to the Observable with the subscribe() method to receive the emitted data.

The Observer can receive three types of events:

on_next(): when there is an element in the data stream;
on_completed(): when no more items are coming, it implies end of emission.
on_error(): when there is an error thrown from the Observable (it also implies end of emission);

class PrintObserver(Observer): 
    def on_next(self, value): 
        print("Received {0}".format(value)) 
    def on_completed(self):     
        print("Done!") 
    def on_error(self, error): 
        print("Error Occurred: {0}".format(error)) 

source.subscribe(PrintObserver())

We don’t have to specify all three event types in the code. We can choose which events to observe using the named arguments, or simply providing a lambda for the on_next function. Typically, in production, we will want to provide an on_error handler so errors are explicitly handled by the subscriber.

source = Observable.from_list([1,2,3,4,5,6]) 
source.subscribe(lambda value: print("Received {0}".format(value)))

Subjects in Reactive Programming

The Subject is the Observable extension that simultaneously implements the Observer interface. That is, Subjects acts like both Observers and Observables. They receive messages about events (like Observers) and notify their subscribers (like Observables). This implies two things:

We can subscribe to a Subject, just like an Observable.
A Subject can subscribe to other Observables.

Therefore, the main difference between a Subject and an Observable is that all of the Subject subscribers share the same action. This means that, when a Subject produces data, all of its subscribers will receive the same data. This is unlike Observables, where each subscription causes an independent execution of the observable.

A Subscriber can not only subscribe to an Observable but also unsubscribe from it. It is important to remember to unsubscribe from the asynchronous calls. When calling unsubscribe(), all the operators unsubscribe from one another in sequence from top to bottom. So we can avoid memory leaks. In the case of the Subjects, we will use the dispose method which can be thought of as the subscription itself, or perhaps a token representing the subscription. Disposing it will dispose the subscription and also unsubscribe. The unsubscribe call can be placed in the socket on_close() method:

def on_close(self): 
    self.combine_latest_sbs.dispose() 
    print("WebSocket closed")

Continue reading this Article at Auth0.com

Originally published at auth0.com.

Desarrollando un Chatbot Básico en 10 minutos

Valery C. Briz — Tue, 26 Sep 2017 07:53:45 +0000

Te interesan los ChatBots? No sabes por donde empezar?

A veces la mejor forma de empezar es intentandolo, algo simple y funcional que en el mismo desarrollo te vaya enseñando y a la vez dando ideas sobre lo que podrías conseguir despues.

Asi que aquí vamos!

Para este tutorial vamos a utilizar Telegram como plataforma para nuestro chatbot y Python como lenguaje de desarrollo para poder lograr nuestro objetivo rapido y sin tanto esfuerzo.

Ok primero necesitamos un Token para utilizar nuestro bot, para eso nos vamos a Telegram y buscamo al “BotFather”, le enviamos el comando /newbot

Entonces preguntará cuál es el nombre del Bot y cual es el ID (hay que tomar en cuenta que el ID/Username del bot no se puede repetir, por lo que hay que escoger un ID único, usualmente al final lleva la palabra Bot), en la última pregunta nos respondera con el Token y un Url para ir a la conversacion con nuestro bot.

El Token se mira algo asi como esto: 123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11 , de ahora en adelante simplemente usaremos para referirnos a ello.

Ahora copia el Token y pegalo en algún lugar seguro, proximamente vamos a utilizarlo.

Si aún no tienes Python instalado puedes ir a https://www.python.org/ para descargarlo e instalarlo.

En el medio hay una gran cantidad de APIs utiles para Python y Telegram-Bots, si quieres saber un poco mas sobre ello puedes ir a:

https://github.com/python-telegram-bot/python-telegram-bot

En esta ocasión vamos a utilizar este API que es bastante completo y facil de usar:

https://github.com/datamachine/twx.botapi

Primero lo instalamos por medio de pip.

pip install twx.botapi

Ahora, Necesitamos un API que nos diga el clima en la ubicación que solicitaremos, para ello utilizaremos Open Weather Map:

https://github.com/csparpa/pyowm

pip install pyowm

Y para utilizarlo es necesario un API KEY que puedes obtener aquí:

http://openweathermap.org/appid

De ahora en adelante nos referiremos al api key como

Este API nos proporciona datos como nubosidad, viento, temperatura y algunos otros detalles acerca del clima en la ubicación que le enviemos.

Perfecto! estamos listos para desarrollarlo!

# -\*- coding: utf-8 -\*-
#python2.7
import sys
from time import sleep
from twx.botapi import TelegramBot, ReplyKeyboardMarkup #Telegram Bot API
import traceback
from pyowm import OWM #API del Clima

"""
Inicializamos nuestro Bot y el API del Clima
"""
TOKEN = <token>
OWMKEY = <OWMKEY>

bot = TelegramBot(TOKEN) 
bot.update_bot_info().wait() #Esperamos por un mensaje entrante
print bot.username 
last_update_id = 0 
def process_message(bot, u): #Este es el procedimiento que se ejecuta al llegar un mensaje 
    #Vamos a utilizar un Teclado customizado 
    keyboard = [['Get Weather']] #Al teclado le agregaremos un Boton de Obtener el clima 
    reply_markup = ReplyKeyboardMarkup.create(keyboard) #Aqui creamos el teclado 
    if u.message.sender and u.message.text and u.message.chat: #Si el mensaje tiene un chatID y un contenido de texto entonces lo identificamos como texto
        chat_id = u.message.chat.id 
        user = u.message.sender.username
        message = u.message.text 
        print chat_id 
        print message 
        if message == 'Get Weather': #Si el usuario esta enviando el comando correcto para obtener el clima entonces preguntamos su ubicación 
            bot.send_message(chat_id, 'please send me your location') 
        else: 
            bot.send_message(chat_id, 'please select an option', reply_markup=reply_markup).wait() #Si no contiene el comando entonces mostramos las opciones de nuevo

    elif u.message.location: #Si el mensaje contiene una ubicación entonces generamos el clima en ese sitio 
        print u.message.location 
        chat_id = u.message.chat.id 
        owm = OWM(OWMKEY) #inicializamos el API del clima
        obs = owm.weather_at_coords(u.message.location.latitude, u.message.location.longitude) #creamos un observation 
        w = obs.get_weather() #creamos un objeto Weather como w 
        print(w) # <Weather - reference time=2013-12-18 09:20, status=Clouds> 
        l = obs.get_location() # creamos una ubicacion respecto al objeto weather 
        status = str(w.get_detailed_status()) 
        placename = str(l.get_name()) 
        wtime = str(w.get_reference_time(timeformat='iso')) 
        temperature = str(w.get_temperature('celsius').get('temp'))
        bot.send_message(chat_id, 'Weather Status: ' +status +' At '+placename+' ' +wtime+' Temperature: '+ temperature+ 'C') #Enviamos la respuesta con el clima
        bot.send_message(chat_id, 'please select an option', reply_markup=reply_markup).wait() #enviamos de nuevo el teclado para que lo muestre en pantalla
    else: 
        print u bot.send_message(chat_id, 'please select an option', reply_markup=reply_markup).wait() 

while True: #Este loop sirve para esperar por los mensajes entrantes
    updates = bot.get_updates(offset = last_update_id).wait() #esperamos y obtenemos el mensaje
    try: 
        for update in updates: #obtenemos los datos del mensaje
            if int(update.update_id) > int(last_update_id): #si el mensaje que estamos recibiendo es nuevo entonces, procesarlo
                last_update_id = update.update_id 
                process_message(bot, update) #lo enviamos a la función que lo procesa 
                continue 
        continue 
    except Exception: 
        ex = None 
        print traceback.format_exc() 
        continue

Ahora podemos guardarlo y ejecutarlo

Si todo fue correctamente entonces obtendras algo como esto:

Genial! ahora es momento de que leas un poco mas y agregues algunas imagenes e interacción al bot, pero por ahora tenemos nuestro nuevo y reluciente BOT funcionando y siendo util!

Si quieres saber un poco más sobre este API para bots de telegram puedes ir a la página de la documentación en:

https://pythonhosted.org/twx/twx/botapi/botapi.html

También aqui puedes encontrar algunos ejemplos del API del clima:

https://github.com/csparpa/pyowm/blob/master/pyowm/docs/usage-examples.md

Espero te sea util!