# settings/local.py 
from .base import *
DEBUG = True

EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'

DATABASES = {
    "default": {
	"ENGINE": "django.db.backends.postgresql_psycopg2",
	"NAME": "twoscoops",
	"USER": "",
	"PASSWORD": "",
	"HOST": 
	"localhost",
	"PORT": "",
	} 
}

INSTALLED_APPS += ("debug_toolbar", )

# settings/dev_pydanny.py 
from .local import *
# Set short cache timeout
CACHE_TIMEOUT = 30

# Top of settings/production.py
import os
SOME_SECRET_KEY = os.environ["SOME_SECRET_KEY"]

# settings/base.py 
import os
# Normally you should not import ANYTHING from Django directly
# into your settings, but ImproperlyConfigured is an exception.
from django.core.exceptions import ImproperlyConfigured .
def get_env_variable(var_name):
    """Get the environment variable or return exception.""" 
    try:
	return os.environ[var_name] 
    except KeyError:
	error_msg = "Set the {} environment variable".format(var_name)
	raise ImproperlyConfigured(erro.r_msg)

SOME_SECRET_KEY = get_env_variable("SOME_SECRET_KEY")

# settings/base.py
import json
# Normally you should not import ANYTHING from Django directly # into your settings, but ImproperlyConfigured is an exception. from django.core.exceptions import ImproperlyConfigured

# JSON-based secrets module

with open("secrets.json") as f:
    secrets = json.loads(f.read())
def get_secret(setting, secrets=secrets):
    """Get the secret variable or return explicit exception."""
    try:
	return secrets[setting] 
    except KeyError:
	error_msg = "Set the {0} environment variable".format(setting) 
	raise ImproperlyConfigured(error_msg)

SECRET_KEY = get_secret("SECRET_KEY")

Django==1.8.0
psycopg2==2.6
djangorestframework==3.1.1

-r base.txt # includes the base.txt requirements file

coverage==3.7.1
django-debug-toolbar==1.3.0

-r base.txt # includes the base.txt requirements file

# At the top of settings/base.py 
from unipath import Path

BASE_DIR = Path(__file__).ancestor(3)
MEDIA_ROOT = BASE_DIR.child("media")
STATIC_ROOT = BASE_DIR.child("static")
STATICFILES_DIRS = (
    BASE_DIR.child("assets"),
)
TEMPLATES = [
    {
	 'BACKEND': 'django.template.backends.django.DjangoTemplates',
	 DIRS = (BASE_DIR.child("templates"),)
     },
]

# At the top of settings/base.py
from os.path import join, abspath, dirname
here = lambda *dirs: join(abspath(dirname(__file__)), *dirs) BASE_DIR = here("..", "..")
root = lambda *dirs: join(abspath(BASE_DIR), *dirs)

# Configuring MEDIA_ROOT
MEDIA_ROOT = root("media")

# Configuring STATIC_ROOT
STATIC_ROOT = root("collected_static")

# Additional locations of static files
STATICFILES_DIRS = (
    root("assets"),
)

# Configuring TEMPLATE_DIRS
TEMPLATES = [
    {
	'BACKEND': 'django.template.backends.django.DjangoTemplates',
	DIRS = (root("templates"),)
    }, 
]

# core/models.py
from django.db import models
class TimeStampedModel(models.Model): 
    """
    An abstract base class model that provides self-
    updating ``created`` and ``modified`` fields.
    """
    created = models.DateTimeField(auto_now_add=True)
    modified = models.DateTimeField(auto_now=True)

    class Meta: 
	abstract = True

# flavors/models.py
from django.db import models
from core.models import TimeStampedModel

class Flavor(TimeStampedModel):
    title = models.CharField(max_length=200)

from django.conf.urls import url
from django.views.generic import DetailView
from tastings.models import Tasting

urlpatterns = [ 
    url(r"ˆ(?P<pk>\d+)/$",
	DetailView.as_view(
	    model=Tasting,
	    template_name="tastings/detail.html"),
	name="detail"),
    url(r"ˆ(?P<pk>\d+)/results/$", 
	DetailView.as_view(
	    model=Tasting,
	    template_name="tastings/results.html"),
	name="results"),
]

# tastings/views.py
from django.views.generic import ListView, DetailView, UpdateView 
from django.core.urlresolvers import reverse
from .models import Tasting 

class TasteListView(ListView):
    model = Tasting
class TasteDetailView(DetailView):
    model = Tasting
