DEV Community: Flávia Bastos

Django Rest Framework: adding DateTimeField format serializer validation

Flávia Bastos — Wed, 15 Feb 2023 09:00:00 +0000

Here’s an example of adding date and time validation to a DateTimeField in a serializer in the Django Rest Framework (DRF).

A first pass, using only the default formats of DateTimeField(), would look like the following:

class CustomSearchFieldsSerializer(serializers.Serializer):
   start_time = serializers.DateTimeField()
   end_time = serializers.DateTimeField()

   def validate(self, data):
       # extra validation to ensure that the end date is always after the start date if data['start_time'] > data['end_time']:
           raise serializers.ValidationError("finish must occur after start")
       return data

Sending a request to that endpoint with the following query parameters (note it only has a date, not time):

/api/v1/custom-search/?start_time=2022-11-01&end_time=2022-11-07

Returns the following 400 Bad Request:

{
   "start_time": [
       "Datetime has wrong format. Use one of these formats instead: YYYY-MM-DDThh:mm[:ss[.uuuuuu]][+HH:MM|-HH:MM|Z]."
   ],
   "end_time": [
       "Datetime has wrong format. Use one of these formats instead: YYYY-MM-DDThh:mm[:ss[.uuuuuu]][+HH:MM|-HH:MM|Z]."
   ]
}

Not exactly what we want… I want this to be flexible and accept date only as a valid option.

Doing some research on the Django Rest Framework (DRF) documentation, I learned that I could customize the accepted formats. The next iteration looks like this:

class CustomSearchFieldsSerializer(serializers.Serializer):
   start_time = serializers.DateTimeField(required=False,
                                          input_formats=["%Y-%m-%dT%H:%M:%SZ", "%Y-%m-%dT%H:%M:%S", "%Y-%m-%d"])
   end_time = serializers.DateTimeField(required=False,
                                        input_formats=["%Y-%m-%dT%H:%M:%SZ", "%Y-%m-%dT%H:%M:%S", "%Y-%m-%d"])

The valid input formats can be passed as strings in a list. We add a few options, including a date-only format (the last option in the list).

Note: setting the flag “required” to False: this will make this field optional (in this case, the request could have no start and/or end time, which will then require the setting of some default values in the business logic to limit the query).

For the purposes of the task I was working on, I settled on the following formats:

input_formats=["%Y-%m-%d", "iso-8601"]

The first one accepts date only and the second follows the iso-8601 format, which is also the default format when nothing is set – the exact behaviour that we saw in the very first iteration. iso-8601 is an international standard for the representation of date and time formats.

If you found this helpful, please share this article.

The post Django Rest Framework: adding DateTimeField format serializer validation was originally published at flaviabastos.ca

Book review: The Programmer’s Brain

Flávia Bastos — Wed, 23 Nov 2022 08:44:00 +0000

As a software developer, I usually self-refer as a “Professional learner” and this book’s subtitle (“What every programmer needs to know about cognition“) caught my eye right away.

The author, Felienne Hermans, does a fantastic job explaining how our brain processes new information and shares, what I found the most valuable and immediately applicable, scientifically based tips and techniques to leverage our brain’s power to become a better programmer.

I think of this book as the result of the application of Barbara Oakley’s excellent work on Learning How to Learn to a Software Developer’s context – if you are not familiar with Barbara Oakley’s work, see the end of the post for more info.

TL;DR:

Yes, this is an excellent book. Check it out!

(no, I make no commission on this; I just loved the book)

Book Overview

The book is divided into 4 parts.

Part 1 is about getting better at reading code. The author explains how our brains process information (and code, more specifically), and goes into practical tips on how to read code better (yes, reading code is a separate skill and you can develop it!).

Part 2 deals with the thinking processes and how they affect our ability to solve problems.

You know when you open some code for review and you have a hard time understanding what a chunk of code does? Part 3 is all about the cognitive load we get into when reading code and what we can do to write better code so that other people can understand our code more easily. So, unless you want to keep writing bad code for job security or #reasons, do not skip this section.

In the last part of the book, the author talks about writing code in a team/group environment. Chapter 13, “How to Onboard New Developers” in my opinion should be a must-read for any lead and team manager (yeah, go ahead and read it now; you can read it standalone from the rest of the book and still take away a lot, I promise!).

My takeaways

I really liked this book (in case it’s not clear yet!) and I personally loved part 3 because I’ve been thinking a lot lately about readability, maintainability, clean code, and all that good stuff. Another important takeaway for me is to work and get really good at the basics as the building blocks to solve more complex problems.

For more info about Barbara Oakley’s work

Barbara Oakley is a professor of Engineering and is famous for her book “Learning How to Learn“, among others. The content of the book was made into a free online course “Learning How to Learn” on Coursera by UC San Diego. I highly recommended it! If you want a shorter version, she gave a talk for the series “Talks at Google” about this book.

If you found this helpful, please share this article!

The post Book review: The Programmer’s Brain _was originally published at _flaviabastos.ca

Como reverter um commit no git

Flávia Bastos — Tue, 08 Nov 2022 08:00:00 +0000

Existem algumas maneiras diferentes de desfazer as coisas no git, mas para o propósito deste post vamos considerar o seguinte cenário:

um repositório com cópias locais e remotas
vários colaboradores
um commit recente que já foi adicionado ao repositório remoto (“merged”, pra usar o termo “git” em inglês) mas que precisa ser revertido

git revert pra resolver esse problema!

RESUMÃO: passos pra reverter um commit em um repositório remoto:

atualize a cópia local do repostitório na seu branch principal: git pull
crie um novo branch: git checkout -b remove_codigo_bugado
encontre o hash do commit com bugs com git log
git revert [-m 1 –no-edit]

O comando acima criará um novo commit onde todas as alterações do commit original que foi adicionado ao repositório remoto serão revertidas. Isso é bom porque fazendo desse jeito você mantém o histórico do repositório inalterado.

As opções opcionais mostradas no comando acima significam:

-m n : se você está revertendo um “merge” commit (o commit final que foi adicionado ao repositório remoto), você precisa passar esta opção com um número ( tem uma entrada em inglês no StackOverflow explicando o porquê )

–no-edit : (note que são dois traços no início da opção!) isso vai evitar que o editor de texto padrão abra automaticamente

