@@ -0,0 +1,2 @@
+#!/bin/bash
+wc posts/* pages/*/*.markdown pages/*/*/*.markdown
@@ -3,7 +3,7 @@ category: page
 slug: django-conf-urls-url-examples
 sortorder: 50001
 toc: False
-sidebartitle: django.conf.urls.url Examples
+sidebartitle: django.conf.urls.url
 meta: Python code examples for the url function within the django.conf.urls module of the Django project. 
 
 
 
@@ -0,0 +1,55 @@
+title: django.core.mail.messages.EmailMessage Examples
+category: page
+slug: django-core-mail-messages-emailmessage-examples
+sortorder: 50007
+toc: False
+sidebartitle: django.core.mail.messages EmailMessage
+meta: Python code examples for the EmailMessage function within the django.core.mail module of the Django project. 
+
+
+# django.core.mail.messages.EmailMessage Examples
+The 
+[EmailMessage](https://github.com/django/django/blob/master/django/core/mail/message.py)
+class is contained with the 
+[django.core.mail](https://github.com/django/django/tree/master/django/core/mail)
+module within the [Django project](/django.html) code base. 
+
+
+## EmailMessage Example 1 from django-emailmessagetemplate
+
+
+```python
+import copy
+
+from django.core.mail import get_connection
+from django.conf import settings
+
+~~from models import EmailMessageTemplate
+
+
+def send_mail(name, related_object=None, context={}, from_email=None,
+              recipient_list=[], fail_silently=False, auth_user=None,
+               auth_password=None, connection=None):
+    """
+    Easy wrapper for sending a single templated message to a recipient list.  
+    The template to use is retrieved from the database based on the name and 
+    related_object (optional) fields.
+    All members of the recipient list will see the other recipients in the 'To' 
+    field.
+    If auth_user is None, the EMAIL_HOST_USER setting is used.
+    If auth_password is None, the EMAIL_HOST_PASSWORD setting is used.
+    """
+
+~~    template = EmailMessageTemplate.objects.get_template(name, related_object)
+
+    connection = connection or get_connection(username=auth_user,
+                                              password=auth_password,
+                                              fail_silently=fail_silently)
+
+~~    template.context=context
+~~    template.from_email=from_email
+~~    template.to=recipient_list
+~~    template.connection=connection
+
+~~    return template.send()
+```
@@ -0,0 +1,58 @@
+title: django.core.mail.send_mail Examples
+category: page
+slug: django-core-mail-send-mail-examples
+sortorder: 50006
+toc: False
+sidebartitle: django.core.mail.send_mail
+meta: Python code examples for the send_mail function within the django.core.mail  module of the Django project. 
+
+
+# django.core.mail.send_mail Examples
+[send_mail](https://github.com/django/django/blob/master/django/core/mail/__init__.py)
+is a function in [Django](/django.html) that can send an email
+using the [EmailMessage](/django-core-mail-messages-emailmessage-examples.html)
+class.
+
+
+## Example 1 from apiserver
+
+
+[**apiserver/apps/accounts/signals.py**](https://github.com/renjith-tring/apiserver/blob/master/apps/accounts/signals.py)
+
+```python
+from django.conf import settings
+from django.template import Context, loader
+~~from django.core.mail import send_mail,EmailMessage
+from django.conf import settings
+from django.core.mail import EmailMultiAlternatives
+from django.template.loader import render_to_string
+from django.utils.html import strip_tags
+from django.template.loader import get_template
+from django.contrib.auth.decorators import login_required
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+from apps.accounts.models import UserProfile, create_api_key
+
+
+from django.db import models
+models.signals.post_save.connect(create_api_key, sender=UserProfile)
+
+@receiver(post_save,sender=UserProfile)                
+def send_contact_mail(sender, created, **kwargs):
+    obj = kwargs['instance']
+    if created:
+        subject = "Thank you for registering with us"
+        to = [obj.email]
+        verification_code = obj.activation_token
+        val =  { 
+                'site_url': settings.SITE_URL,
+                'subject':subject,
+                'verification_code':verification_code,
+                }
+        
+        html_content = render_to_string('mails/registration.html',val)
+        text_content = strip_tags(html_content)
+        from_email = settings.DEFAULT_FROM_EMAIL
+        msg_html = render_to_string('mails/registration.html',val)
+~~        send_mail(subject, None, from_email,to,html_message=msg_html)
+```
@@ -3,7 +3,7 @@ category: page
 slug: django-db-models-model-examples
 sortorder: 50002
 toc: False
-sidebartitle: django.db.models.Model Examples
+sidebartitle: django.db.models.Model
 meta: Python code examples for the Model class within the django.db.models module of the Django project. 
 
 
@@ -14,6 +14,34 @@ class is the superclass for all data stored in [Django](/django.html)
 applications.
 
 
+## Example 1 from django-audit-log
+[django-audit-log](https://github.com/vvangelovski/django-audit-log) is a
+[code library](https://pypi.org/project/django-audit-log/) that tracks 
+changes to [Django](/django.html) models. The source code is available 
+under the 
+[BSD 3 "New" license](https://github.com/vvangelovski/django-audit-log/blob/master/LICENSE.txt).
+
+[**django-audit-log/audit-log/models/__init__.py**](https://github.com/vvangelovski/django-audit-log/blob/master/audit_log/models/__init__.py)
+
+```python
+~~from django.db.models import Model
+from django.utils.translation import ugettext_lazy as _
+from audit_log.models.fields import CreatingUserField, CreatingSessionKeyField, LastUserField, LastSessionKeyField
+
+~~class AuthStampedModel(Model):
+    """
+    An abstract base class model that provides auth and session information
+    fields.
+    """
+    created_by = CreatingUserField(verbose_name = _("created by"), related_name = "created_%(app_label)s_%(class)s_set")
+    created_with_session_key = CreatingSessionKeyField(_("created with session key"))
+    modified_by =  LastUserField(verbose_name = _("modified by"), related_name = "modified_%(app_label)s_%(class)s_set")
+    modified_with_session_key = LastSessionKeyField(_("modified with session key"))
+
+    class Meta:
+        abstract = True
+```
+
 
 ## Example 2 from django-cms
 [django-cms](https://github.com/divio/django-cms)
@@ -114,3 +142,86 @@ class Page(models.Model):
         on_delete=models.CASCADE,
     )
 ```
+
+
+## Example 3 from
+
+## Example 4 from mezzanine
+
+
+[**mezzanine/mezzanine/core/models.py**](https://github.com/stephenmcd/mezzanine/blob/master/mezzanine/core/models.py)
+
+```python
+from __future__ import unicode_literals
+from future.builtins import str
+from future.utils import with_metaclass
+
+from json import loads
+try:
+    from urllib.request import urlopen
+    from urllib.parse import urlencode
+except ImportError:
+    from urllib import urlopen, urlencode
+
+from django.apps import apps
+from django.contrib.contenttypes.fields import GenericForeignKey
+~~from django.db import models
+from django.db.models.base import ModelBase
+from django.template.defaultfilters import truncatewords_html
+from django.utils.encoding import python_2_unicode_compatible
+from django.utils.html import format_html, strip_tags
+from django.utils.timesince import timesince
+from django.utils.timezone import now
+from django.utils.translation import ugettext, ugettext_lazy as _
+
+from mezzanine.conf import settings
+from mezzanine.core.fields import RichTextField, OrderField
+from mezzanine.core.managers import DisplayableManager, CurrentSiteManager
+from mezzanine.generic.fields import KeywordsField
+from mezzanine.utils.html import TagCloser
+from mezzanine.utils.models import base_concrete_model, get_user_model_name
+from mezzanine.utils.sites import current_site_id, current_request
+from mezzanine.utils.urls import admin_url, slugify, unique_slug
+
+
+user_model_name = get_user_model_name()
+
+
+def wrapped_manager(klass):
+    if settings.USE_MODELTRANSLATION:
+        from modeltranslation.manager import MultilingualManager
+
+        class Mgr(MultilingualManager, klass):
+            pass
+        return Mgr()
+    else:
+        return klass()
+
+
+~~class SiteRelated(models.Model):
+    """
+    Abstract model for all things site-related. Adds a foreignkey to
+    Django's ``Site`` model, and filters by site with all querysets.
+    See ``mezzanine.utils.sites.current_site_id`` for implementation
+    details.
+    """
+
+    objects = wrapped_manager(CurrentSiteManager)
+
+    class Meta:
+        abstract = True
+
+~~    site = models.ForeignKey("sites.Site", on_delete=models.CASCADE,
+~~        editable=False)
+
+    def save(self, update_site=False, *args, **kwargs):
+        """
+        Set the site to the current site when the record is first
+        created, or the ``update_site`` argument is explicitly set
+        to ``True``.
+        """
+        if update_site or (self.id is None and self.site_id is None):
+            self.site_id = current_site_id()
+        super(SiteRelated, self).save(*args, **kwargs)
+```
+
@@ -0,0 +1,115 @@
+title: django.db.models.signal Examples
+category: page
+slug: django-db-models-signal-examples
+sortorder: 50005
+toc: False
+sidebartitle: django.db.models.signal
+meta: Python code examples for database signals within a Django project. 
+
+
+# django.db.models.signal Examples
+The 
+[Signal](https://github.com/django/django/blob/master/django/db/models/signals.py)
+module allows certain senders to notify a set of receivers that some action 
+has taken place across [Django](/django.html) apps within the same project.
+
+
+## Example 1 from django-haystack
+[django-haystack](https://github.com/django-haystack/django-haystack)
+([project website](http://haystacksearch.org/)) is a Python library
+for creating search indexes and queries that abstracts the underlying
+search engine implementation from your code.
+
+[**django-haystack/haystack/signals.py**](https://github.com/django-haystack/django-haystack/blob/master/haystack/signals.py)
+
+```python
+# encoding: utf-8
+
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+~~from django.db import models
+
+from haystack.exceptions import NotHandled
+
+
+class BaseSignalProcessor(object):
+    """
+    A convenient way to attach Haystack to Django's signals & cause things to
+    index.
+    By default, does nothing with signals but provides underlying functionality.
+    """
+
+    def __init__(self, connections, connection_router):
+        self.connections = connections
+        self.connection_router = connection_router
+        self.setup()
+
+    def setup(self):
+        """
+        A hook for setting up anything necessary for
+        ``handle_save/handle_delete`` to be executed.
+        Default behavior is to do nothing (``pass``).
+        """
+        # Do nothing.
+        pass
+
+    def teardown(self):
+        """
+        A hook for tearing down anything necessary for
+        ``handle_save/handle_delete`` to no longer be executed.
+        Default behavior is to do nothing (``pass``).
+        """
+        # Do nothing.
+        pass
+
+    def handle_save(self, sender, instance, **kwargs):
+        """
+        Given an individual model instance, determine which backends the
+        update should be sent to & update the object on those backends.
+        """
+        using_backends = self.connection_router.for_write(instance=instance)
+
+        for using in using_backends:
+            try:
+                index = self.connections[using].get_unified_index().get_index(sender)
+                index.update_object(instance, using=using)
+            except NotHandled:
+                # TODO: Maybe log it or let the exception bubble?
+                pass
+
+    def handle_delete(self, sender, instance, **kwargs):
+        """
+        Given an individual model instance, determine which backends the
+        delete should be sent to & delete the object on those backends.
+        """
+        using_backends = self.connection_router.for_write(instance=instance)
+
+        for using in using_backends:
+            try:
+                index = self.connections[using].get_unified_index().get_index(sender)
+                index.remove_object(instance, using=using)
+            except NotHandled:
+                # TODO: Maybe log it or let the exception bubble?
+                pass
+
+
+class RealtimeSignalProcessor(BaseSignalProcessor):
+    """
+    Allows for observing when saves/deletes fire & automatically updates the
+    search engine appropriately.
+    """
+
+    def setup(self):
+        # Naive (listen to all model saves).
+~~        models.signals.post_save.connect(self.handle_save)
+~~        models.signals.post_delete.connect(self.handle_delete)
+        # Efficient would be going through all backends & collecting all models
+        # being used, then hooking up signals only for those.
+
+    def teardown(self):
+        # Naive (listen to all model saves).
+~~        models.signals.post_save.disconnect(self.handle_save)
+~~        models.signals.post_delete.disconnect(self.handle_delete)
+        # Efficient would be going through all backends & collecting all models
+        # being used, then disconnecting signals only for those.
+```
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+#!/bin/bash`
	`2`	`+wc posts/* pages//.markdown pages///*.markdown`