GoDjango Screencasts and Tutorials

Django 1.11+ django.contrib.auth Class Based Views - Part 2 - Password Change and Reset

Mon, 10 Jul 2017 15:00:00 +0000

Since we can log in and logout what about managing our password? Learn the power of using the builtin Generic Class Based Views now in django.contrib.auth. They are simple to use once you know about them.
Watch Now...

Django 1.11+ django.contrib.auth Class Based Views - Part 1 - Login & Logout

Mon, 03 Jul 2017 21:00:00 +0000

This is the first in a long series on creating a CryptoCurrency management site, but first we need to lock things down so people can't see all of our stuff. So we will start by setting up our app and logging in and out. We will do this with the new Class Based Views in django.contrib.auth system.
Watch Now...

Django 1.11 Release Notes a Reading

Wed, 05 Apr 2017 15:00:00 +0000

Django 1.11 is released for the world to use. It comes with a lot of changes, which can take some time to read.

In my last video I mentioned I would read these release notes if there was interest so here you go. I have read all of the release notes so you can just put on some headphones and hit play.

Django 1.11 Release Notes a Reading

Django 1.11 Highlights

Wed, 29 Mar 2017 15:00:00 +0000

You can't always, easily, keep up with the latest and greatest of what is coming out in django, so since we have a new release candidate for django 1.11 here are a few of the highlights.

I would say there are some interesting things that are on the horizon for django, especially since this is the last 1.x release before we are on to 2.0.

Django 1.11 Highlights

How Do I Start Learning Django

Tue, 14 Mar 2017 15:00:00 +0000

If you have done django for any amount of time you have probably gotten this question, and it can sometimes be hard to answer beyond start at the main django site.

In this video I attempt to help by giving people a starting point, and some guidance on resources to and how to use.

Give it a watch and offer any suggestions, and tweaks you think should be made.

How Do I Start Learning Django?

You Should do Weird Stuff in Django

Mon, 27 Feb 2017 16:00:00 +0000

Out of the ordinary things are the times that we grow the most as developers. However, a lot of times we don't do enough weird things when we write our software.

I would encourage you to try that odd idea that you have been messing with in your head that you aren't sure you can do. Ironically you will grow more as a developer from that than your day to day getting stuff done development

I am not sure why I ever really thought about this, but give a watch to what keyed me in on this thought.

You Should Do Weird Stuff in Django

Why You Should Pin Your Dependencies by My Mistakes

Mon, 20 Feb 2017 16:00:00 +0000

Have you ever been bitten by not pinning your dependencies in your django project? If not be glad, and come learn from my problems.

Pinning your dependencies is important to solve future unknown issues, better the devil you know and all that.

In this weeks video I talk about 3 times I had issues. They are either not pinning my dependencies, a weird edge case with pinning and python, and not really understanding what I was doing with pinned dependencies.

Why You Should Pin Your Dependencies

Different types of testing in Django

Tue, 14 Feb 2017 16:00:00 +0000

Testing is always one of those topics that can be interesting to talk about. There are a lot of different opinions on testing so it can be fun.

Django comes with some great tools for testing, so this week we will talk a little bit about the different types of tests. Then expand on that with how that relates to Django.

I also present to you a new type of test at the end of the video that I have been using, special thanks to a co-worker for coming up with the idea. It is really specific to django, and I haven't heard of others doing it.

Different Types of Tests with Django

5 Reasons to Use Class Based Views

Mon, 06 Feb 2017 16:00:00 +0000

Anytime anyone brings up Class Based Views, generic and otherwise, it is similar to the Vim vs Emacs debate. So lets pile on a bit more.

But not really. In actuality, I feel like there are good, solid, and legitimate reasons to use Class Based Views which get passed over in the middle of arguments.

In this weeks topic I talk about 5 of those reasons I think people should use Class Based Views. In reality there are more, but I wanted to keep the video short'ish.

5 Reasons to Use Class Based Views

How to Vett Django Apps

Mon, 30 Jan 2017 16:00:00 +0000

There are a lot of 3rd party django apps that people put out which makes our lives easier, but are they good?

There are a lot of ways to evaluate them, mostly it seems a lot of people use intuition.

In this weeks video I go over several ways of how I go about vetting projects before use in my projects.

How to Vett Django Apps

How I Deploy Django Day-to-Day

Wed, 18 Jan 2017 16:00:00 +0000

There are a lot of ways to deploy Django so I think it is one of those topics people are really curious about how other people do it. Generally, in all deploys you need to get the latest code, run migrations, collect your static files and restart web server processes. How yo do those steps, that is the interesting part.

In todays video I go over How I deploy Django day to day, followed by some other ways I have done it. This is definitely a topic you can make as easy or complicated as you want.

Here is the link again: https://www.youtube.com/watch?v=43lIXCPMw_8?vq=hd720

5 Reasons I don't think you should use the django admin

Mon, 09 Jan 2017 16:00:00 +0000

Have you ever needed to quickly modify data or look it up. But while the task is simple the entire process of changing one value frustrates you?

Well, this is very common to me, bad UX is annoying. I quite often have to either lookup, or edit, two disparate, yet related pieces of data, and sometimes it is an exercise in frustration.

An all to common occurrence is I just needed to check the edit history of a "Company" our database. This is a simple process, go to the admin find the Company model, do a search and you have your answer.

Except, it isn't that easy in reality. Lets run through what really happened.

I went to "http://superawesomesite.com/admin/" and logged in.

I then looked at how my model options extended well below the fold of my browser so I had to scroll. No problem I'll just hit "ctrl+f" and search for it. WTF!!! where is my company model?

I then proceed to scroll down and finally find it only to remember it was pluralized. If I had searched for "Companies" I would have been good to go, grrrrr.

I click into and see the list of companies available to me. I see that there is a search feature at the top so I do a search for the relevant information. Unfortunately, I don't know the company name that is what I am trying to find out.

Except, we aren't filtering our search in the admin based on that field. So no results show up.

No problem I can do a list filter on the side. So I set the correct filters and still no luck because someone didn't set all the metadata that was supposed to be set for the company. Again grrrrr.

Finally, I abandoned the admin and opened up the django/python shell and did a query with the model, and in about 30 seconds had the record I needed. Took the id and plugged that into the django admin and I was good to go.

This was an exercise in frustration because the 30 seconds that was taken during development to decide which fields should be filtered didn't let that person imagine the field I needed. Also the fact that whomever added the company didn't add all the correct information, made it almost impossible to find the data. In the end I had to go outside this system that is hailed as one of the greatest tools for django to get the information I needed.