EXEMPLO passo-a-passo:

Meu branch principal e local chamado main tá assim:



└❯ git log
commit 9ebef49af9f50996f32c863604b1fc6fdce71e26 (HEAD -> main, origin/main, origin/HEAD)
Author: Flavia Bastos <meu_email>
Date: Tue Oct 4 19:22:55 2022 -0300

    Corrigir ortografia

Nesse meio tempo alguém adiciona um commit novo no repositório remoto. Quando eu puxo as alterações novas pro meu repositório local, eu vejo o commit novo ( 86d1c24f17aa7) e um merge commit novo ( 5aa51c6ea265cc) para essas alterações:



└❯ git log
commit 5aa51c6ea265cc43b93a66de97ca4d8fcafc69df (HEAD -> main, origin/main, origin/HEAD)
Merge: 9ebef49 86d1c24
Author: Outra pessoa <outro_email>
Date: Thu Oct 6 17:14:15 2022 -0400

    Merge pull request #1 from Outra pessoa/caso_123

    Codigo novo cheio de firula

commit 86d1c24f17aa7fd264a26d81533e53f6f48dea24 (origin/caso_123, caso_123)
Author: Outra pessoa <outro_email>
Date: Thu Oct 6 18:08:49 2022 -0300

    Codigo novo cheio de firula

commit 9ebef49af9f50996f32c863604b1fc6fdce71e26
Author: Flavia Bastos <meu_email>
Date: Tue Oct 4 19:22:55 2022 -0300

    Corrigir ortografia

Observe aqui que o merge commit ( 5aa51c6ea265cc) também descreve os commits antecedentes no atributo “Merge”:



Merge: 9ebef49 86d1c24

Daí acontece que esse código sofisticado também estava com bugs e fez com que algumas coisas quebrassem feio. Quem nunca, neah?

Vamos corrigir isso rapidamente criando um branch novo a partir da última atualização da branch principal (main):



└❯ git checkout -b corrige_bug
Switched to a new branch 'corrige_bug'

A partir da mensagem do comando git log acima, sabemos que queremos o hash do commit mais recente (o primeiro da lista nesse caso), mas pode haver outros commits novos depois dele. Sempre confirme rodando o git log de novo.

Agora vamos reverter o commit com bug ( 5aa51c6ea265cc) – observe que estamos em um branch separado e estou usando a opção -m 1, porque quero reverter para seu primeiro antecedente 9ebef49 (se eu usasse -m 2 ao invés, ele reverteria para o segundo antecedente 86d1c24):



└❯ git revert 5aa51c6ea265cc43b93a66de97ca4d8fcafc69df -m 1 --no-edit
[corrige_bug 560ad2d] Revert "Merge pull request #1 from Outra pessoa/caso_123"
 Date: Thu Oct 6 18:30:50 2022 -0300
 1 file changed, 1 insertion(+), 1 deletion(-)

O úlimo passo agora é mandar esse branch corrige_bugpro repositório remoto e dar merge na alteração:



└❯ git push origin corrige_bug
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 12 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 402 bytes | 402.00 KiB/s, done.
Total 3 (delta 2), reused 0 (delta 0), pack-reused 0
remote: Resolving deltas: 100% (2/2), completed with 2 local objects.
remote: 
remote: Create a pull request for 'corrige_bug' on GitHub by visiting:
remote: https://github.com/FlaviaBastos/meu_projeto/pull/new/corrige_bug
remote: 
To github.com:FlaviaBastos/meu_projeto.git
 * [new branch] corrige_bug -> corrige_bug

Depois que essa última alteração for adicionada ao repositório remoto, volte para o branch principal main no seu repositório local, puxe as últimas alterações e confirme com o git log que o commit com erros foi revertido:



❯ git log
commit 4332e3e999c2056019cf64255f17b32a6ef1992b (HEAD -> main, origin/main, origin/HEAD)
Merge: 5aa51c6 560ad2d
Author: Outra pessoa <outro_email>
Date: Thu Oct 6 17:53:28 2022 -0400

    Merge pull request #2 from FlaviaBastos/corrige_bug

    Revert "Merge pull request #1 from Outra pessoa/caso_123"

commit 560ad2ddfd207fad2f609873270bdd3f645bb4b6 (origin/corrige_bug, corrige_bug)
Author: Flavia Bastos <my_email>
Date: Thu Oct 6 18:30:50 2022 -0300

    Revert "Merge pull request #1 from Outra pessoa/caso_123"

    This reverts commit 5aa51c6ea265cc43b93a66de97ca4d8fcafc69df, reversing
    changes made to 9ebef49af9f50996f32c863604b1fc6fdce71e26.

commit 5aa51c6ea265cc43b93a66de97ca4d8fcafc69df (HEAD -> main, origin/main, origin/HEAD)
Merge: 9ebef49 86d1c24
Author: Outra pessoa <outro_email>
Date: Thu Oct 6 17:14:15 2022 -0400

    Merge pull request #1 from Outra pessoa/caso_123

    Codigo novo cheio de firula

Ufa! Tudo resolvido!

MAS peraí, o `RESET --HARD` faz a mesma coisa, não?

Sim. Porém, apenas localmente. O comando git reset vai mover o ponteiro do seu repositório para qualquer commit que você definir, efetivamente removendo qualquer coisa depois dele. Se você rodar um git status, você não verá mais esses outros commits, nem nada de novo que precise ser feito commit e você estará reescrevendo o histórico do repositório desse jeito. Isso só é seguro se você estiver trabalhando sozinho ou em um branch que ainda não foi mandado e anexado ao repositório remoto.

Se você precisar enviar as alterações de reversão de commit para um repositório remoto, você deve usar o git revert.

Pra saber mais:

Documentação do git revert: https://git-scm.com/docs/git-revert/pt_BR

Compartilhe esse artigo!

Como reverter um commit no git

Tweet

O artigo Como reverter um commit no git_ foi publicado originalmente no _flaviabastos.ca

TIL: installed packages in Python – list, and show

Flávia Bastos — Tue, 25 Oct 2022 08:00:00 +0000

If your Python project has a very short list of required packages (in requirements, pipfile, etc), it’s easy to see all packages you have. But on large projects, the dependencies can run pretty long, not to mention the dependencies for the required packages. And what about learning more about those dependencies?

