moved outside dependencies to virtualenv and dumped some unused apps out of lib

1 files changed, 0 insertions, 240 deletions

diff --git a/app/lib/contact_form/forms.py b/app/lib/contact_form/forms.py
deleted file mode 100644
index dfa9ac8..0000000
--- a/app/lib/contact_form/forms.py
+++ /dev/null
@@ -1,240 +0,0 @@
-"""
-A base contact form for allowing users to send email messages through
-a web interface, and a subclass demonstrating useful functionality.
-
-"""
-
-
-from django import forms
-from django.conf import settings
-from django.core.mail import send_mail
-from django.template import loader, RequestContext
-from django.contrib.sites.models import Site
-
-
-# I put this on all required fields, because it's easier to pick up
-# on them with CSS or JavaScript if they have a class of "required"
-# in the HTML. Your mileage may vary.
-attrs_dict = { 'class': 'required' }
-
-
-class ContactForm(forms.Form):
-    """
-    Base contact form class from which all contact form classes should
-    inherit.
-    
-    If you don't need any custom functionality, you can simply use
-    this form to provide basic contact functionality; it will collect
-    name, email address and message.
-    
-    The ``contact_form`` view included in this application knows how
-    to work with this form and can handle many types of subclasses as
-    well (see below for a discussion of the important points), so in
-    many cases it will be all that you need. If you'd like to use this
-    form or a subclass of it from one of your own views, just do the
-    following:
-    
-        1. When you instantiate the form, pass the current
-           ``HttpRequest`` object to the constructor as the keyword
-           argument ``request``; this is used internally by the base
-           implementation, and also made available so that subclasses
-           can add functionality which relies on inspecting the
-           request.
-           
-        2. To send the message, call the form's ``save`` method, which
-           accepts the keyword argument ``fail_silently`` and defaults
-           it to ``False``. This argument is passed directly to
-           ``send_mail``, and allows you to suppress or raise
-           exceptions as needed for debugging. The ``save`` method has
-           no return value.
-           
-    Other than that, treat it like any other form; validity checks and
-    validated data are handled normally, through the ``is_valid``
-    method and the ``cleaned_data`` dictionary.
-    
-    
-    Base implementation
-    -------------------
-    
-    Under the hood, this form uses a somewhat abstracted interface in
-    order to make it easier to subclass and add functionality. There
-    are several important attributes subclasses may want to look at
-    overriding, all of which will work (in the base implementation) as
-    either plain attributes or as callable methods:
-    
-        * ``from_email`` -- used to get the address to use in the
-          ``From:`` header of the message. The base implementation
-          returns the value of the ``DEFAULT_FROM_EMAIL`` setting.
-          
-        * ``message`` -- used to get the message body as a string. The
-          base implementation renders a template using the form's
-          ``cleaned_data`` dictionary as context.
-          
-        * ``recipient_list`` -- used to generate the list of
-          recipients for the message. The base implementation returns
-          the email addresses specified in the ``MANAGERS`` setting.
-          
-        * ``subject`` -- used to generate the subject line for the
-          message. The base implementation returns the string 'Message
-          sent through the web site', with the name of the current
-          ``Site`` prepended.
-          
-        * ``template_name`` -- used by the base ``message`` method to
-          determine which template to use for rendering the
-          message. Default is ``contact_form/contact_form.txt``.
-          
-    Internally, the base implementation ``_get_message_dict`` method
-    collects ``from_email``, ``message``, ``recipient_list`` and
-    ``subject`` into a dictionary, which the ``save`` method then
-    passes directly to ``send_mail`` as keyword arguments.
-    
-    Particularly important is the ``message`` attribute, with its base
-    implementation as a method which renders a template; because it
-    passes ``cleaned_data`` as the template context, any additional
-    fields added by a subclass will automatically be available in the
-    template. This means that many useful subclasses can get by with
-    just adding a few fields and possibly overriding
-    ``template_name``.
-    
-    Much useful functionality can be achieved in subclasses without
-    having to override much of the above; adding additional validation
-    methods works the same as any other form, and typically only a few
-    items -- ``recipient_list`` and ``subject_line``, for example,
-    need to be overridden to achieve customized behavior.
-    
-    
-    Other notes for subclassing
-    ---------------------------
-    
-    Subclasses which want to inspect the current ``HttpRequest`` to
-    add functionality can access it via the attribute ``request``; the
-    base ``message`` takes advantage of this to use ``RequestContext``
-    when rendering its template. See the ``AkismetContactForm``
-    subclass in this file for an example of using the request to
-    perform additional validation.
-    
-    Subclasses which override ``__init__`` need to accept ``*args``
-    and ``**kwargs``, and pass them via ``super`` in order to ensure
-    proper behavior.
-    
-    Subclasses should be careful if overriding ``_get_message_dict``,
-    since that method **must** return a dictionary suitable for
-    passing directly to ``send_mail`` (unless ``save`` is overridden
-    as well).
-    
-    Overriding ``save`` is relatively safe, though remember that code
-    which uses your form will expect ``save`` to accept the
-    ``fail_silently`` keyword argument. In the base implementation,
-    that argument defaults to ``False``, on the assumption that it's
-    far better to notice errors than to silently not send mail from
-    the contact form (see also the Zen of Python: "Errors should never
-    pass silently, unless explicitly silenced").
-    
-    """
-    def __init__(self, data=None, files=None, request=None, *args, **kwargs):
-        if request is None:
-            raise TypeError("Keyword argument 'request' must be supplied")
-        super(ContactForm, self).__init__(data=data, files=files, *args, **kwargs)
-        self.request = request
-    
-    name = forms.CharField(max_length=100,
-                           widget=forms.TextInput(attrs=attrs_dict),
-                           label=u'Name:')
-    email = forms.EmailField(widget=forms.TextInput(attrs=dict(attrs_dict,
-                                                               maxlength=200)),
-                             label=u'E-mail:')
-    subject_line = forms.CharField(widget=forms.TextInput(attrs=dict(attrs_dict,
-                                                               maxlength=200)),
-                             label=u'Subject:')
-    body = forms.CharField(widget=forms.Textarea(attrs=attrs_dict),
-                              label=u'Message:')
-    
-    def from_email(self):
-        if self.cleaned_data['email']:
-            addy = self.cleaned_data['email']
-        else:
-            addy = settings.DEFAULT_FROM_EMAIL
-        return addy
-    
-    recipient_list = [mail_tuple[1] for mail_tuple in settings.CONTACT]
-
-    subject_template_name = "contact_form/contact_form_subject.txt"
-    
-    template_name = 'contact_form/contact_form.txt'
-
-    _context = None
-    
-    def message(self):
-        """
-        Renders the body of the message to a string.
-        
-        """
-        if callable(self.template_name):
-            template_name = self.template_name()
-        else:
-            template_name = self.template_name
-        return loader.render_to_string(template_name,
-                                       self.get_context())
-    
-    def subject(self):
-        """
-        Renders the subject of the message to a string.
-        
-        """
-        subject = loader.render_to_string(self.subject_template_name,
-                                          self.get_context())
-        return ''.join(subject.splitlines())
-    
-    
-
-        
-        
-    def get_context(self):
-        if not self.is_valid():
-            raise ValueError("Cannot generate Context from invalid contact form")
-        if self._context is None:
-            self._context = RequestContext(self.request,
-                                           dict(self.cleaned_data,
-                                                site=Site.objects.get_current()))
-        return self._context
-    
-    def get_message_dict(self):
-        if not self.is_valid():
-            raise ValueError("Message cannot be sent from invalid contact form")
-        message_dict = {}
-        for message_part in ('from_email', 'message', 'recipient_list', 'subject'):
-            attr = getattr(self, message_part)
-            message_dict[message_part] = callable(attr) and attr() or attr
-        return message_dict
-    
-    def save(self, fail_silently=False):
-        """
-        Builds and sends the email message.
-        
-        """
-        send_mail(fail_silently=fail_silently, **self.get_message_dict())
-
-
-class AkismetContactForm(ContactForm):
-    """
-    Contact form which doesn't add any extra fields, but does add an
-    Akismet spam check to the validation routine.
-    
-    Requires the setting ``AKISMET_API_KEY``, which should be a valid
-    Akismet API key.
-    
-    """
-    def clean_body(self):
-        if 'body' in self.cleaned_data and getattr(settings, 'AKISMET_API_KEY', ''):
-            from akismet import Akismet
-            from django.utils.encoding import smart_str
-            akismet_api = Akismet(key=settings.AKISMET_API_KEY,
-                                  blog_url='http://%s/' % Site.objects.get_current().domain)
-            if akismet_api.verify_key():
-                akismet_data = { 'comment_type': 'comment',
-                                 'referer': self.request.META.get('HTTP_REFERER', ''),
-                                 'user_ip': self.request.META.get('REMOTE_ADDR', ''),
-                                 'user_agent': self.request.META.get('HTTP_USER_AGENT', '') }
-                if akismet_api.comment_check(smart_str(self.cleaned_data['body']), data=akismet_data, build_data=True):
-                    raise forms.ValidationError(u"Akismet thinks this message is spam")
-        return self.cleaned_data['body']