class TasteResultsView(TasteDetailView):
    template_name = "tastings/results.html"
class TasteUpdateView(UpdateView): 
    model = Tasting
    def get_success_url(self):
	return reverse("tastings:detail",
	    kwargs={"pk": self.object.pk})

# tastings/urls.py
from django.conf.urls import url
from . import views

urlpatterns = [
    url(
	regex=r"ˆ$", 
	view=views.TasteListView.as_view(), 
	name="list"
    ),
    url(
	regex=r"ˆ(?P<pk>\d+)/$", 
	view=views.TasteDetailView.as_view(), 
	name="detail"
    ), 
    url(
	regex=r"ˆ(?P<pk>\d+)/results/$", 
	view=views.TasteResultsView.as_.view(), 
	name="results"
    ), 
    url(
	regex=r"ˆ(?P<pk>\d+)/update/$", 
	view=views.TasteUpdateView.as_view(), 
	name="update"
    ) 
]

# urls.py at root of project
urlpatterns += [
    url(r'ˆtastings/', include('tastings.urls', namespace='tastings')),
]

# tastings/views.py snippet
class TasteUpdateView(UpdateView):
    model = Tasting
    def get_success_url(self):
	return reverse("tastings:detail", .
	    kwargs={"pk": self.object.pk})

{% extends "base.html" %}
{% block title %}Tastings{% endblock title %}
{% block content %}
<ul>
  {% for taste in tastings %} 
    <li>
      <a href="{% url "tastings:detail" taste.pk %}">{{ taste.title }}</a>
      <small>
	(<a href="{% url "tastings:update" taste.pk %}">update</a>)
      </small>
    </li>
  {% endfor %}
</ul>
{% endblock content %}

# simplest_views.py
from django.http import HttpResponse 
from django.views.generic import View

# The simplest FBV
def simplest_view(request):
    # Business logic goes here 
    return HttpResponse("FBV")

# The simplest CBV
class SimplestView(View):
    def get(self, request, *args, **kwargs):
       # Business logic goes here
       return HttpResponse("CBV")

def ice_cream_store_display(request, store_id): 
    store = get_object_or_404(Store, id=store_id)
    now = timezone.now()
    return render(request, 'melted_ice_cream_report.html', locals())

def ice_cream_store_display(request, store_id):
    return render(request, 'melted_ice_cream_report.html', dict{
	'store': get_object_or_404(Store, id=store_id),
	'now': timezone.now()
    })

# simple decorator template import functools
def decorator(view_func): 
    @functools.wraps(view_func)
    def new_view_func(request, *args, **kwargs):
	# You can modify the request (HttpRequest) object here. 
	response = view_func(request, *args, **kwargs)
	# You can modify the response (HttpResponse) object here. 
	return response
    return new_view_func

# sprinkles/decorators.py 
from functools import wraps
from . import utils

# based off the decorator template from Example 8.5 
def check_sprinkles(view_func):
"""Check if a user can add sprinkles""" 
    @wraps(view_func)
    def new_view_func(request, *args, **kwargs):
	# Act on the request object with utils.can_sprinkle()
	request = utils.can_sprinkle(request)
	# Call the view function
	response = view_func(request, *args, **kwargs)
	# Return the HttpResponse object
	return response 
    return new_view_func

# views.py
from django.shortcuts import get_object_or_404, render
from .decorators import check_sprinkles
from .models import Sprinkle

# Attach the decorator to the view 
@check_sprinkles
def sprinkle_detail(request, pk):
    """Standard detail view"""
    sprinkle = get_object_or_404(Sprinkle, pk=pk)
    return render(request, "sprinkles/sprinkle_detail.html",
	{"sprinkle": sprinkle})

from django.views.generic import TemplateView 

class FreshFruitMixin(object):
    def get_context_data(self, **kwargs): 
	context = super(FreshFruitMixin,
	    . self).get_context_data(**kwargs)
	context["has_fresh_fruit"] = True 
	return context

class FruityFlavorView(FreshFruitMixin, TemplateView): 
    template_name = "fruity_flavor.html"

# flavors/models.py
from django.core.urlresolvers import reverse 
from django.db import models
STATUS = (
    (0, "zero"),
    (1, "one"),
)

class Flavor(models.Model):
    title = models.CharField(max_length=255)
    slug = models.SlugField(unique=True)
    scoops_remaining = models.IntegerField(default=0, choices=STATUS)
    def get_absolute_url(self):
	return reverse("flavors:detail", kwargs={"slug": self.slug})