pip list

Will list all installed packages

pip show <package_name>

Will show information about installed packages and if you’re lucky, what other package requires that dependency

And, of course, pip -h will show all other pip options.

Example:

requirements.txt

Django>=3.1.0,<3.2.0
djangorestframework>=3.12.2,<3.13.0
psycopg2>=2.8.6,<2.9.0
Pillow>=8.1.0,<8.2.0

flake8>=3.8.4,<3.9.0

List my packages:

# pip list
Package Version
------------------- -------
asgiref 3.3.1
Django 3.1.7
djangorestframework 3.12.2
flake8 3.8.4
mccabe 0.6.1
Pillow 8.1.0
pip 21.0.1
psycopg2 2.8.6
pycodestyle 2.6.0
pyflakes 2.2.0
pytz 2021.1
setuptools 53.0.0
sqlparse 0.4.1
wheel 0.36.2

Show more about one package:

# pip show pyflakes
Name: pyflakes
Version: 2.2.0
Summary: passive checker of Python programs
Home-page: https://github.com/PyCQA/pyflakes
Author: A lot of people
Author-email: code-quality@python.org
License: MIT
Location: /usr/local/lib/python3.9/site-packages
Requires: 
Required-by: flake8

If you found this helpful, please share this article!

List installed packages in Python

Tweet

The post TIL: installed packages in Python – list, and show _was originally published at _flaviabastos.ca

How to revert a commit in git

Flávia Bastos — Tue, 11 Oct 2022 08:00:00 +0000

There are a few different ways to undo things in git but for the purpose of this post we will stick with the following scenario:

a repository with local and remote copies
multi-person collaborators
a recent change merged to remote (and potentially deployed) that needs to be reverted

git revert to the rescue!

TL; DR: steps to revert a commit on a remote repo:

on your local and main branch, pull the latest changes: git pull
create a new branch: git checkout -b remove_buggy_code
find the hash of the buggy commit with git log
git revert [-m 1 –no-edit]

The command above will create a new merge commit where all the changes from the original merge commit are reverted. This is good because this keeps the repository’s history unchanged.

The optional tags shown above mean:

-m n : if you are reverting a merge commit you need to pass this flag with a number (this StackOverflow post explains why)

–no-edit : this will skip launching the default text editor

Let’s run through an example:

My local, main branch looks like this:

└❯ git log
commit 9ebef49af9f50996f32c863604b1fc6fdce71e26 (HEAD -> main, origin/main, origin/HEAD)
Author: Flavia Bastos <my_email>
Date: Tue Oct 4 19:22:55 2022 -0300

    Fix typo on test name

Then someone merges a new commit to remote. When I pull the new changes, I see the new commit (86d1c24f17aa7) and a new merge commit (5aa51c6ea265cc) for those changes:

└❯ git log
commit 5aa51c6ea265cc43b93a66de97ca4d8fcafc69df (HEAD -> main, origin/main, origin/HEAD)
Merge: 9ebef49 86d1c24
Author: Someone Else <another_email>
Date: Thu Oct 6 17:14:15 2022 -0400

    Merge pull request #1 from SomeoneElse/fancy_feature

    fancy code

commit 86d1c24f17aa7fd264a26d81533e53f6f48dea24 (origin/fancy_feature, fancy_feature)
Author: Someone Else <another_email>
Date: Thu Oct 6 18:08:49 2022 -0300

    fancy code

commit 9ebef49af9f50996f32c863604b1fc6fdce71e26
Author: Flavia Bastos <my_email>
Date: Tue Oct 4 19:22:55 2022 -0300

    Fix typo on test name

Note here that the merge commit (5aa51c6ea265cc) also outlines the parent commits in the “Merge” attribute:

Merge: 9ebef49 86d1c24

Now, it turns out that this fancy code was also buggy and it caused some things to break really bad

Let’s fix this quickly by creating a new branch from this latest main:

└❯ git checkout -b bug_fixer
Switched to a new branch 'bug_fixer'

From the output of the git log command above, we know that we want the most recent (top) commit hash, but there could be other commits on top of it. Always confirm with git log.

Now let’s revert the buggy commit (5aa51c6ea265cc) – note we are on a separate branch and I’m using the-m 1flag, because I want to revert to its first parent 9ebef49 (-m 2 would revert to the second parent 86d1c24):

└❯ git revert 5aa51c6ea265cc43b93a66de97ca4d8fcafc69df -m 1 --no-edit
[bug_fixer 560ad2d] Revert "Merge pull request #1 from SomeoneElse/fancy_feature"
 Date: Thu Oct 6 18:30:50 2022 -0300
 1 file changed, 1 insertion(+), 1 deletion(-)

All that’s left now it to push this bug_fixer branch up to remote and merge this change:

└❯ git push origin bug_fixer
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 12 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 402 bytes | 402.00 KiB/s, done.
Total 3 (delta 2), reused 0 (delta 0), pack-reused 0
remote: Resolving deltas: 100% (2/2), completed with 2 local objects.
remote: 
remote: Create a pull request for 'bug_fixer' on GitHub by visiting:
remote: https://github.com/FlaviaBastos/my_project_name/pull/new/bug_fixer
remote: 
To github.com:FlaviaBastos/my_project_name.git
 * [new branch] bug_fixer -> bug_fixer

After this last change is merged in the remote repo, go back to the main branch, pull the latest changes and confirm with git log that the buggy commit was reverted:

❯ git log
commit 4332e3e999c2056019cf64255f17b32a6ef1992b (HEAD -> main, origin/main, origin/HEAD)
Merge: 5aa51c6 560ad2d
Author: Someone Else <another_email>
Date: Thu Oct 6 17:53:28 2022 -0400

    Merge pull request #2 from FlaviaBastos/bug_fixer

    Revert "Merge pull request #1 from SomeoneElse/fancy_feature"

commit 560ad2ddfd207fad2f609873270bdd3f645bb4b6 (origin/bug_fixer, bug_fixer)
Author: Flavia Bastos <my_email>
Date: Thu Oct 6 18:30:50 2022 -0300

    Revert "Merge pull request #1 from SomeoneElse/fancy_feature"

    This reverts commit 5aa51c6ea265cc43b93a66de97ca4d8fcafc69df, reversing
    changes made to 9ebef49af9f50996f32c863604b1fc6fdce71e26.