I propose we as a community reduce our reliance on the django admin, especially in production.

I also created a Video on the 5 reasons we shouldn't use the django admin.

Basics of Webpack

Fri, 21 Oct 2016 15:00:00 +0000

Webpack can be complicated, but it doesn't have to be. Learn some of the basics of webpack, and how you can get started with it while actually understanding it. In this video we start our journey to working with react and django, but first we need to build our javascript and that is where webpack comes in.
Watch Now...

Store Measurements Sanely with django-measurement

Fri, 30 Sep 2016 15:00:00 +0000

Storing measurement data for multiple types of units is quite a frustrating task. Fortunately with django-measurement providing a good wrapper for python-measurement it makes this almost a non-issue. In this video get a quick overview of how to use django-measurement to store that pesky data.
Watch Now...

Setting up a Honey Pot with django-admin-honeypot

Fri, 05 Aug 2016 15:00:00 +0000

Security is something we often ignore until it is too late. However, there are some things you can do right now that are easy to increase your security. Using django-admin-honeypot is one of those things you can do. It is super easy and provides you with the means of tracking who is trying to access your site.
Watch Now...

Django with Bash for Windows

Thu, 23 Jun 2016 15:00:00 +0000

Doing django development using "Bash for Windows" seems to work pretty well. See what it takes to set it up and get started.
Watch Now...

Custom python-social-auth Pipeline

Fri, 10 Jun 2016 15:00:00 +0000

Sometimes when you authenticate with a social service you need to do custom "stuff" in your code base beyond creating a user object. Learn how to get started simply adding a custom function do the python-social-auth pipeline.
Watch Now...

Create Cache Bustable Static Files

Fri, 25 Mar 2016 15:00:00 +0000

Dealing with static files like css and javascript and the cache can be annoying, and hard. Fortunately Django provides a way to solve this fairly easily. Learn how to add a hash in your static file names so caching can be easier.
Watch Now...

CSV Files - Read and Create

Thu, 11 Feb 2016 16:00:00 +0000

CSV files seem to be what some companies live by. Because of that we need to know how to work with them. In this video learn the basics of using csv reader, writer, DictReader, and DictWriter
Watch Now...

Django Model Inheritance - Multi-Table Inheritance

Thu, 21 Jan 2016 16:00:00 +0000

In the last post we talked about Model Inheritance with regards to Abstract Model Classes, it was a great introduction into using OOP with your models to keep your code slim and tidy. You can read it at: Django Abstract Base Class - Model Inheritance

In this post we are going to discuss Multi-Table Inheritance. We will create a base model, that is not an abstract model, and inherit from the model. Then we are going to show you how to get and reference data from that models inheritance.

Multi Table Inheritance

When we talk about multi-table inheritance we are referring to having a top level table with all the fields that are core to that context. Then we are going to have other tables with the more specific fields. You select from the table you want, and then do a join on a relationship to get the parent table data. Since Django does this through models and code, we will talk about it in those terms.

In our example we are going to have a Ticket Model.

class Ticket(models.Model):
    title = models.CharField(max_length=255, blank=True)
    description = models.TextField(blank=True)
    name = models.CharField(max_length=255, blank=True)

This model is a good piece of code because no matter what type of ticket we ever have we are going to have a title, description, and name. This is normal for any OOP we would do as a base class. Since we have this base model we can subclass it to have more specific models with data associated with them.

class InternalTicket(Ticket):
    user = models.ForeignKey('auth.User', null=True)

class CustomerTicket(Ticket):
    product = models.TextField(blank=True)

Now we have 3 models available to us: Ticket, InternalTicket, and CustomerTicket. Each one has a title, description and name as fields. However, CustomerTicket does not have a user field and InternalTicket does not have product field. Also both InternalTicket and CustomerTicket are stored in separate database table from title, description and name. So if you looked up the tables in the database you would see a FK reference to the ticket table, id field and the field you declared. Everything else lives in the ticket table.

Getting and Creating Data

With all that said lets look at creating some data and getting it back out. Because that is really when it makes sense on how it works.

In [1]: CustomerTicket.objects.create(product='Videos', title='Odd Playback', description='doesnt play back fast enough', name='Jane Smith')
Out[1]: <CustomerTicket: CustomerTicket object>

We have created a CustomerTicket object with all of our fields set, and it succeeds. (Further proof it works)

In [2]: Ticket.objects.all()
Out[2]: [<Ticket: Ticket object>]

Here we are getting all tickets from the ticket model, which is including our CustomerTicket we create above.

In [3]: ticket = Ticket.objects.get()

In [4]: ticket.customerticket
Out[4]: <CustomerTicket: CustomerTicket object>

If we reference the customerticket property, which is the related name, it will return back the model so we can get the data from the model. We can look at that in action.

In [5]: ticket.customerticket.product
Out[5]: 'Videos'

In [6]: ticket.description
Out[6]: 'doesnt play back fast enough'

Finally, you can see the description is still on the ticket level and not the cutomerticket model.

How does it work

From the django docs:

multi-table inheritance uses an implicit OneToOneField to link the child and the parent

This means there is a one-to-one relationship between the ticket record and the corresponding subclassed models. Django just handles the translation of it from multiple tables to a single model so you don't really notice it.

CustomerTicket object

As our final look we can look at how the CustomerTicket object we created earlier references the ticket object.

n [1]: customer = CustomerTicket.objects.get()

In [2]: customer.description
Out[2]: 'doesnt play back fast enough'

As you can see django just handles the fact that description is on the model, even though the description data is in the ticket table.

In [3]: customer.ticket_ptr
Out[3]: <Ticket: Ticket object>

The .ticket_ptr property is the reference to the ticket object so if you need to actually use that model you can.

In [4]: customer.ticket_ptr_id
Out[4]: 1

ticket_ptr_id holds the id of the Ticket object in the database giving you another avenue for getting information out of the appropriate place.

Conslusion

You don't often need to use Multi-table inheritance, but when you do need to use it, it is nice that django makes it super simple to use. I have only seen a few instances where it makes sense, tickets being one, and social media posts as another. It provides great value in giving you core data, then when needed get the rest of the data. It does this while allowing you to use the models as separate models as if the inheritance didn't exist. Finally, another way to think of it is as data being used with polymorphism.

Django and Angular - Setting up Base Angular App

Thu, 07 Jan 2016 16:00:00 +0000

Learn what it takes to get the basics of an angular app going with Django. See how simple it is to get started.
Watch Now...

reverse, lazy and resolve - Django url-resolvers