from django.http import HttpResponse .
from django.shortcuts import get_object_or_404
from django.views.generic import View
from braces.views import LoginRequiredMixin
from .models import Flavor
from .reports import make_flavor_pdf

class PDFFlavorView(LoginRequiredMixin, View): 
    # Get the flavor
    def get(self, request, *args, **kwargs):
	flavor = get_object_or_404(Flavor, slug=kwargs['slug'])
	# create the response
	response = HttpResponse(content_type='application/pdf')
	# generate the PDF stream and attach to the response
	response = make_flavor_pdf(response, flavor)
	return response

import csv import StringIO
from .models import Purchase 

def add_csv_purchases(rows):
    rows = StringIO.StringIO(rows)
    records_added = 0
    # Generate a dict per row, with the first CSV row being the keys 
    for row in csv.DictReader(rows, delimiter=","):
	# DON'T DO THIS: Tossing unvalidated data into your model.
	Purchase.objects.create(**row)
	records_added += 1
    return records_added

import csv import StringIO
from django import forms
from .models import Purchase, Seller 

class PurchaseForm(forms.ModelForm):
    class Meta:
	model = Purchase
    def clean_seller(self):
	seller = self.cleaned_data["seller"] 
	try:
	    Seller.objects.get(name=seller) 
	except Seller.DoesNotExist:
	    msg = "{0} does not exist in purchase #{1}.".format(
		seller,
		self.cleaned_data["purchase_number"]
	    )
	raise forms.ValidationError(msg) return seller

def add_csv_purchases(rows):
    rows = StringIO.StringIO(rows)
    records_added = 0
    errors = []
    # Generate a dict per row, with the first CSV row being the k
    for row in csv.DictReader(rows, delimiter=","):
	# Bind the row data to the PurchaseForm. 
	form = PurchaseForm(row)
	# Check to see if the row data is valid. 
	if form.is_valid():
	    # Row data is valid so save the record.
	    form.save()
	    records_added += 1
	else: 
	    errors.append(form.errors)
    return recordded, errors

from django import forms
from .models import Taster
class TasterForm(forms.ModelForm):
    class Meta:
	model = Taster

    def __init__(self, *args, **kwargs):
	# set the user as an attribute of the form 
	self.user = kwargs.pop('user')
	super(TasterForm, self).__init__(*args, **kwargs)

from django.views.generic import UpdateView 
from braces.views import LoginRequiredMixin
from .forms import TasterForm 
from .models import Taster

class TasterUpdateView(LoginRequiredMixin, UpdateView): 
    model = Taster
    form_class = TasterForm
    success_url = "/someplace/"
    def get_form_kwargs(self):
	"""This method is what injects forms with their keyword arguments.""" 
	# grab the current set of form #kwargs
	kwargs = super(TasterUpdateView, self).get_form_kwargs()
	# Update the kwargs with the user_id
	kwargs['user'] = self.request.user
	return kwargs

from django import forms
class IceCreamReviewForm(forms.Form): 
    # Rest of tester form goes here ...
    def clean(self):
	cleaned_data = super(TasterForm, self).clean()
	flavor = cleaned_data.get("flavor")
	age = cleaned_data.get("age")
	if flavor == 'coffee' and age < 3:
	    # Record errors that will be displayed later. 
	    msg = u"Coffee Ice Cream is not for Babies." 
	    self.add_error('flavor', msg) 
	    self.add_error('age', msg)
	# Always return the full collection of cleaned data. 
	return cleaned_data

# flavors/views.py
from django.views.generic import CreateView, UpdateView
from braces.views import LoginRequiredMixin
from .models import Flavor
class FlavorCreateView(LoginRequiredMixin, CreateView):
    model = Flavor
    fields = ('title', 'slug', 'scoops_remaining')
class FlavorUpdateView(LoginRequiredMixin, UpdateView): 
    model = Flavor
    fields = ('title', 'slug', 'scoops_remaining')

# core/validators.py
from django.core.exceptions import ValidationError
def validate_tasty(value):
    """Raise a ValidationError if the value doesn't start with the word 'Tasty'."""
    if not value.startswith(u"Tasty"): 
	msg = u"Must start with Tasty" 
	raise ValidationError(msg)

# flavors/forms.py
from django import forms
from flavors.models import Flavor