commit 5aa51c6ea265cc43b93a66de97ca4d8fcafc69df
Merge: 9ebef49 86d1c24
Author: Someone Else <another_email>
Date: Thu Oct 6 17:14:15 2022 -0400

    Merge pull request #1 from SomeoneElse/fancy_feature

    fancy code

commit 86d1c24f17aa7fd264a26d81533e53f6f48dea24 (origin/fancy_feature, fancy_feature)
Author: Flavia Bastos <my_email>

Phew! Crisis averted!

But what about `reset --hard`? Doesn’t it revert commits too?

Yes, it does. Only locally though. git reset will move the head (the pointer) of your repo to whatever commit you set it to, effectively removing anything after it – chopping anything above the head, if you will. The diff is lost. If you then do a git status, you will not see those other commits anymore, nor anything new that needs to be staged and you are rewriting history. This is only safe to do if you are working solo or on a branch that has not been pushed to remote yet.

If you need to push the changes to a remote repo, you need to use git revert.

Learn more:

git revert documentation: https://git-scm.com/docs/git-revert

If you found this helpful, please share this article!

How to revert a commit in git

Tweet

The post How to revert a commit in git _was originally published at _flaviabastos.ca

Managing local git branches with git rebase

Flávia Bastos — Thu, 03 Mar 2022 09:00:00 +0000

When you work on a codebase with other people, you need to manage your local branches: you need to ensure that when you push some code and create a merge/pull request on the remote branch, your changes will be easily integrated with the main codebase. And by “easily” I mean preferably without merge conflicts or the dreaded message “your branch is xxx commits behind the target branch”. 👀

There are many ways to accomplish this but I personally like to use git rebase.

what is git rebase

Git rebase is the tool used to combine changes from one branch into another branch.

when to use git rebase

You want to use git rebase when have a local branch with changes (for a bug fix or new feature, for example) and the main branch (the one you created your branch from) received updates and you want those updates in your local branch too, along with your changes.

In other words, you want to use git rebase to make sure your work is up to date with all the changes from the main branch and ready to be reviewed and potentially merged.

when NOT to use git rebase

You should not use git rebase on a shared branch (say a main or dev branch). Only rebase your local, non-shared branches. Treat rebase as a clean up tool for when you are getting ready to open a merge/pull request.

The reason for this recommendation is because of how git rebase works – which I will not get into here but you can watch this short video.

how to use git rebase:

I often run into 2 different cases that will determine how I use git rebase:

1- my local branch was created from the main branch (a “child” branch)

2- my local branch was created a from a branch that was branched from main (a “grandchild” branch)

In both cases the “main” branch received updates and I need those updates in my local branch.

This is how it works:

git rebase – branch out of main

I created a local branch directly out of the main branch so I can add my super-cool feature. While I’m still working on it OR if I’m ready to send it to code review, I find out that there’s one important bug fix in the main branch and I need it on my local branch too.

This is the most simple case and all I need to do is to 1. get those latest changes from main and 2. add them to my branch:

$super-cool:
git fetch && git rebase origin/main

That’s it. You can continue working on your super-cool feature or just push your local to the remote (for code review, I hope! 😅)

git rebase – branch of branch of main

This is another case I run into often:

I create a local branch “super-cool” from the main branch and add my changes to it. I send this change for code review and I want to start working right-away on adding another feature that depends on the super-cool feature that have not been merged to the main branch yet.

If I create a branch from main, the required code won’t be there. There are other ways to solve this (like cherry-picking, for example) but what I usually do is to create a branch from the “super-cool” branch:

$super-cool:
git checkout -b "super-cool-premium"

Now I have all the super-cool changes and can add the premium changes I want.

Meanwhile my colleagues approved my pull/merge request from “super-cool” and those changes are now merged to the main branch.

Now my local “super-cool-premium” branch needs to reflect that change also: I want to make it look like as if I had branched directly from latest main (without getting into much detail here, this is good because it makes the history look cleaner).

In this case I use the –onto variant of the rebase command in my “super-cool-premium” branch:

$super-cool-premium:

git rebase --onto origin/main @~1

This is telling git to update my local “super-cool-premium” branch by bringing the latest changes from main and applying my changes on top of it. When my super-cool-premium gets merged to main later on, the main branch history will look like this:

Merge branch 'super-cool-premium' into 'main'

"add super-cool-premium feature"

Merge branch 'super-cool' into 'main'

"add super-cool feature"

Merge branch 'bug-fix-34' into 'main'

"main bug fix #34"

Merge branch 'bug-fix-34' into 'main'

"main bug fix #33"

when git rebase has conflicts

There are times when you try to rebase and you will get a warning that there are files with conflicts.

At this point you will notice that your branch is in “detached” mode: it’s waiting for instructions on what to do next and you must pick one of the two options: resolve the conflicts and continue the rebase with –continue or abort the operation with the –abort flag.

If you decide to keep going, it’s a matter of resolving the conflicts in your code editor, adding all changes (with git add; no need to create a new commit!) and telling git to continue with the rebase process:

git rebase --continue

managing your commits – the case for single commits

🚨🚨🚨 strong personal opinion disclaimer 🚨🚨🚨

One habit that I have that I find that helps a lot with minimizing confusion and conflicts when dealing with remote public branches is that I always only submit one single commit with my pull/merge request. Even if I need to address feedback from code review and update my code, I will still keep one single commit (I usually amend the commit, which is a *safe* thing to do only before the branch has been merged!!)

I can have multiple commits while I work on my local branch but before I push it to remote I will always squash the commits. No need to add “fix bug“, “fix bug again“, “fix for reals“, “are you kidding me” and so on the the main history, right? 👀 I will squash them all and give my commit a clear message like: “add super cool feature”.

That way, in the main branch history you will see only one commit per feature or bug fix added (plus the actual merge commit).🤩
This helps a lot when merging multiple branches, doing rebases, managing conflicts, reverting changes, etc. Plus the history will look soooooo tidy. I treat each bug fix/new feature as a one distinct package to be added to the codebase.

What’s wrong with using git merge?