Mon, 07 Dec 2015 16:00:00 +0000

Working with urls is a core part of web development. The url-resolver utilities django provides makes working with them just that much easier. Look at using `reverse`, `reverse_lazy`, and `resolve` utility functions to write better idiomatic django.
Watch Now...

Django Abstract Base Class - Model Inheritance

Thu, 03 Dec 2015 16:00:00 +0000

Model inheritance is a very useful and powerful feature of django, but used incorrectly it can cause a lot of confusion. Lets go ahead and take a look at some of those.

Have you ever been looking through other peoples code and seen a model class Meta with abstract = True? That is the first type of inheritance we are going to look at, abstract base models. There is also multi-table inheritance, proxy models, and multiple inheritance available.

Abstract Base Classes

In this post we are going to focus on Abstract base classes. This is the easiest type of model inheritance to really understand because it works very much like normal inheritance. In OOP when you inherit from another object you get all of its members plus your own. You can modify those members or leave them the same. Abstract base classes are the same.

Here are two example classes

class Customer(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField(max_length=100)
    address = models.CharField(max_length=100)
    purchase_history = models.ForeignKey('cart.Invoice')

class Staff(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField(max_length=100)
    address = models.CharField(max_length=100)
    bio = models.TextField()
    position = models.CharField(max_length=20)

As you can see these two models are legitimate models with fields, but they do have common elements. In a lot of cases it is fine to leave them this way. However, if we use these same fields yet again it would be a good idea to use an abstract base class.

class ConactInfo(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField(max_length=100)
    address = models.CharField(max_length=100)

    class Meta:
        abstract = True

class Customer(ContactInfo):
    purchase_history = models.ForeignKey('cart.Invoice')

class Staff(ContactInfo):
    bio = models.TextField()
    position = models.CharField(max_length=20)

We now have a ConactInfo abstract base class because we added abstract = True to its Meta. This will tell django and the migration system this isn't a model we can use to store data with.

However, we can inherit from it so that each model that we subclass with it has the fields, methods, and properties of the abstract model. At this point if you did ./manage.py makemigrations it would create a migration file creating only Customer and Staff tables in the database.

Will it Work with Existing Models?

Lets say you have several existing models in your code base you want to abstract into base classes. Will it "just work"? Yes it will. Once I found out about abstract classes I went and made several then ran a makemigrations and nothing happened because to django nothing changed you just refactored you code.

Conclusion

Hopefully this gives you a place to start with doing model inheritance. It is very useful, but much like OOP don't go crazy with it and have a lot of abstract classes. You can be so abstract you have no idea what is going on.

My rule of thumb, whether good or bad, is if I have more than 3 fields repeated in only 2 models I just leave them alone. If I need to add them to a third model I will evaluate if it makes sense to use an abstract model. If I can name the abstract model and it makes sense like ContactInfo then there is enough context to create the new model, so I will. Otherwise I will put it off until the code is screaming for an abstract base class.

Stay tuned for the next post on Multi-table inheritance.

What has your experience been?

Installing Wagtail

Fri, 20 Nov 2015 16:00:00 +0000

Wagtail has become a very popular CMS in the last year. Start with this video to see how to get it up and running for your project, and get content on the homepage.
Watch Now...

Understanding *args and **kwargs

Fri, 30 Oct 2015 15:00:00 +0000

args and kwargs are hard. They are confusing, and tricky when you are learning python. Even experienced developers can be tripped up by them. Learn how to expand and collapse lists and dictionaries for args and kwargs.
Watch Now...

Filter Your List of Objects in the Admin

Fri, 25 Sep 2015 15:00:00 +0000

Getting the data you need in the admin quickly is important. Learn how to filter not only based on fields, but add your own custom filter as well.
Watch Now...

Getting Started with Django Admin

Thu, 20 Aug 2015 15:00:00 +0000

The admin is a very useful tool for developers to use when working with django. It is super easy to setup, and get your models registered with it so you can start CRUDing data.
Watch Now...

Working with Environment Variables in Python

Thu, 06 Aug 2015 15:00:00 +0000

If you look at modern code deployment practices, like in the 12 factor app, environment variables are very important for keeping secret information secret, or server specific information set for that server. All while not having long crazy settings in a settings file for every single server and computer. It helps keep things slimmer in your code along with the following quoted from the 12factorapp site:

    * Resource handles to the database, Memcached, and other backing services
    * Credentials to external services such as Amazon S3 or Twitter
    * Per-deploy values such as the canonical hostname for the deploy

What Are Environment Variables?

Environment variables are a key value pairs that can affect how a program runs. They need to be set at some point before a process is run so the process can read them in and act accordingly. A lot of times in production environments your database name and password are set as environment variables so that information does not end up in a code repository somewhere.

By relying on an environment variable your code doesn't care what a setting is because you can set that at some other point. Actually working with environment variables is really simple. All you need to start is import os and you are off to the races.

Get Environment Variable with Python:

name = os.environ.get('DATABASE_NAME')

The environ part of this call is like a dictionary of all the environment variables. So we just get the one we are after and go about our business. You might even see something like below for your database settings, in your django settings file. You are either getting the environment variable, or you are getting back an empty string.

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': os.environ.get('DATABASE_NAME', ''),
        'USER': os.environ.get('DATABASE_USER', ''),
        'PASSWORD': os.environ.get('DATABASE_PASSWORD', ''),
        'HOST': os.environ.get('DATABASE_HOST', ''),
        'PORT': os.environ.get('DATABASE_PORT', ''),
    }
}

Running `django-admin.py/manage.py` with environment variables

A common use of environment variables in django is the DJANGO_SETTINGS_MODULE. It tells django-admin.py what settings file to load for a project.

DJANGO_SETTINGS_MODULES='project.settings' django-admin.py

manage.py is basically a shortcut to this command. We are setting the location of our settings.py file and running django-admin.py command. There has been a lot debate about manage.py since the above is all it really does. You can read and learn more on a ticket about it: Deprecate and then remove "shell" management command

Set environment variable in bashrc

Finally, depending on your environment you might want to setup environment variables in your bashrc or bash_profile so every time you start a command line environment they are set. To do this add something like the following to your bashrc or bash_profile

export PROGRAMMING_FOLDER='/home/user/programming/'

The export command is built into shell and sets PROGRAMMING_FOLDER to /home/user/programming for the current environment. You can verify this running env in your shell, or even env | grep PROGRAMMING to get just that environment variable.

Common Places to Set Environment Variables in Production

First link is how to set environment variables with supervisord which is a recommended way to run your server side code, generally running gunicorn or uWSGI. uWSGI is linked to because a lot of people run it outside of supervisord. However, it is recommended if you use gunicorn to use supervisord so set environment variables inside that config.

Conclusion

Environment variables are extremely useful, but can be a huge pain to work with. I really suggest playing with them in different environments to get used to working with them. When I first started setting them in production environments it was tough to first learn how to set them, and run my code. However, once I got environment variables working locally in my dev environment, and in production it became super convenient. I am super glad I took the extra effort to learn a process to work with them, and I think you will too.

Django and Python 3 How to Setup pyenv for Multiple Pythons

Thu, 23 Jul 2015 15:00:00 +0000

We need to be doing Django development in Python 3. Unfortunately, we have a lot of projects still in Python 2.7 so switching between the 2 versions can be frustrating. Fortunately pyenv takes the guess work out of switching, and makes it super simple.
Watch Now...

Frontend Code Strategy with Django

Mon, 13 Jul 2015 15:00:00 +0000

Web development is getting more and more focused on front-end development. This leads to a lot of questions on what is the best way to handle compiling css, javascript, coffeescirpt, stylus, etc. Having been involved with a project where the frontend deals with 100+ files between stylus files, coffeescirpt files, javascript, and css. This is kind of crazy to manage without a good strategy or even knowing how to accomplish it.

How Frontend Code Works in Django

When working with django you need to consider how the code is going to go from your code base to be displayed in the browser. The normal path it takes is to live in a static directory which you edit and run locally. Then in production you do a collectstatic command and it moves everything to a folder for your webserver to pull from. With that in mind as long as the above happens you can do almost anything you want for your frontend code. Lets take a look at the 3 most common ways you can do front-end development with django.

Three Popular Ways to Write Frontend Code

Everything in the static folder

The most common way we start projects is to just stuff everything in a static file on the root of our project. We add img, css, and js folders to keep things organized. We then use the staticfiles app to use template helpers for loading in our static files without having to hard code them. This will get us a long way, and for most sites is a good approach, because lets face it most sites don't move past hobby projects.

To get this working about the only configuration you need is:

INSTALLED_APPS = (
    ...
    'django.contrib.staticfiles',
    ...
)

STATIC_URL = '/static/'
STATICFILES_DIRS = (
    os.path.join(BASE_DIR, 'static'),
)

STATIC_ROOT = os.path.join(BASE_DIR, 'static_final')

To see it in action you can watch a video here: Staticfiles, template filters, and commands

Third Party Django Library

The next step people often move to is using a third party django app which kind of takes care of everything for you. You set in the settings what you want to use to compile and preprocess code. The django app then does all the processing, finally outputing the final information where we tell it, generally from the settings above. It is fairly simple and straight forward to use these libraries especially since they don't really break your workflow, and you get the addition of using the latest cool technologies.

The two most populare packages I have seen is django-compressor and django-pipeline, a fork of compressor. Both are fairly simple to setup and configure, but they do have their limitations and oddities. I would recommend doing a side project with each to evaluate which one you like, to determine if it is right for you.

If you want to checkout a video for django-pipline go here: Compile and compress assets with django-pipline

Front-end Build System

The final way most often seen for building front end code is to use an entire build system outside of django completely. You setup your static file locations like we did above, and then you tell the independent build system to output your files there. Generally you would use something like grunt, gulp or brunch to do this. This method gives you the most flexibility and freedom, but is the most time consuming to setup and learn. If you heavily rely on front end code then this is probably the best solution, especially for single page apps.

Also by taking the time to learn some of these tools it helps you become a better all around developer through getting you involved in other things besides just django and python. Generally these build systems are completely custom, or based on something in the node.js world. Below are some of the more popular ones:

There is also a video on this method as well using gulp check it out here: Use gulp.js to manage static assets

Conclusion

Knowing what is the best way to build your assets is hard, I use all three methods in various projects. So I kind of take a tiered approach to know when to choose what method. If it is a small site where I am going to write it once and forget about it or maybe touch it a couple of times a year I don't worry about a build system at all, not worth the effort. If I am going to touch the code once a month on average I will generally use django-pipeline. However, if I am touching the code base 2+ times a month it means I am probably touching it more than that and I need to have the most flexibility, so I will use gulp.

These are the rules I follow, but I suggest you take a look at these methods and find your own sweet spot.

Wrapping Up CycleMento

Tue, 23 Jun 2015 15:00:00 +0000

in this video we wrap up the Building a Product series by doing an overview of topics we discussed in the previous 11 videos.
Watch Now...

Adding Maintenance Data pt 1

Fri, 15 May 2015 15:00:00 +0000

Join us as we continue building our product by starting to allow our users to add bike maintenance records to their bikes.
Watch Now...

Saving Data from Strava

Wed, 08 Apr 2015 15:00:00 +0000

Getting data can be easy. Effectively saving it from one source to your database can be a pain. In this video we explore a way to get data from Strava and save it to our database with as little future trouble as possible.
Watch Now...

Informing Users with django.contrib.messages

Thu, 26 Feb 2015 16:00:00 +0000

The messages framework can be bit confusing to wrap your head around at first. Learn the basics of setting successful and error messages and show them to users. See the default django way, then see how to do with django-braces.
Watch Now...

Account Control part 1

Fri, 30 Jan 2015 16:00:00 +0000

This is the first in a series of videos on creating a product which utilizes other services to help your users stay informed. We start the series with getting our users setup with an account, and giving them the ability to log in and out.
Watch Now...

Custom Django Admin Actions

Wed, 24 Dec 2014 16:00:00 +0000

Doing bulk data actions in the admin is easy, if you know how to do it. In this video you will learn how to create your own custom admin actions so you can update a lot of data objects all at the same time.
Watch Now...

Project Templates with Cookiecutter

Mon, 24 Nov 2014 16:00:00 +0000

When we start new projects we want to solve a problem, not write boilerplate. Cookiecutter helps you to stop writing boilerplate. In this video you will learn what cookiecutter is, and how to create templates so you can save yourself time and effort starting new projects.
Watch Now...

Using Arrow for Better Datetime

Wed, 29 Oct 2014 15:00:00 +0000

Learn how to be better at dealing with dates and times in python in a few short minutes. Working with dates and times in python is a lot easier than other languages, but can be convoluted and confusing. Arrow provides a convenient api for working with and manipulating dates and times. See what it takes to get started.
Watch Now...

The Class Based "View"

Mon, 29 Sep 2014 15:00:00 +0000

People often find working with class based views hard, but they are simple... Once you spend time figuring them out. In this video start with the base of building blocks and work your way through completly understanding the base View of (generic) class based views.
Watch Now...

Understanding get_absolute_url

Tue, 09 Sep 2014 15:00:00 +0000

URL's can be a pain at times, but with get_absolute_url on your model it can make dealing with them on a per-object basis much simpler and cleaner across your entire site. Not to mention Django itself loves to use get_absolute_url, so it will make other tasks a lot easier.
Watch Now...

Starting with django-allauth

Mon, 11 Aug 2014 15:00:00 +0000

There are a lot of ways to do authentication in django. You can do social authentication and/or django.contrib.auth authentication. Generally they are separate, but with django-allauth you can combine them both into one package. It even gives you a great jumping off place with plenty of other features. In this video learn how to start using django-allauth.
Watch Now...

Deferred Tasks and Scheduled Jobs with Celery 3.1, Django 1.7 and Redis

Mon, 14 Jul 2014 15:00:00 +0000

Setting up celery with Django can be a pain, but it doesn't have to be. In this video learn what it takes to setup Celery for deferred tasks, and as your cron replacement. We will use Celery 3.1 and Django 1.7 both introduce changes you need to be aware of.
Watch Now...

Using Chart.js with Django

Mon, 07 Jul 2014 15:00:00 +0000

Chart.js is the new kid on on the block for JavaScript charts. Learn how to use them here to chart out the number of user registrations for the last 30 days.

The View

This view builds an array of people that registered on the site daily for the last 30 days.

from django.views.generic import TemplateView
from django.contrib.auth.models import User

import arrow


class AnalyticsIndexView(TemplateView):
    template_name = 'analytics/admin/index.html'

    def get_context_data(self, **kwargs):
        context = super(AnalyticsIndexView, self).get_context_data(**kwargs)
        context['30_day_registrations'] = self.thirty_day_registrations()
        return context

    def thirty_day_registrations(self):
        final_data = []

        date = arrow.now()
        for day in xrange(1, 30):
            date = date.replace(days=-1)
            count = User.objects.filter(
                date_joined__gte=date.floor('day').datetime,
                date_joined__lte=date.ceil('day').datetime).count()
            final_data.append(count)

        return final_data

The method thirty_day_registrations loops through from 1 to 30, and gets the count of registrations for that day. Then it returns that array back to the get_context_data method and assigns it to 30_day_registrations which is what we will use in our template.

The Template

The template is very basic in that it has just enough data to generate a line chart.

{% extends "base.html" %}

{% block extrahead %}
<script src="//cdnjs.cloudflare.com/ajax/libs/Chart.js/0.2.0/Chart.min.js" type="text/javascript"></script>
<script src="//cdnjs.cloudflare.com/ajax/libs/jquery/2.1.1/jquery.min.js" type="text/javascript"></script>
<script type="text/javascript">
$( document ).ready(function() {
    var data = {
        labels: ['1', '5', '10', '15', '20', '25', '30'],
        datasets: [
            {
                label: "Site Registrations in the Last 30 Days",
                fillColor: "rgba(220,220,220,0.2)",
                strokeColor: "rgba(220,220,220,1)",
                pointColor: "rgba(220,220,220,1)",
                pointStrokeColor: "#fff",
                pointHighlightFill: "#fff",
                pointHighlightStroke: "rgba(220,220,220,1)",
                data: {{ 30_day_registrations }}
            }
        ]
    };
    var ctx = document.getElementById("myChart").getContext("2d");
    var myLineChart = new Chart(ctx).Line(data);
});
</script>
{% endblock %}

{% block content %}
<canvas id="myChart" width="500" height="300"></canvas>
{% endblock %}

If we go line-by-line of the important parts this should make more sense.

<canvas id="myChart" width="500" height="300"></canvas>

This is where in the page your chart is going to show up its only real requirement is it has an id and is a canvas object.

var ctx = document.getElementById("myChart").getContext("2d");

This gets us the canvas element for us to feed data to so we can see our chart.

var myLineChart = new Chart(ctx).Line(data);

We create a Chart object and pass it our canvas element. Then we create our Line chart using a data object we are going to create.

var data = {
    labels: ['1', '5', '10', '15', '20', '25', '30'],
    datasets: [
        {
            label: "Site Registrations in the Last 30 Days",
            fillColor: "rgba(220,220,220,0.2)",
            strokeColor: "rgba(220,220,220,1)",
            pointColor: "rgba(220,220,220,1)",
            pointStrokeColor: "#fff",
            pointHighlightFill: "#fff",
            pointHighlightStroke: "rgba(220,220,220,1)",
            data: {{ 30_day_registrations }}
        }
    ]
};

This is an example data object to create a chart. Most of it is self-explanatory, but the keys parts are:

labels: this is outside of the datasets object.
datasets: you can have multiple json objects in here for more lines in chart
data: in this case it is just an array, which in this case we are generating in our view and outputting here.

Conclusion

Chart.js is a great library for doing charting, especially if your primary audience is using more modern browsers. I have been looking at charting libraries, but so far this has been one of the best ones of both paid and free ones. The best part is right now chart.js is free. So if you need to do some charting I would say give it a shot.

Stripe, Webhooks and dj-stripe

Mon, 23 Jun 2014 15:00:00 +0000

Stripe is great for working with payments. Webhooks and dj-stripe make it even better, in this video learn how to use stripe webhooks with your application to get the most out of your stripe integration.
Watch Now...

Stripe and Starting dj-stripe

Thu, 12 Jun 2014 15:00:00 +0000

Stripe is great, but using a library makes it even better. Dj-stripe is a great django library for working with stripe to get people to subscribe to your service. See how simple it is to start working with dj-stripe.
Watch Now...

Starting with Stripe.js

Fri, 23 May 2014 15:00:00 +0000

We all want to make money, so learn what it takes to start accepting money on your site with stripe. Learn the basics of have a user subscribe to your site in this first part of a multi-part stripe series.
Watch Now...

Working with JSON and Django

Mon, 28 Apr 2014 15:00:00 +0000

In this day and age of web development we work with json, a lot, especially with using web services. Unfortunately, sometimes you can forget what does what, when, and where when dealing with json. I know I have to look up the same thing over and over at times. This blog post is everything you need to deal with json "day-to-day" with Django.

JSON to Dict

One of the first things we, usually, do is convert json data that we get back from a web service call, or from a webhook, into a python datastructure.

import json

json_data = '{"hello": "world", "foo": "bar"}' 

data = json.loads(json_data)

The key element from this is the json.loads which loads a string of json and converts the data to a python dict. From there you get to use it like normal.

Dict to JSON

import json

data = {'baz': 'goo', 'foo': 'bar'}

json_data = json.dumps(data)

Normally you want to get your data into json from your dict, or model, which is just as easy using json.dumps. It converts your dict to a string of json so you can return it to in a response.

HttpResponse with JSON

There are a couple of key parts to returning json properly. You need to have a string of json, and a proper content type.

import json
from django.http import HttpResponse

def fbview(request):
    data = {'foo': 'bar', 'hello': 'world'}
    return HttpResponse(json.dumps(data), content_type='application/json')

With this you will send back json properly formatted and with the proper content type so everyone knows what is going on with the data.

JSONRequestResponseMixin from django-braces

Finally, if you are working with class based views you can use a very convenient mixin in django-braces. JSONRequestResponseMixin which gives you some built-in response methods to return your dicts and models back as json, and it handles everything else.

class APIView(CsrfExemptMixin, JsonRequestResponseMixin):
    def post(self, request, *args, **kwargs):
        data = {'foo': 'bar', 'hello': 'world'}
        return self.render_json_response(data)

As you can probably guess the render_json_response method does what the function based view above does by converting the dict to json and returning the proper response.

Conclusion

Hopefully this is a good primer and/or reminder of how you can work with json with python and django. This takes care of all your basics so you can get started with json, or do it better.

Webhooks, Django, and ngrok

Fri, 25 Apr 2014 15:00:00 +0000

Working with webhooks can be a pain. In this video learn more of what they are and how to easily work with them in your local environment using ngrok.
Watch Now...

Django 1.7 Migrations - An Introduction

Tue, 08 Apr 2014 15:00:00 +0000

See what it takes to use the new migrations system that has been integrated into Django 1.7. This video walks you through how to create migrations, and run them. Along with a few other key points you might want to know.
Watch Now...

Download CSV files via CSVResponseMixin

Mon, 31 Mar 2014 15:00:00 +0000

Providing csv files to people is annoying, but writing a custom mixin for use with your views can make it super easy. Often times we have to use a custom function, of some sort, and rejigger around how our views work to get a csv file, then set header information, and finally return a response.

There is a Better Way

Below is a custom mixin you can write, or use, to return a csv file based on a list of lists.

class CSVResponseMixin(object):
    csv_filename = 'csvfile.csv'

    def get_csv_filename(self):
        return self.csv_filename

    def render_to_csv(self, data):
        response = HttpResponse(content_type='text/csv')
        cd = 'attachment; filename="{0}"'.format(self.get_csv_filename())
        response['Content-Disposition'] = cd

        writer = csv.writer(response)
        for row in data:
            writer.writerow(row)

        return response

The first few lines of code are simple. We are declaring the mixin, setting the filename, and returning the filename based on a method on the mixin. That leaves us with the render_to_csv method which takes a lsit of lists, and gives us a downloadable file.

Line by Line Explanation

response = HttpResponse(content_type='text/csv')

We are creating a Django HttpResponse object which django returns, and we are setting the content type to a csv file so the browser knows what it is.

response['Content-Disposition'] = 'attachment; filename="{0}"'.format(self.get_csv_filename())

We are setting the content disposition to be an attachment so that it forces the browser to download the file. Otherwise the browser might render it out into the browser, as text. We also are setting the filename from the get_csv_filename method call instead of using the property for a couple of reasons. First, we can override it in our implementation to be more dynamic. Second, we can mock it out in our testing.

writer = csv.writer(response)
for row in data:
    writer.writerow(row)

return response

Finally, we are creating a csv writer and using our response object. Then as we loop over our list of lists we write them out one at a time generating our csv data. From there we return our response object which causes the browser to download the csv file of data.

Example Implementation

A quick and dirty example of how to do this is quite simple. All you have to do is attach this to a url pattern, and you are good to go.

class DataView(CSVResponseMixin, View):

    def get(self, request, *args, **kwargs):
        data = (('hello', 'world'), ('foo', 'bar'))
        return self.render_to_csv(data)

The telling thing about this example is we are using the View class as our base class so it isn't some fancy generic class based view. This gives it simplicity people are after with function based views, but is more understandable and testable.

Conclusion

Just like with LastAccessMixin we are leveraging good OOP practice to give us generic functionality we want to use. This one gives us a standard way to export data as a csv file in a consistent way. If you want to use this mixin plus many other useful ones checkout django-braces. They currently have a lot of good ones, and this one will be coming in a future release.

Better Models Through Custom Managers and QuerySets

Mon, 17 Mar 2014 15:00:00 +0000

Learn what it takes to get common queries chain-able, and slimmer. This video goes over custom model managers and custom querysets so you can write better code, cleaner, code by harnessing the power of Django and OOP.
Watch Now...

Record Last Access Not Just Last Login

Fri, 07 Mar 2014 21:30:00 +0000

Knowing when a person last logged in is great, except when it isn't. Sometimes you want to know when a user last actually used your app. Since you can stay continually logged in to Django sites we need an alternative way to know when a person was last on your site.

If you are using class based views, and you should, then writing a mixin is a good way to go.

LastAccessMixin

from django.utils import timezone

class LastAccessMixin(object):
    def dispatch(self, request, *args, **kwargs):
        if request.user.is_authenticated():
            request.user.accessdata.last_access = timezone.now()
            request.user.accessdata.save(update_fields=['last_access'])
        return super(LastAccessMixin, self).dispatch(request, *args, **kwargs)

What Does this Code Do?

The first place class based views go is to the disatch method. This "dispatches" the request to the proper place. It determines what type of a request it is be it a GET, POST, HEAD etc. From there it goes to the appropriate method.

def dispatch(self, request, *args, **kwargs):

We are overriding the dispatch method because it is always called, and only once. We also want to use the dispatch method instead of say get because on some urls we might use a post method, then we wouldn't know the page was used.

if request.user.is_authenticated():
    request.user.accessdata.last_access = timezone.now()
    request.user.accessdata.save(update_fields=['last_access'])

In the method, before it routes away, we are wanting to record the user accessed the page. So we are simply updating a model attached to the user model with the current time, then saving it. Nothing too complicated.

return super(LastAccessMixin, self).dispatch(request, *args, **kwargs)

Since we are done recording that the user hit a page we can call the rest of the dispatch so the request continues on properly.

Using LastAccessMixin

The best way to use this mixin is to include it in the declaration of your class based view similar to below:

from django.views.generic import TemplateView
from home.mixins import LastAccessMixin

class IndexView(LastAccessMixin, TemplateView):
    template_name = 'home/index.html'

Now when a user visits the index page, and they are logged in, the time is logged. You can add this mixin to any class based view, and you are set.

Closing Thoughts

This is a quick implementation of this functionality. The mixin can be expanded to be much more robust, and universal. However, this is a good demonstration of the power of mixins, and an easy way to solve what could have been a complex problem.

As a final note since all we want to really know is that users are using the site it is, probably, recommended to choose a few specific views to use this with, and not every single view.

I would be curious if you know of other ways to accomplish this.

Compile and Compress Assets with django-pipeline

Sat, 01 Mar 2014 21:00:00 +0000

Using things like CoffeeScript, Stylus, Less, SASS/SCSS, etc... Is becoming a more and more core part of development, but the problem usually is compiling these assets for use on our site. With django-pipeline this process is now much easier in both development and production. Learn the few easy steps it takes to get started with it.
Watch Now...

django-storages and AmazonS3

Mon, 03 Feb 2014 16:00:00 +0000

Saving files in the cloud, be it Amazon S3, Azure, or Rackspace, is very common now and almost a requirement. django-storages makes this seemless. This video shows you just how easy it is to get started.
Watch Now...

ViewSets and Routers - django-rest-framework part 3

Mon, 20 Jan 2014 16:00:00 +0000

ViewSets and Routers are very useful for slimming up your code and providing a lot of default functionality out of the box. They are powerful features in django-rest-framework allowing a lot of flexibility in your code while keeping things clean.
Watch Now...

Permissions & Authentication - django-rest-framework part 2

Sun, 05 Jan 2014 00:00:00 +0000

Learn how to use basic authentication with your new API, and setup custom permissions to get fine grained precision of what can be done with data.
Watch Now...

Start Your API - django-rest-framework part 1

Mon, 16 Dec 2013 16:00:00 +0000

In this video we start creating our API by learning what it takes to put data in our database, and retrieve it back doing all of our CRUD operations. django-rest-framework makes it very simple to accomplish with a minimal amount of effort.
Watch Now...

Be More Productive with django_extensions

Thu, 28 Nov 2013 16:00:00 +0000

Django provides a lot of really useful things by default, but there are a few things we do over and over again. Learn how django extensions help solve some of these, and enhances your ability to do others with this intro to django-extensions. We will show a few of the many many useful things it can do.
Watch Now...

Transform Images with django-imagekit

Sat, 16 Nov 2013 16:00:00 +0000

In this video we will walk through a couple of easy ways to transform images as you need them. django-imagekit makes this fairly simple and straight forward. This video provides an introduction to using it.
Watch Now...

Upload Files

Wed, 30 Oct 2013 15:00:00 +0000

Learn how to use Django to let your users upload files. This uses only what is built into Django to get you started.
Watch Now...

Tagging with django-taggit

Wed, 09 Oct 2013 15:00:00 +0000

In this video you will learn an easy way to add tags to your models, and on your site. Tags can be hard if you try to implement them yourself, so don't try and just use this library from the start.
Watch Now...

django-waffle

Wed, 25 Sep 2013 15:00:00 +0000

Learn how to use this popular feature flipper for helping you to develop and test new features live instead of only in development.
Watch Now...

crispy-forms

Tue, 10 Sep 2013 15:00:00 +0000

Learn how to get started using the popular crispy forms django application to streamline rendering your templates by doing your layout in python.
Watch Now...

Activity Feed with Event Log

Tue, 27 Aug 2013 15:00:00 +0000

Adding an activity feed is simple with the eventlog application. I show you how to get started with it by easily adding it to your project, and how use and administer it.
Watch Now...

Travis-CI and Coveralls

Thu, 25 Jul 2013 03:00:00 +0000

Continuous Integration and Code Coverage used to be hard. Now with Travis-CI and Coveralls life just got a lot easier, especially for open source projects. In this video we will go over setting up travis and coveralls for django applications.
Watch Now...

Robots and Sitemaps

Mon, 08 Jul 2013 14:00:00 +0000

Dealing with google site indexing from google and other search engines can be a pain, but fortunately django makes it easy with django.contrib.sitemaps and the django-robots app. In this video learn to create sitemap.xml and robots.txt quickly and easily.
Watch Now...

Starting Jinja2

Sun, 23 Jun 2013 03:30:00 +0000

Jinja2 is a great templating language based on Django's templating engine. It has some great features, and is more performant. This video shows you how to get started with it in your projects today.
Watch Now...

Using Templates for Sending Emails

Wed, 05 Jun 2013 19:00:00 +0000

Sending nice pretty emails en-mass, or at regular intervals requires work so they look good. Fortunately Django's templates offers a great way to email uniform looking emails to your users. This video shows you how to do it, and keep it simple.
Watch Now...

Basic Ajax

Thu, 30 May 2013 03:00:00 +0000

Ajax is essential these days, and fortunately Django provides some good mechanism for doing AJAX well. This video goes over some of the basics you need to do and know when doing AJAX in Django.
Watch Now...

Class Based Views Part 3: DetailView and template_name Shortcut

Tue, 24 Apr 2012 20:00:00 +0000

The DetailView is an important class based view since it allows us to show off details of our data instead of just bits here and there. It is also very simple to use and will save you time. In this video you are also going to see a nice little shortcut with your templates to save you from writing a couple of extra lines.
Watch Now...

Class Based Views Part 2: ListView and FormView

Tue, 17 Apr 2012 22:32:53 +0000

The ListView and FormView class based generic views are the first look we have at generic views with some power behind them which can really save us some code. The ListView is great for showing content and paginating said content with very little effort. While the FormView is great for dealing with class based forms without having to deal, to much, with the underlying request itself.
Watch Now...

Class Based Views Part 1: TemplateView and RedirectView

Wed, 04 Apr 2012 20:45:00 +0000

This is the first episode in a series of videos on Class Based generic Views. These are important to learn since the function based generic views are being deprecated, and Class Based generic Views will help to streamline things moving forward when dealing with views. This video goes over the most basic views, TemplateView and RedirectView. The video uses simple scenarios, but usable, to get you started.
Watch Now...

Using django.contrib.markup

Tue, 27 Mar 2012 21:00:00 +0000

Having your users input data and outputting it in ways other than straight plain text can be complicated. However, using different markup languages like markdown can make things easier for you the developer and your users. This video goes over how to use markdown, textile and restructured text built right into Django.
Watch Now...

django-social-auth 101

Tue, 20 Mar 2012 22:30:00 +0000

Django-social-auth is probably the best, at the very least one of the best, Django applications for handling 3rd party authentication systems. It can handle everything from github, twitter, facebook to open-id and browser-id. It is very flexible and easy to setup. This video will show you how to setup it up to work with github and get you started using django-social-auth.
Watch Now...

Pagination

Thu, 15 Mar 2012 00:00:00 +0000

When you have a lot of data to sift through pagination is one of the best ways we have to visually breakup data so it is not as daunting. In this video we will use the Paginator built right into Django. It is much simpler than it sounds like it might be.
Watch Now...

Browser ID

Tue, 21 Feb 2012 20:30:00 +0000

Browser ID is Mozillas new federated authentication system. This screencast walks you through using the django-browserid package to do your authentication, and attach it to the built in Django auth system
Watch Now...

Forms Part 5: Basic Form Validation

Tue, 14 Feb 2012 21:45:00 +0000

Forms are a big subject in Django. We have run through a lot when it comes to forms. We are concluding our series with Form Validation. This simple video will finalize everything we have done so far by allowing us to give feedback to our users when our form validation goes wrong.
Watch Now...

Forms Part 4: Formsets

Tue, 31 Jan 2012 21:00:00 +0000

Formsets make life easier when it comes to dealing with multiple forms of the same type on the same page. In this episode we will show you how to set them up, and the basics of how to save that data to the database. It is not much different from dealing with single forms.
Watch Now...

Forms Part 3: Model Based Forms

Tue, 24 Jan 2012 22:30:00 +0000

Model forms really helps to show the power behind Django. When all it takes is to define a model and then attach the model object to a form object and poof you have a form, I call that winning. In this video we will go over using your models you already have to create forms to save you time, heartache, and code.
Watch Now...

Forms Part 2: Class Based Forms

Tue, 17 Jan 2012 20:00:00 +0000

Forms are generally annoying to deal with. Fortunately Django offers some great ways to work with forms to make your life easier. In this our second part on forms we walk you through Class Based Forms in Django on our way to understanding the breadth of what you can do with forms in Django.
Watch Now...

Forms Part 1: Raw Forms

Tue, 20 Dec 2011 01:37:51 +0000

Forms are generally a pain to deal with when doing sites. This is the first video in a series to help make forms in django easier to do and understand. We start with doing raw forms and not using any of the django helpers so we can understand what the helpers are doing in the future.
Watch Now...

RSS With the Syndication Framework

Mon, 12 Dec 2011 21:50:26 +0000

Getting our data out to others is very important with a world full of data. RSS is one of the best ways to do this, still. We go over how to create an RSS feed for your content as we continue to build out our demo blog. It is so simple it should be illegal, check it out.
Watch Now...

Deploying Django to Heroku

Mon, 05 Dec 2011 13:00:00 +0000

Heroku makes life easier for those web developers that just want to deploy our code and it work. In this screencast we walk you through creating a heroku app, deploying your actual code, and running south migrations. This will make development and deployment easier for everyone.
Watch Now...

Introduction to South Migrations

Mon, 28 Nov 2011 13:00:00 +0000

South Migrations are becoming the de-facto standard for those that need to use migrations in Django. They are also very useful as well. This video is an introduction to using south migrations in your projects whether starting a new application or adding it to an existing one.
Watch Now...

Adding CoffeeScript

Mon, 21 Nov 2011 23:18:12 +0000

With CoffeeScript becoming more and more popular it is time to start using it. This video is about how to get CoffeeScript added to your project so you can start developing with it.
Watch Now...

Getting Started with VirtualEnv

Fri, 18 Nov 2011 07:13:07 +0000

VirtualEnv is a great tool to allow you to create multiple distinct environments to prevent versioning issues of your dependencies, or to even use different versions of python by default for that environment. This screen cast walks you through the very basics of getting it going, and a bit of how it works.
Watch Now...

GoDjango Screencasts and Tutorials

Django 1.11+ django.contrib.auth Class Based Views - Part 2 - Password Change and Reset

Django 1.11+ django.contrib.auth Class Based Views - Part 1 - Login & Logout

Django 1.11 Release Notes a Reading

Django 1.11 Highlights

How Do I Start Learning Django

You Should do Weird Stuff in Django

Why You Should Pin Your Dependencies by My Mistakes

Different types of testing in Django

5 Reasons to Use Class Based Views

How to Vett Django Apps

How I Deploy Django Day-to-Day

5 Reasons I don't think you should use the django admin

Basics of Webpack

Store Measurements Sanely with django-measurement

Setting up a Honey Pot with django-admin-honeypot

Django with Bash for Windows

Custom python-social-auth Pipeline

Create Cache Bustable Static Files

CSV Files - Read and Create

Django Model Inheritance - Multi-Table Inheritance

Multi Table Inheritance

Getting and Creating Data

How does it work

CustomerTicket object

Conslusion

Django and Angular - Setting up Base Angular App

reverse, lazy and resolve - Django url-resolvers

Django Abstract Base Class - Model Inheritance

Abstract Base Classes

Will it Work with Existing Models?

Conclusion

Installing Wagtail

Understanding *args and **kwargs

Filter Your List of Objects in the Admin

Getting Started with Django Admin

Working with Environment Variables in Python

What Are Environment Variables?

Get Environment Variable with Python:

Running django-admin.py/manage.py with environment variables

Set environment variable in bashrc

Common Places to Set Environment Variables in Production

Conclusion

Django and Python 3 How to Setup pyenv for Multiple Pythons

Frontend Code Strategy with Django

How Frontend Code Works in Django

Three Popular Ways to Write Frontend Code

Everything in the static folder

Third Party Django Library

Front-end Build System

Conclusion

Wrapping Up CycleMento

Adding Maintenance Data pt 1

Saving Data from Strava

Informing Users with django.contrib.messages

Account Control part 1

Custom Django Admin Actions

Project Templates with Cookiecutter

Using Arrow for Better Datetime

The Class Based "View"

Understanding get_absolute_url

Starting with django-allauth

Deferred Tasks and Scheduled Jobs with Celery 3.1, Django 1.7 and Redis

Using Chart.js with Django

The View

The Template

Conclusion

Stripe, Webhooks and dj-stripe

Stripe and Starting dj-stripe

Starting with Stripe.js

Working with JSON and Django

JSON to Dict

Dict to JSON

HttpResponse with JSON

JSONRequestResponseMixin from django-braces

Conclusion

Webhooks, Django, and ngrok

Django 1.7 Migrations - An Introduction

Download CSV files via CSVResponseMixin

There is a Better Way

Running `django-admin.py/manage.py` with environment variables