class IceCreamOrderForm(forms.Form):
    """Normally done with forms.ModelForm. But we use forms.Form here
	to demonstrate that these sorts of techniques work on every
	type of form.
    """
    slug = forms.ChoiceField("Flavor")
    toppings = forms.CharField()

    def __init__(self, *args, **kwargs): 
	super(IceCreamOrderForm, self).__init__(*args,
		**kwargs)
	# We dynamically set the choices here rather than
	# in the flavor field definition. Setting them in
	# the field definition means status updates won't
	# be reflected in the form without server restarts.
	self.fields["slug"].choices = [
	    (x.slug, x.title) for x in Flavor.objects.all() 
	]
	# NOTE: We could filter by whether or not a flavor
	#       has any scoops, but this is an example of
	#       how to use clean_slug, not filter().

    def clean_slug(self):
	slug = self.cleaned_data["slug"]
	if Flavor.objects.get(slug=slug).scoops_remaining <= 0:
	    msg = u"Sorry, we are out of that flavor."
	    raise forms.ValidationError(msg) 
	return slug

    def clean(self):
	cleaned_data = super(IceCreamOrderForm, self).clean()
	slug = cleaned_data.get("slug", "")
	toppings = cleaned_data.get("toppings", "")
	# Silly "too much chocolate" validation example
	if u"chocolate" in slug.lower() and \ u"chocolate" in toppings.lower():
	    msg = u"Your order has too much chocolate."
	    raise forms.ValidationError(msg) return cleaned_data

from django.core.urlresolvers import reverse 
from django.db import models

class IceCreamStore(models.Model):
    title = models.CharField(max_length=100) 
    block_address = models.TextField() .
    phone = models.CharField(max_length=20, blank=True) 
    description = models.TextField(blank=True)

    def get_absolute_url(self):
	return reverse("store_detail", kwargs={"pk": self.pk})

# stores/forms.py
from django import forms
from .models import IceCreamStore

class IceCreamStoreUpdateForm(forms.ModelForm):
    # Don't do this! Duplication of the model field!
    phone = forms.CharField(required=True)
    # Don't do this! Duplication of the model field!
    description = forms.TextField(required=True)

    class Meta:
    model = IceCreamStore

# stores/forms.py
from django import forms
from .models import IceCreamStore

class IceCreamStoreCreateForm(forms.ModelForm):
    class Meta:
	model = IceCreamStore
	fields = ("title", "block_address", )

class IceCreamStoreUpdateForm(IceCreamStoreCreateForm):
    def __init__(self, *args, **kwargs): 
	super(IceCreamStoreUpdateForm,
		self).__init__(*args, **kwargs)
	self.fields["phone"].required = True
	self.fields["description"].required = True
    class Meta(IceCreamStoreCreateForm.Meta):
	# show all the fields!
	fields = ("title", "block_address", "phone", "description", )

# stores/views
from django.views.generic import CreateView, UpdateView
from .forms import IceCreamStoreCreateForm 
from .forms import IceCreamStoreUpdateForm 
from .models import IceCreamStore

class IceCreamCreateView(CreateView):
    model = IceCreamStore
    form_class = IceCreamStoreCreateForm

class IceCreamUpdateView(UpdateView): 
    model = IceCreamStore
    form_class = IceCreamStoreUpdateForm

# core/views.py
class TitleSearchMixin(object):

    def get_queryset(self):
	# Fetch the queryset from the parent's get_queryset 
	queryset = super(TitleSearchMixin, self).get_queryset()
	# Get the q GET parameter
	q = self.request.GET.get("q") 
	if q:
	    # return a filtered queryset
	    return queryset.filter(title__icontains=q) 
	# No q is specified so we return queryset 
	return queryset

# add to flavors/views.py
from django.views.generic import ListView
from core.views import TitleSearchMixin 
from .models import Flavor

class FlavorListView(TitleSearchMixin, ListView): 
    model = Flavor

# add to store/views.py
from django.views.generic import ListView
from core.views import TitleSearchMixin 
from .models import Store

class IceCreamStoreListView(TitleSearchMixin, ListView):
    model = Store

# vouchers/models.py
from django.core.urlresolvers import reverse 
from django.db import models
from .managers import VoucherManager

class Voucher(models.Model):
    """Vouchers for free pints of ice c.ream.""" 
    name = models.CharField(max_length=100) 
    email = models.EmailField()
    address = models.TextField()
    birth_date = models.DateField(blank=True) 
    sent = models.BooleanField(default=False) 
    redeemed = models.BooleanField(default=False)
    objects = VoucherManager()