Nothing! Git merge adds a merge commit so if you try to keep your local branch up to date with main by merging main into your branch, be aware that you will have those extra commits. And there is nothing wrong with that. Personally I don’t like it and prefer one single commit per feature or bug fix I submit and that’s why I use rebase a lot. And squash my commits (which I will write about some other time but – spoiler alert – it’s just git rebase in interactive mode 😲)

there’s more to git rebase

These are two examples of git rebase that I use on a regular basis but there’s a lot more to it. This tutorial goes into more depth on how git rebase works and brings up some considerations and warnings regarding this helpful command. One warning worth mentioning again is that you should never rebase a remote common branch (in our example, the main branch). Rebase should always be done in a local branch before it gets merged to the remote.

If you found this helpful, please share this article!

Managing local git branches with git rebase

Tweet

The post Managing local git branches with git rebase _was originally published at _flaviabastos.ca

The difference between HTTP status codes 401 and 403: Unauthorized and Forbidden

Flávia Bastos — Wed, 17 Nov 2021 09:00:00 +0000

You are working with an API and after sending a request you receive one of these two HTTP response codes: 401 or 403. What do HTTP status codes 401 and 403 mean?

Official specification

If you search for the official specification, this is what you get:

401: Unauthorized

The 401 (Unauthorized) status code indicates that the request has not been applied because it lacks valid authentication credentials for the target resource.

https://httpwg.org/specs/rfc7235.html#status.401

403: Forbidden

The 403 (Forbidden) status code indicates that the server understood the request but refuses to authorize it.

https://httpwg.org/specs/rfc7231.html#status.403

Hmmm…. These two sound pretty similar to me. And to make things even more confusing, 403 “Forbidden” says that the server refuses to “authorize” the request but it’s code 401 that is called “Unauthorized”.

Let’s simplify: airport analogy

You need a valid flight ticket to board a plane and the flight ticket has some information: your name and the gate number, for example, along with the destination, flight time, etc.

To simplify this analogy, the ticket has two parts: your identification (a username and a password to access the API) and your gate number (the resource you want to access).

If the ticket is incorrect or damaged, you cannot even go through the airport security: when they check your ticket, it will be refused. You are Forbidden to enter the boarding area of the airport.

Next, let’s say that your ticket is correct (so you made through security just fine!) and the gate number in your ticket says “Gate 24” but you walk to Gate 27. The attendant cannot authorize you to go through that gate because it’s not the right gate for your ticket.

In other words, an “incorrect ticket” is similar to messing up your credentials: wrong username and/or password and you receive back a 403 Forbidden. Using the correct credentials but trying to access a resource that is not allowed for those credentials returns you a 401 Unauthorized.

You can also think that 403 happens before 401, despite the natural number order: you will not receive a 401 until you resolve a 403.

A real example

The screenshot below shows that I try to login to my headspace account with a incorrect password (a “damaged” ticket in our analogy) and the response code in the network tab of the developer tools shows the 403.

403 HTTP status code when trying to login with incorrect username or password

Important! Don’t believe everything you read!

One important thing to note here: the official specification is not enforced in any way and like many other things in software development, you might find out that the response codes are not consistent with the specification. If you are using a web framework, this will be configured out of the box and the return codes will work as specified but developers can override the base implementation and assign whichever code they want as responses.

Of course this is a bad idea because it will lead to confusion and it’s prone to error.

It takes just one Google search to prove to you that people mix these 2 status codes up all.the.time and there’s a chance that the API you are using got things backwards!

Here’s a horror story for you: I once worked with an API that only used GET methods (for modifying resources as well, instead of POST!!) and all response codes, for anything, were 200. So! Watch out!

If you found this helpful, please share this article!

HTTP 401 and 403 explained

Tweet

The post The difference between HTTP status codes 401 and 403: Unauthorized and Forbidden _was originally published at _flaviabastos.ca

A caller id for your python function

Flávia Bastos — Wed, 30 Jun 2021 08:00:00 +0000

Most of you might be too young to know this but there was time that the phone in your house – not in your pocket! – would ring and gasp! you had no idea who were calling! You had to ANSWER the phone to find out. Now we have caller ID and know exactly who is calling – and can ~~completely ignore the call~~ decide if we are answering the call or not.

When working with large applications, for debugging purposes, I find very helpful to know which function is calling what function. Breakpoints and print statements are useful tools but sometimes you just need more information. In a large codebase it’s fairly easy to get lost with breakpoints so I’ve been using the chunk of code below to print extra info and learn a little bit more about my application.

import inspect
func = inspect.currentframe().f_back.f_code
print(f"in function 'my_function' called from NAME: {func.co_name} in FILENAME: {func.co_filename} on LINE#: {func.co_firstlineno}")

How to use

Consider a *very* simple program (which honestly doesn’t even need our helper function, but for the sake of example, stay with me here):


def helper_function(value):
    return value.isnumeric()

def adder(num1, num2):
    return int(num1) + int(num2)

def main():
    print("The most useless calculator!")
    first_number = input("Please enter a number: ")
    second_number = input("Please enter another number: ")
    print(f"Let's add {first_number} and {second_number}")

    if helper_function(first_number) and helper_function(second_number):
        total = adder(first_number, second_number)
        print(f"The total is {total}")
    else:
        print("Sorry, we cannot add these values...")

main()

The function above takes two pieces of input form the command line (lines 11 and 12), calls a helper function to check if the values entered are numbers (line 15) and if so, calls the function to add the numbers (line 16).

Now, just for a moment let’s pretend that each of these functions are way more complicated than this and live in separate files. Add some more functionality, a framework, 2 cups of all-purpose flour and a webserver. Voilà! You have a web application. What if you still want to know which function called what? Let’s add our chunk of code to adder:


def helper_function(value):
    return value.isnumeric()

def adder(num1, num2):
    import inspect
    func = inspect.currentframe().f_back.f_code
    print(
        f" **** in function 'adder' called from NAME: {func.co_name} in FILENAME: {func.co_filename} on LINE#: {func.co_firstlineno}"
    )

    return int(num1) + int(num2)

def main():
    print("The most useless calculator!")
    first_number = input("Please enter a number: ")
    second_number = input("Please enter another number: ")
    print(f"Let's add {first_number} and {second_number}")

    if helper_function(first_number) and helper_function(second_number):
        total = adder(first_number, second_number)
        print(f"The total is {total}")
    else:
        print("Sorry, we cannot add these values...")

main()

When you run this script now (let’s save it as “watcher.py”), it will output the information about the function that called adder, in this case, main:

>>> python3 watcher.py 
The most useless calculator!
Please enter a number: 4
Please enter another number: 2
Let's add 4 and 2
**** in function 'adder' called from NAME: main in FILENAME: watcher.py on LINE#: 15
The total is 6

Note that the line number is the line where the parent function, in this case “main”, starts, not where our function was called from!

This has been very helpful and I’ve used a lot lately. I hope it helps you too!

Fancypants

You will need to copy this chunk of code into every function you would like to debug but that’s a bit tedious. Instead, you can turn it into a decorator and decorate the functions you want to inspect. Start by creating your decorator:


def caller_id(my_func):
    def wrapper(*args, **kwargs):
        import inspect

        my_func(*args, **kwargs)

        func = inspect.currentframe().f_back.f_code
        print(
            f"in function {my_func. __name__ } called from NAME: {func.co_name} in FILENAME: {func.co_filename} on LINE#: {func.co_firstlineno}"
        )

    return wrapper

Then, you can decorate your function with it. Let’s add it to adder again. Now adder looks like:

@caller_id
def adder(num1, num2):
    return int(num1) + int(num2)

That’s it.

If you found this helpful, let me know on Twitter!

The post A caller id for your python function _was originally published at _flaviabastos.ca

git stash 101

Flávia Bastos — Wed, 26 May 2021 07:10:00 +0000

git is a very useful tool for software development and you only need to know a few commands to get most of the job done. However, you can be a lot more productive if you go beyond the basics.

One git command I started using not too long ago is git stash. In my opinion this is one command that might not be super useful if you are just starting to code or you are the only person working on a personal project. But if you start collaborating and need to switch between a new feature work to fixing a bug, for example, git stash is very helpful.

What does git stash do?

It allows you to save your work in progress out of your way, meaning, without the need to create a commit, and access that work later.

When to use git stash?

When you have some work in progress but you are not ready to create a commit yet (maybe you are just exploring some options or the work is not completed yet) and you need to switch branches OR you want to go back to start point but you want to keep the changes for later. You can then ask git to take the current changes and save they aside. In this way, when you run “git status”, you see that your repo is back to the same state it was when you first cloned it or created that branch: the recent changes are not visible anymore but they are saved in case you want to go back and work on them again. You can now checkout a different branch and start new work.

In other words…

This is almost like having a branch within a branch: imagine that you created a branch for some new work. You make a few changes but you think you can create a different solution for that issue. You can stash the current changes so your new branch gets “reset” to the same state as when it was created and you can try a different solution. If later on you decide that your first solution was the best one, you can stash this new code and retrieve the previous solution from the stash.

The key point for git stash is to save the changes for later. If you don’t care about the changes and just want to discard unstaged changes (changes you did not “git add” yet), you can just run git checkout . (note the . at the end!)

Each repository has its own unique stash and you can end up with entries from different branches in that repository’s stash. Each stash entry is assigned an index.

Basic stashing activities:

CREATE STASH

you can create a stash for uncommitted changes by running:

git stash push

OR simply

git stash

Add a message to your stash for easier identification afterwards:

git stash -m "recursive solution"

Stash only one file (instead of all the changes):

git stash push <path_to_file>

INSPECT STASH

you can check your stash by running:

git stash list

list all the files that changed when the stash entry was created:

git stash show stash@{1}

// you can omit the stash index if your stash has only one entry!

check the changes in a stash entry – for example, stash@{1}:

git stash show -p stash@{1}

MANAGE STASH

apply one item from your stash to your code and KEEP that entry in the stash:

git stash apply stash@{1}

apply one item from your stash to your code and REMOVE that entry from the stash:

git stash pop stash@{1}

remove one entry from the stash:

// this will delete this entry from the stash without applying it to your code!

git stash drop stash@{2}

clean up (delete) the whole stash:

git stash clear

There are many other options to use with git stash but these are the ones I use most often. You can check git stash documentation for more options: https://git-scm.com/docs/git-stash

If you found this helpful, let me know on Twitter!

The post git stash 101 _was originally published at _flaviabastos.ca

Developing inside a Docker container

Flávia Bastos — Wed, 14 Oct 2020 08:00:00 +0000

A few months ago I got a new computer and I have been very intentional about deciding what I install on it. From past experience I know that computers that are used as a development environment tend to get messy in no time since one might install all kinds of libraries, frameworks, dependencies, you name it, and to makes matters worse, you will probably run into version conflicts for any or most of those things. Hardly ever a development environment is a clean environment and I don’t know about you but there are very few things that I find more frustrating than wasting time troubleshooting development environment set up. Let me write the code already!

With that in mind, I decided early on that I would avoid installing node.js on this computer, for example. In my experience, Node is notorious for giving lots of headaches with version conflict. The Node Version Manager (nvm) can only do so much to alleviate the problem and I find it clunky. So, no, thanks.

Well, then smarty-pants. How do you do full stack web development these days without using nvm you ask me. Excellent question! The answer: Docker.

I’ve written about Docker in the past and I just plain love it. It took me some time to understand what it does and which problems it solves but once I did, it became my go-to solution to keep things under control: you can isolate a development environment with all dependencies and runtime that your project needs. If your friend wants to run your project, they get the container and voilà, the project runs on their computer without they needing to install all dependencies locally. Beautiful!

So, a few weeks ago I started a new course to learn Gatsby and this was the perfect scenario to test my Docker development environment.

Docker image for a dev environment

The first thing I did was to create a base image with node.js and a few utilities installed. Here’s the Dockerfile for the image I used:

Note about this setup: I use debian as a base image but if you care about image size, consider using alpine instead.

On the file above I have also highlighted in the comments how to 1. build the image and 2. two options to run the image. These are the two steps you need to take to start using this image as a container for your development environment.

Choosing how to run the image

If all you care is to have a “start point”, or clean slate if you will, run as the first option suggests. That will put you inside the container in a prompt on the root folder. You can then run other install commands .

If you are using this image as a development environment (like I am), you will want to run as the second option (the longer docker run command). This command does 2 extra things that will be super helpful: 1. expose container ports so you can access the project from your browser (more about this later) and 2. map the code you are writing on the code editor in your computer to a folder inside the container so the container can “see” the changes to your code. Yes, pretty much essential.