{% extends "base.html" %}

{% load flavors_tags %}

# flavors/models.py
from django.core.urlresolvers import reverse 
from django.db import models

class Flavor(models.Model):
    title = models.CharField(max_length=255)
    slug = models.SlugField(unique=True) 
    scoops_remaining = models.IntegerField(default=0)

    def get_absolute_url(self):
	return reverse("flavors:detail", kwargs={"slug": self.slug})

from rest_framework import serializers
from .models import flavor

class FlavorSerializer(serializers.ModelSerializer):
    class Meta:
	model = flavor
	fields = ('title', 'slug', 'scoops_remaining')

# flavors/views
from rest_framework.generics import ListCreateAPIView
from rest_framework.generics import RetrieveUpdateDestroyAPIView 
from .models import Flavor
from .serializers import FlavorSerializer

class FlavorCreateReadView(ListCreateAPIView):
    queryset = Flavor.objects.all()
    serializer_class = FlavorSerializer
    lookup_field = 'slug'

class FlavorReadUpdateDeleteView(RetrieveUpdateDestroyAPIView): 
    queryset = Flavor.objects.all()
    serializer_class = FlavorSerializer
    lookup_field = 'slug'

# flavors/urls.py
from django.conf.urls import url
from flavors import views

urlpatterns = [
    url(
	regex=r"ˆapi/$", 
	view=views.FlavorCreateReadView.as_view(), 
	name="flavor_rest_api"
    ), 
    url(
	regex=r"ˆapi/(?P<slug>[-\w]+)/$",
	view=views.FlavorReadUpdateDeleteView.as_view(),
	name="flavor_rest_api"
    )
]

# core/apiv1_shutdown.py
from django.http import HttpResponseGone

apiv1_gone_msg = """APIv1 was removed on April 2, 2015. Please switch to APIv3:
<ul>
    <li>
	<a href="https://www.example.com/api/v3/">APIv3 Endpoint</a>
    </li> 
    <li>
	<a href="https://example.com/apiv3_docs/">APIv3 Documentation</a>
    </li> 
    <li>
	<a href="http://example.com/apiv1_shutdown/">APIv1 shut down notice</a>
    </li>
</ul> 
"""
def apiv1_gone(request):
    return HttpResponseGone(apiv1_gone_msg)

from django.db import models
from django.utils.encoding import python_2_unicode_compatible

@python_2_unicode_compatible # For Python 3.4 and 2.7 
class IceCreamBar(models.Model):
    name = models.CharField(max_length=100)
    shell = models.CharField(max_length=100)
    filling = models.CharField(max_length=100)
    has_stick = models.BooleanField(default=True)

    def __str__(self): 
	return self.name

from django.contrib import admin
from .models import IceCreamBar

class IceCreamBarAdmin(admin.ModelAdmin):
    list_display = ("name", "shell", "filling",)

admin.site.register(IceCreamBar, IceCreamBarAdmin)

from django.contrib import admin
from django.core.urlresolvers import reverse 
from django.utils.html import format_html
from icecreambars.models import IceCreamBar 

class IceCreamBarAdmin(admin.ModelAdmin):
    list_display = ("name", "shell", "filling",)
    readonly_fields = ("show_url",)

    def show_url(self, instance):
	url = reverse("ice_cream_bar_detail",
		kwargs={"pk": instance.pk})
	response = format_html("""<a href="{0}">{1}</a>""", url, url) 
	return response

    show_url.short_description = "Ice Cream Bar URL"
    # Displays HTML tags
    # Never set allow_tags to True against user submitted data!!!
    show_url.allow_tags = True

admin.site.register(IceCreamBar, IceCreamBarAdmin)

import uuid as uuid_lib
from django.db import models
from django.utils.encoding import python_2_unicode_compatible

@python_2_unicode_compatible
class IceCreamPayment(models.Model):

    uuid = models.UUIDField(
	db_index=True,
	default=uuid_lib.uuid4,
	editable=False)

    def __str__(self): 
	return str(self.pk)

import logging import requests

logger = logging.getLogger(__name__)

def get_additional_data(): 
    try:
	r = requests.get("http://example.com/something-optional/") 
    except requests.HTTPError as e:
	logger.exception(e)
	logger.debug("Could not get additional data", exc_info=True)
	return None 
    return r