For this example, I have this repository that I cloned from GitHub and it’s a Gatsby application. So I will run the second docker run command making sure I am using the correct path to my cloned repo.

Inside the container

Once I have the command prompt inside the container, I can navigate to the place in the repository that holds the package.json file and then run npm install. This will install all the projects dependencies inside the container.

Next, I can start the development server by running gatsby develop.

I get the message that I can now view my project in the browser:

 Local: http://localhost:8000/

Not so fast, my friend!

However, when I go to localhost:8000 I get an ERR_CONNECTION_RESET. I tried 127.0.0.1 instead but I still got nothing. If I list my running containers (with docker ps), I see that it’s running on 0.0.0.0 and I thought that 0.0.0.0 was another way to say “127.0.0.1” or “localhost”… Why is it not working?

└❯ docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 8a12a061be10 gatsby "/bin/bash" 10 minutes ago Up 2 minutes 0.0.0.0:8000->8000/tcp my\_project

Well, it turns out that when running applications inside a container, localhost is the container itself and not your workstation anymore. So you need to tell the container which host it should serve the application from. However, containers have dynamic IP addresses so you don’t know beforehand which IP address the container will take.

What do I do now?

The fix for this problem is to give the application a “placeholder” IP address. 0.0.0.0 is that placeholder and it means “all IPV4 addresses in the local machine”. In this case:

gatsby develop --H 0.0.0.0

Now, the message is different:

 Local: http://localhost:8000/ On Your Network: http://172.17.0.2:8000/

And both these addresses now serve my project!

So this is it. I can now change my code and see the changes on the browser just fine.

Another option

If you use VSCode as your editor, it has now an extension called “Remote – Containers” that will open your repository inside a Docker container for you (no need to build the image) and allow you to manage the container from its own UI. Note that you still need Docker installed locally for this extension to work.

One thing to note is that it’s possible to manage the port exposing through VSCode and using this project as a test, I did not need to specify any host for my development server command. The extension provides a way to expose the ports (select the one the project is running on, right-click and “forward the port”):

Port forwarding in Remote-Containers in VSCode

The project is now accessible on 127.0.0.1:8000 in the browser.

For more information on using the VSCode Remote Containers extension I recommend this excellent article, that goes into a lot more detail than I did!

I hope this post helps you keep your development environment organized.

If you found this helpful, let me know on Twitter!

The post Developing inside a Docker container _was originally published at _flaviabastos.ca

How to permit nested parameters in Rails

Flávia Bastos — Wed, 30 Sep 2020 08:28:00 +0000

The context

Rails 5 introduced a big change in how it handles ActionController::Parameters (the parameters that you get on your Controllers): before Rails 5, if you called your params you would get a hash back and after Rails 5, you get a ActionController::Parameters object. You can see that by calling params.inspect and if you call .to_h on these parameters you should be good to go.

However, you might get an empty hash when calling .to_h on some parameters because they were not explicitly permitted – see the result of inspecting my params (note the “permitted: false” at the very end):

<ActionController::Parameters {"friends" => {"park" => "Doggoland", "dogs"=>[{"id"=>73, "name"=>"Milou", "household"=>"Tintin"}, {"id"=>74, "name"=>"Snoopy", "household"=>"Charlie Brown"}]}} permitted: false>

Permitting params was showing up back in Rails 4 when Strong Parameters were introduced as part of security features and this blog post goes through some examples of why just calling .to_h might be an issue now that Rails 5 returns objects instead.

Permitting parameters

One good way to permit some parameters is by creating a private helper function in your controller that will explicitly permit the parameters you want:

private def nice\_params params.permit(:id, :name, :email).to\_h end

When accessing your params, instead of params[:name], you use nice_params[:name].

Permitting nested parameters

Things get a little more complicated when you have a nested data structure. The documentation only gets one level deep and I had something more complicated than that. Let’s use the following as an example:

{"friends" => { "park" => "Doggoland", "dogs"=>[{"id"=>73, "name"=>"Milou", "household"=>"Tintin"}, {"id"=>74, "name"=>"Snoopy", "household"=>"Charlie Brown"}] } }

My nice_params function looks like this:

def nice\_params params.permit( friends: [:park, dogs: [:id, :name, :household]] ).to\_h end

One very important thing to notice is that the nested list must be placed last!

I hope this helps someone else with deep nested params.

If you found this helpful, let me know on Twitter!

The post How to permit nested parameters in Rails_ was originally published at _flaviabastos.ca

5 razões pra começar a aprender JavaScript

Flávia Bastos — Wed, 16 Sep 2020 11:25:00 +0000

Se você já programa há algum tempo e não sabe JavaScript ou se está pensando em aprender a programar e não sabe por onde começar, aqui está a minha lista de motivos porque eu acho que você deveria aprender JavaScript (ou simplesmente “JS” no resto desse post):

JS é o que faz a internet ser interativa

Antes de JS, a internet era meio sem-graça: um monte de texto, uns links e olhe lá umas imagens com animação. JS mudou tudo e passou a oferecer uma experiência muito mais interativa pros usuários. Sabe a tela de login do seu email ou do acesso ao site do banco? Então, tem JS pra você clicar no botão e ir pra outra página. E quando você vai preencher um formulário e os campos já vão sugerindo o resto do text? É o JS que faz isso.

Só pra deixar claro, existem outras maneiras de se implementar as funcionalidades que eu descrevi aí mas na maioria das vezes quem está fazendo esse trabalho é o JS. E pra ser bem sincera, hoje em dia é quase impossível navegar na internet sem usar nada de JS….

Não precisa instalar nada pra começar

Uma coisa que eu acho bem legal é que como JS é basicamente a “língua oficial” da internet, você não precisa instalar nada no seu computador pra começar a usar e aprender JS. O seu navegador já é suficiente! Aqui sugiro 3 opções, da mais simples pra mais “complicada” (que daí vai precisar instalar ferramentas pra te ajudar a escrever código):

Use o site de JavaScript do Pluralsight
abra uma nova aba no seu navegador e aperte as teclas CTRL + SHIFT + I. Esse é o atalho pra abrir o “Developer Tools” (“Ferramentas de desenvolvimento” numa tradução livre) no Chrome ou no Firefox ( acho que funciona em outros navegadores mas não tenho certeza). Clique em “Console” e o painel vai parecer o seguinte (estou mostrando no Chrome):

Ferramentas de desenvolvimento do Chrome

Clique na linha onde tem o sinal de maior e escreva o seguinte (incluindo as aspas): “Ola mundo!”. Aperte ENTER.

Parabéns, você acabou de escrever seu primeiro programa em JS. O browser avaliou seu código e escreveu de volta o conteúdo. Esse caso é bem simples, claro, e não teve nenhum processamento mas dá pra fazer muitas outras coisas só nesse painel. Se quiser escrever uma função com linhas múltiplas, segure a tecla SHIFT enquanto aperte o ENTER pra inserir uma linha nova e não “executar” o console imediatamente.

Com linhas múltiplas você pode começar a escrever coisas mais interessantes como por exemplo funções. Essa função aí em baixo usa uma lista de nomes e interage com cada nome, um de cada vez:

Exemplo de função em JavaScript

// código da tela:amigos = ["frodo", "sam", "pippin", "merry"]gritos = function gritando(arr) { return arr.map(nome => nome.toUpperCase());}gritos(amigos)// depois da linha acima, o resultado na tela é:// (4) ["FRODO", "SAM", "PIPPIN", "MERRY"]

Esse são exemplos bem simples mas é só pra mostrar o que dá pra fazer (e eu só sei o que tem escrever porque já usei muito JS e olhei na documentação; não dá pra saber de outra forma!)

Uma desvantagem do console é que não dá pra salvar nada. Fechou a janela do navegador, perdeu.

a terceira opção é você usar um arquivo com extensão .html(a “língua” de formatação da internet) e inserir o seu JS dentro dele. Por exemplo:

Você pode simplesmente salvar esse arquivo com o nome que quiser, por exemplo, “exemplo.html” e abrir no navegador (clique em CTRL + O — “o” maiúculo de “open”, “abrir” em inglês — e escolha o arquivo que acabou de salvar). O navegador vai mostrar só texto “Mensagem na tela” que é o que está no HTML na linha 20, mas pra você ver a mensagem do JS (linha 15), abra a ferramenta de desenvolvimento (CTRL + SHIFT + I). Pra editar esse arquivo você provavelmente vai querer usar um editor de texto e embora seu computador deva ter algum instalado, eles não costumam ser indicados pra desenvolvimento. Outras opções incluem: VSCode ou Sublime ou Atom.

Tem muito recurso gratuito disponível

Se você sabe um pouco de inglês, tem muitas opções de materiais gratuitos para aprender JS. Dois dos meus favoritos são os seguintes (precisa criar conta pra acessar os dois, mas são grátis): freeCodeCamp e o JavaScript 30 do Wes Bos. Em português tem a documentação do MDN mas eu realmente não conheço nenhum curso no momento pra recomendar.

A linguagem está em crescimento e oferece muita funcionalidade

Esse é um ponto que muitas pessoas usam para criticar a linguagem: parece que todo dia tem uma ferramenta nova em JS. Embora isso seja um exagero, não está muito longe da verdade. Mas na minha opinião esse é um ponto positivo, pois conforme a linguagem vem crescendo, ela vai ocupando mais espaços na área de desenvolvimento pra web e hoje em dia é viável ser programador web sabendo só JS. Em conjunto com outras ferramentas do ecossistema (como Node.js pra rodar do lado do servidor e React.js pra fazer a interação com o usuário), dá pra escrever aplicações completas.

Dá pra fazer fazer coisas bem legais!

Voltando um pouco ao primeiro ponto, a maioria do que você conhece da internet que permite você interagir com o conteúdo de um site, tem JS envolvido. Tem até aplicação feita 100% em JS: um exemplo é esse joguinho escrito só com JS que o Wes Bos ensina no curso.

Então resumindo, se você quer começar a aprender a programar, JS é uma ótima opção pra começar. Se você já programa em outras linguagens mas tem aquele preconceito com JS, tá na hora de superar isso aí. A internet só está evoluindo.

Se você tem perguntas ou sugestões, me conta lá no Twitter.

O post “5 razões pra começar a aprender JavaScript” foi publicado originalmente no blog flaviabastos.ca

DEV Community: Flávia Bastos

Django Rest Framework: adding DateTimeField format serializer validation

Book review: The Programmer’s Brain

Book Overview

My takeaways

For more info about Barbara Oakley’s work

Como reverter um commit no git

RESUMÃO: passos pra reverter um commit em um repositório remoto:

EXEMPLO passo-a-passo:

MAS peraí, o RESET --HARD faz a mesma coisa, não?

Pra saber mais:

TIL: installed packages in Python – list, and show

Example:

How to revert a commit in git

TL; DR: steps to revert a commit on a remote repo:

Let’s run through an example:

But what about reset --hard? Doesn’t it revert commits too?

Learn more:

Managing local git branches with git rebase

what is git rebase

when to use git rebase

when NOT to use git rebase

how to use git rebase:

git rebase – branch out of main

git rebase – branch of branch of main

when git rebase has conflicts

managing your commits – the case for single commits

What’s wrong with using git merge?

there’s more to git rebase

The difference between HTTP status codes 401 and 403: Unauthorized and Forbidden

Official specification

401: Unauthorized

403: Forbidden

Let’s simplify: airport analogy

A real example

Important! Don’t believe everything you read!

A caller id for your python function

How to use

Fancypants

git stash 101

What does git stash do?

When to use git stash?

Basic stashing activities:

CREATE STASH

INSPECT STASH

MANAGE STASH

Developing inside a Docker container

Docker image for a dev environment

Choosing how to run the image

Inside the container

Not so fast, my friend!

What do I do now?

Another option

How to permit nested parameters in Rails

The context

Permitting parameters

Permitting nested parameters

5 razões pra começar a aprender JavaScript

JS é o que faz a internet ser interativa

Não precisa instalar nada pra começar

Tem muito recurso gratuito disponível

A linguagem está em crescimento e oferece muita funcionalidade

Dá pra fazer fazer coisas bem legais!

MAS peraí, o `RESET --HARD` faz a mesma coisa, não?

But what about `reset --hard`? Doesn’t it revert commits too?