Add oauth

+# DropBox Project using AWS, Khuloud
+
+### 경희대학교 Cloud Computing A조
+
+## 팀원
+
+- 2017110267 강연욱
+
+- 2017103972 김성연
+
+- 2017100907 유정수
+
+- 2017104025 정수연
+
+- 2016104173 최재혁
+
+## 기술 Stack
+1. Frontend: nuxt, vuetify
+2. Backend : Django
+3. Database: DynamoDB
+4. A W S   : EC2, S3
+
+## 향후 일정
\ No newline at end of file

+# This file must be used with "source bin/activate" *from bash*
+# you cannot run it directly
+
+deactivate () {
+    # reset old environment variables
+    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
+        PATH="${_OLD_VIRTUAL_PATH:-}"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
+        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # This should detect bash and zsh, which have a hash command that must
+    # be called to get it to forget past commands.  Without forgetting
+    # past commands the $PATH changes we made may not be respected
+    if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
+        hash -r
+    fi
+
+    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
+        PS1="${_OLD_VIRTUAL_PS1:-}"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    if [ ! "${1:-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+VIRTUAL_ENV="/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env"
+export VIRTUAL_ENV
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/bin:$PATH"
+export PATH
+
+# unset PYTHONHOME if set
+# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
+# could use `if (set -u; : $PYTHONHOME) ;` in bash
+if [ -n "${PYTHONHOME:-}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1:-}"
+    if [ "x(env) " != x ] ; then
+	PS1="(env) ${PS1:-}"
+    else
+    if [ "`basename \"$VIRTUAL_ENV\"`" = "__" ] ; then
+        # special case for Aspen magic directories
+        # see http://www.zetadev.com/software/aspen/
+        PS1="[`basename \`dirname \"$VIRTUAL_ENV\"\``] $PS1"
+    else
+        PS1="(`basename \"$VIRTUAL_ENV\"`)$PS1"
+    fi
+    fi
+    export PS1
+fi
+
+# This should detect bash and zsh, which have a hash command that must
+# be called to get it to forget past commands.  Without forgetting
+# past commands the $PATH changes we made may not be respected
+if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
+    hash -r
+fi

+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+# Created by Davide Di Blasi <davidedb@gmail.com>.
+# Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; test "\!:*" != "nondestructive" && unalias deactivate'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV "/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env"
+
+set _OLD_VIRTUAL_PATH="$PATH"
+setenv PATH "$VIRTUAL_ENV/bin:$PATH"
+
+
+set _OLD_VIRTUAL_PROMPT="$prompt"
+
+if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
+    if ("env" != "") then
+        set env_name = "env"
+    else
+        if (`basename "VIRTUAL_ENV"` == "__") then
+            # special case for Aspen magic directories
+            # see http://www.zetadev.com/software/aspen/
+            set env_name = `basename \`dirname "$VIRTUAL_ENV"\``
+        else
+            set env_name = `basename "$VIRTUAL_ENV"`
+        endif
+    endif
+    set prompt = "[$env_name] $prompt"
+    unset env_name
+endif
+
+alias pydoc python -m pydoc
+
+rehash

+# This file must be used with ". bin/activate.fish" *from fish* (http://fishshell.org)
+# you cannot run it directly
+
+function deactivate  -d "Exit virtualenv and return to normal shell environment"
+    # reset old environment variables
+    if test -n "$_OLD_VIRTUAL_PATH"
+        set -gx PATH $_OLD_VIRTUAL_PATH
+        set -e _OLD_VIRTUAL_PATH
+    end
+    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
+        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
+        set -e _OLD_VIRTUAL_PYTHONHOME
+    end
+
+    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
+        functions -e fish_prompt
+        set -e _OLD_FISH_PROMPT_OVERRIDE
+        functions -c _old_fish_prompt fish_prompt
+        functions -e _old_fish_prompt
+    end
+
+    set -e VIRTUAL_ENV
+    if test "$argv[1]" != "nondestructive"
+        # Self destruct!
+        functions -e deactivate
+    end
+end
+
+# unset irrelevant variables
+deactivate nondestructive
+
+set -gx VIRTUAL_ENV "/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env"
+
+set -gx _OLD_VIRTUAL_PATH $PATH
+set -gx PATH "$VIRTUAL_ENV/bin" $PATH
+
+# unset PYTHONHOME if set
+if set -q PYTHONHOME
+    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
+    set -e PYTHONHOME
+end
+
+if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
+    # fish uses a function instead of an env var to generate the prompt.
+
+    # save the current fish_prompt function as the function _old_fish_prompt
+    functions -c fish_prompt _old_fish_prompt
+
+    # with the original prompt function renamed, we can override with our own.
+    function fish_prompt
+        # Save the return status of the last command
+        set -l old_status $status
+
+        # Prompt override?
+        if test -n "(env) "
+            printf "%s%s" "(env) " (set_color normal)
+        else
+            # ...Otherwise, prepend env
+            set -l _checkbase (basename "$VIRTUAL_ENV")
+            if test $_checkbase = "__"
+                # special case for Aspen magic directories
+                # see http://www.zetadev.com/software/aspen/
+                printf "%s[%s]%s " (set_color -b blue white) (basename (dirname "$VIRTUAL_ENV")) (set_color normal)
+            else
+                printf "%s(%s)%s" (set_color -b blue white) (basename "$VIRTUAL_ENV") (set_color normal)
+            end
+        end
+
+        # Restore the return status of the previous command.
+        echo "exit $old_status" | .
+        _old_fish_prompt
+    end
+
+    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
+end

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from chardet.cli.chardetect import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from django.core.management import execute_from_command_line
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(execute_from_command_line())

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+from django.core import management
+
+if __name__ == "__main__":
+    management.execute_from_command_line()

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from setuptools.command.easy_install import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from setuptools.command.easy_install import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+
+import sys
+import json
+import argparse
+from pprint import pformat
+
+import jmespath
+from jmespath import exceptions
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('expression')
+    parser.add_argument('-f', '--filename',
+                        help=('The filename containing the input data.  '
+                              'If a filename is not given then data is '
+                              'read from stdin.'))
+    parser.add_argument('--ast', action='store_true',
+                        help=('Pretty print the AST, do not search the data.'))
+    args = parser.parse_args()
+    expression = args.expression
+    if args.ast:
+        # Only print the AST
+        expression = jmespath.compile(args.expression)
+        sys.stdout.write(pformat(expression.parsed))
+        sys.stdout.write('\n')
+        return 0
+    if args.filename:
+        with open(args.filename, 'r') as f:
+            data = json.load(f)
+    else:
+        data = sys.stdin.read()
+        data = json.loads(data)
+    try:
+        sys.stdout.write(json.dumps(
+            jmespath.search(expression, data), indent=4, ensure_ascii=False))
+        sys.stdout.write('\n')
+    except exceptions.ArityError as e:
+        sys.stderr.write("invalid-arity: %s\n" % e)
+        return 1
+    except exceptions.JMESPathTypeError as e:
+        sys.stderr.write("invalid-type: %s\n" % e)
+        return 1
+    except exceptions.UnknownFunctionError as e:
+        sys.stderr.write("unknown-function: %s\n" % e)
+        return 1
+    except exceptions.ParseError as e:
+        sys.stderr.write("syntax-error: %s\n" % e)
+        return 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from pip._internal import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from pip._internal import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from pip._internal import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

+python3
\ No newline at end of file

+/Users/noblyan/opt/anaconda3/bin/python3
\ No newline at end of file

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+
+# $Id: rst2html.py 4564 2006-05-21 20:44:42Z wiemann $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing HTML.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+
+description = ('Generates (X)HTML documents from standalone reStructuredText '
+               'sources.  ' + default_description)
+
+publish_cmdline(writer_name='html', description=description)

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+
+# $Id: rst2html4.py 7994 2016-12-10 17:41:45Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing (X)HTML.
+
+The output conforms to XHTML 1.0 transitional
+and almost to HTML 4.01 transitional (except for closing empty tags).
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+
+description = ('Generates (X)HTML documents from standalone reStructuredText '
+               'sources.  ' + default_description)
+
+publish_cmdline(writer_name='html4', description=description)

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+# -*- coding: utf8 -*-
+# :Copyright: © 2015 Günter Milde.
+# :License: Released under the terms of the `2-Clause BSD license`_, in short:
+#
+#    Copying and distribution of this file, with or without modification,
+#    are permitted in any medium without royalty provided the copyright
+#    notice and this notice are preserved.
+#    This file is offered as-is, without any warranty.
+#
+# .. _2-Clause BSD license: http://www.spdx.org/licenses/BSD-2-Clause
+#
+# Revision: $Revision: 7847 $
+# Date: $Date: 2015-03-17 18:30:47 +0100 (Di, 17. Mär 2015) $
+
+"""
+A minimal front end to the Docutils Publisher, producing HTML 5 documents.
+
+The output also conforms to XHTML 1.0 transitional
+(except for the doctype declaration).
+"""
+
+try:
+    import locale # module missing in Jython
+    locale.setlocale(locale.LC_ALL, '')
+except locale.Error:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+description = (u'Generates HTML 5 documents from standalone '
+               u'reStructuredText sources '
+               + default_description)
+
+publish_cmdline(writer_name='html5', description=description)

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+
+# $Id: rst2latex.py 5905 2009-04-16 12:04:49Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing LaTeX.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline
+
+description = ('Generates LaTeX documents from standalone reStructuredText '
+               'sources. '
+               'Reads from <source> (default is stdin) and writes to '
+               '<destination> (default is stdout).  See '
+               '<http://docutils.sourceforge.net/docs/user/latex.html> for '
+               'the full reference.')
+
+publish_cmdline(writer_name='latex', description=description)

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+
+# Author: 
+# Contact: grubert@users.sf.net
+# Copyright: This module has been placed in the public domain.
+
+"""
+man.py
+======
+
+This module provides a simple command line interface that uses the
+man page writer to output from ReStructuredText source.
+"""
+
+import locale
+try:
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+from docutils.writers import manpage
+
+description = ("Generates plain unix manual documents.  " + default_description)
+
+publish_cmdline(writer=manpage.Writer(), description=description)

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+
+# $Id: rst2odt.py 5839 2009-01-07 19:09:28Z dkuhlman $
+# Author: Dave Kuhlman <dkuhlman@rexx.com>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A front end to the Docutils Publisher, producing OpenOffice documents.
+"""
+
+import sys
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline_to_binary, default_description
+from docutils.writers.odf_odt import Writer, Reader
+
+
+description = ('Generates OpenDocument/OpenOffice/ODF documents from '
+               'standalone reStructuredText sources.  ' + default_description)
+
+
+writer = Writer()
+reader = Reader()
+output = publish_cmdline_to_binary(reader=reader, writer=writer,
+    description=description)
+

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+
+# $Id: rst2odt_prepstyles.py 5839 2009-01-07 19:09:28Z dkuhlman $
+# Author: Dave Kuhlman <dkuhlman@rexx.com>
+# Copyright: This module has been placed in the public domain.
+
+"""
+Fix a word-processor-generated styles.odt for odtwriter use: Drop page size
+specifications from styles.xml in STYLE_FILE.odt.
+"""
+
+#
+# Author: Michael Schutte <michi@uiae.at>
+
+from lxml import etree
+import sys
+import zipfile
+from tempfile import mkstemp
+import shutil
+import os
+
+NAMESPACES = {
+    "style": "urn:oasis:names:tc:opendocument:xmlns:style:1.0",
+    "fo": "urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0"
+}
+
+def prepstyle(filename):
+    
+    zin = zipfile.ZipFile(filename)
+    styles = zin.read("styles.xml")
+    
+    root = etree.fromstring(styles)
+    for el in root.xpath("//style:page-layout-properties", 
+        namespaces=NAMESPACES):
+        for attr in el.attrib:
+            if attr.startswith("{%s}" % NAMESPACES["fo"]):
+                del el.attrib[attr]
+    
+    tempname = mkstemp()
+    zout = zipfile.ZipFile(os.fdopen(tempname[0], "w"), "w",
+        zipfile.ZIP_DEFLATED)
+    
+    for item in zin.infolist():
+        if item.filename == "styles.xml":
+            zout.writestr(item, etree.tostring(root))
+        else:
+            zout.writestr(item, zin.read(item.filename))
+    
+    zout.close()
+    zin.close()
+    shutil.move(tempname[1], filename)
+
+
+def main():
+    args = sys.argv[1:]
+    if len(args) != 1:
+        print >> sys.stderr, __doc__
+        print >> sys.stderr, "Usage: %s STYLE_FILE.odt\n" % sys.argv[0]
+        sys.exit(1)
+    filename = args[0]
+    prepstyle(filename)
+
+if __name__ == '__main__':
+    main()
+
+
+# vim:tw=78:sw=4:sts=4:et:

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+
+# $Id: rst2pseudoxml.py 4564 2006-05-21 20:44:42Z wiemann $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing pseudo-XML.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+
+description = ('Generates pseudo-XML from standalone reStructuredText '
+               'sources (for testing purposes).  ' + default_description)
+
+publish_cmdline(description=description)

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+
+# $Id: rst2s5.py 4564 2006-05-21 20:44:42Z wiemann $
+# Author: Chris Liechti <cliechti@gmx.net>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing HTML slides using
+the S5 template system.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+
+description = ('Generates S5 (X)HTML slideshow documents from standalone '
+               'reStructuredText sources.  ' + default_description)
+
+publish_cmdline(writer_name='s5', description=description)

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+
+# $Id: rst2xetex.py 7847 2015-03-17 17:30:47Z milde $
+# Author: Guenter Milde
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing Lua/XeLaTeX code.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline
+
+description = ('Generates LaTeX documents from standalone reStructuredText '
+               'sources for compilation with the Unicode-aware TeX variants '
+               'XeLaTeX or LuaLaTeX. '
+               'Reads from <source> (default is stdin) and writes to '
+               '<destination> (default is stdout).  See '
+               '<http://docutils.sourceforge.net/docs/user/latex.html> for '
+               'the full reference.')
+
+publish_cmdline(writer_name='xetex', description=description)

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+
+# $Id: rst2xml.py 4564 2006-05-21 20:44:42Z wiemann $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing Docutils XML.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+
+description = ('Generates Docutils-native XML from standalone '
+               'reStructuredText sources.  ' + default_description)
+
+publish_cmdline(writer_name='xml', description=description)

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+
+# $Id: rstpep2html.py 4564 2006-05-21 20:44:42Z wiemann $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing HTML from PEP
+(Python Enhancement Proposal) documents.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+
+description = ('Generates (X)HTML from reStructuredText-format PEP files.  '
+               + default_description)
+
+publish_cmdline(reader_name='pep', writer_name='pep_html',
+                description=description)

+#!/Users/noblyan/Desktop/4_1/클라우드컴퓨팅/A_Team_Khuloud/A_Team_Khuloud/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from sqlparse.__main__ import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

+pip

+Copyright (c) Django Software Foundation and individual contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+
+    3. Neither the name of Django nor the names of its contributors may be used
+       to endorse or promote products derived from this software without
+       specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+Metadata-Version: 2.1
+Name: Django
+Version: 3.0.6
+Summary: A high-level Python Web framework that encourages rapid development and clean, pragmatic design.
+Home-page: https://www.djangoproject.com/
+Author: Django Software Foundation
+Author-email: foundation@djangoproject.com
+License: BSD
+Project-URL: Documentation, https://docs.djangoproject.com/
+Project-URL: Funding, https://www.djangoproject.com/fundraising/
+Project-URL: Source, https://github.com/django/django
+Project-URL: Tracker, https://code.djangoproject.com/
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Internet :: WWW/HTTP :: WSGI
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.6
+Requires-Dist: pytz
+Requires-Dist: sqlparse (>=0.2.2)
+Requires-Dist: asgiref (~=3.2)
+Provides-Extra: argon2
+Requires-Dist: argon2-cffi (>=16.1.0) ; extra == 'argon2'
+Provides-Extra: bcrypt
+Requires-Dist: bcrypt ; extra == 'bcrypt'
+
+======
+Django
+======
+
+Django is a high-level Python Web framework that encourages rapid development
+and clean, pragmatic design. Thanks for checking it out.
+
+All documentation is in the "``docs``" directory and online at
+https://docs.djangoproject.com/en/stable/. If you're just getting started,
+here's how we recommend you read the docs:
+
+* First, read ``docs/intro/install.txt`` for instructions on installing Django.
+
+* Next, work through the tutorials in order (``docs/intro/tutorial01.txt``,
+  ``docs/intro/tutorial02.txt``, etc.).
+
+* If you want to set up an actual deployment server, read
+  ``docs/howto/deployment/index.txt`` for instructions.
+
+* You'll probably want to read through the topical guides (in ``docs/topics``)
+  next; from there you can jump to the HOWTOs (in ``docs/howto``) for specific
+  problems, and check out the reference (``docs/ref``) for gory details.
+
+* See ``docs/README`` for instructions on building an HTML version of the docs.
+
+Docs are updated rigorously. If you find any problems in the docs, or think
+they should be clarified in any way, please take 30 seconds to fill out a
+ticket here: https://code.djangoproject.com/newticket
+
+To get more help:
+
+* Join the ``#django`` channel on irc.freenode.net. Lots of helpful people hang
+  out there. See https://en.wikipedia.org/wiki/Wikipedia:IRC/Tutorial if you're
+  new to IRC.
+
+* Join the django-users mailing list, or read the archives, at
+  https://groups.google.com/group/django-users.
+
+To contribute to Django:
+
+* Check out https://docs.djangoproject.com/en/dev/internals/contributing/ for
+  information about getting involved.
+
+To run Django's test suite:
+
+* Follow the instructions in the "Unit tests" section of
+  ``docs/internals/contributing/writing-code/unit-tests.txt``, published online at
+  https://docs.djangoproject.com/en/dev/internals/contributing/writing-code/unit-tests/#running-the-unit-tests
+
+

+Wheel-Version: 1.0
+Generator: bdist_wheel (0.33.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

+[console_scripts]
+django-admin = django.core.management:execute_from_command_line
+

+django

+r"""
+    _        ___      __    __  .___________. __    __
+ /\| |/\    /   \    |  |  |  | |           ||  |  |  |
+ \ ` ' /   /  ^  \   |  |  |  | `---|  |----`|  |__|  |
+|_     _| /  /_\  \  |  |  |  |     |  |     |   __   |
+ / , . \ /  _____  \ |  `--'  |     |  |     |  |  |  |
+ \/|_|\//__/     \__\ \______/      |__|     |__|  |__|
+
+"""
+
+VERSION = (0, 41, 0, 'final', 0)
+
+__title__ = 'django-allauth'
+__version_info__ = VERSION
+__version__ = '.'.join(map(str, VERSION[:3])) + ('-{}{}'.format(
+    VERSION[3], VERSION[4] or '') if VERSION[3] != 'final' else '')
+__author__ = 'Raymond Penners'
+__license__ = 'MIT'
+__copyright__ = 'Copyright 2010-2019 Raymond Penners and contributors'

+default_app_config = 'allauth.account.apps.AccountConfig'

+from django.contrib import admin
+
+from . import app_settings
+from .adapter import get_adapter
+from .models import EmailAddress, EmailConfirmation
+
+
+class EmailAddressAdmin(admin.ModelAdmin):
+    list_display = ('email', 'user', 'primary', 'verified')
+    list_filter = ('primary', 'verified')
+    search_fields = []
+    raw_id_fields = ('user',)
+
+    def get_search_fields(self, request):
+        base_fields = get_adapter(request).get_user_search_fields()
+        return ['email'] + list(map(lambda a: 'user__' + a, base_fields))
+
+
+class EmailConfirmationAdmin(admin.ModelAdmin):
+    list_display = ('email_address', 'created', 'sent', 'key')
+    list_filter = ('sent',)
+    raw_id_fields = ('email_address',)
+
+
+if not app_settings.EMAIL_CONFIRMATION_HMAC:
+    admin.site.register(EmailConfirmation, EmailConfirmationAdmin)
+admin.site.register(EmailAddress, EmailAddressAdmin)

+from django.apps import AppConfig
+from django.utils.translation import gettext_lazy as _
+
+
+class AccountConfig(AppConfig):
+    name = 'allauth.account'
+    verbose_name = _('Accounts')

+from threading import local
+
+from django.contrib.auth.backends import ModelBackend
+
+from ..utils import get_user_model
+from . import app_settings
+from .app_settings import AuthenticationMethod
+from .utils import filter_users_by_email, filter_users_by_username
+
+
+_stash = local()
+
+
+class AuthenticationBackend(ModelBackend):
+
+    def authenticate(self, request, **credentials):
+        ret = None
+        if app_settings.AUTHENTICATION_METHOD == AuthenticationMethod.EMAIL:
+            ret = self._authenticate_by_email(**credentials)
+        elif app_settings.AUTHENTICATION_METHOD \
+                == AuthenticationMethod.USERNAME_EMAIL:
+            ret = self._authenticate_by_email(**credentials)
+            if not ret:
+                ret = self._authenticate_by_username(**credentials)
+        else:
+            ret = self._authenticate_by_username(**credentials)
+        return ret
+
+    def _authenticate_by_username(self, **credentials):
+        username_field = app_settings.USER_MODEL_USERNAME_FIELD
+        username = credentials.get('username')
+        password = credentials.get('password')
+
+        User = get_user_model()
+
+        if not username_field or username is None or password is None:
+            return None
+        try:
+            # Username query is case insensitive
+            user = filter_users_by_username(username).get()
+            if self._check_password(user, password):
+                return user
+        except User.DoesNotExist:
+            return None
+
+    def _authenticate_by_email(self, **credentials):
+        # Even though allauth will pass along `email`, other apps may
+        # not respect this setting. For example, when using
+        # django-tastypie basic authentication, the login is always
+        # passed as `username`.  So let's play nice with other apps
+        # and use username as fallback
+        email = credentials.get('email', credentials.get('username'))
+        if email:
+            for user in filter_users_by_email(email):
+                if self._check_password(user, credentials["password"]):
+                    return user
+        return None
+
+    def _check_password(self, user, password):
+        ret = user.check_password(password)
+        if ret:
+            ret = self.user_can_authenticate(user)
+            if not ret:
+                self._stash_user(user)
+        return ret
+
+    @classmethod
+    def _stash_user(cls, user):
+        """Now, be aware, the following is quite ugly, let me explain:
+
+        Even if the user credentials match, the authentication can fail because
+        Django's default ModelBackend calls user_can_authenticate(), which
+        checks `is_active`. Now, earlier versions of allauth did not do this
+        and simply returned the user as authenticated, even in case of
+        `is_active=False`. For allauth scope, this does not pose a problem, as
+        these users are properly redirected to an account inactive page.
+
+        This does pose a problem when the allauth backend is used in a
+        different context where allauth is not responsible for the login. Then,
+        by not checking on `user_can_authenticate()` users will allow to become
+        authenticated whereas according to Django logic this should not be
+        allowed.
+
+        In order to preserve the allauth behavior while respecting Django's
+        logic, we stash a user for which the password check succeeded but
+        `user_can_authenticate()` failed. In the allauth authentication logic,
+        we can then unstash this user and proceed pointing the user to the
+        account inactive page.
+        """
+        global _stash
+        ret = getattr(_stash, 'user', None)
+        _stash.user = user
+        return ret
+
+    @classmethod
+    def unstash_authenticated_user(cls):
+        return cls._stash_user(None)

+from django.contrib.auth import REDIRECT_FIELD_NAME
+from django.contrib.auth.decorators import login_required
+from django.shortcuts import render
+
+from .models import EmailAddress
+from .utils import send_email_confirmation
+
+
+def verified_email_required(function=None,
+                            login_url=None,
+                            redirect_field_name=REDIRECT_FIELD_NAME):
+    """
+    Even when email verification is not mandatory during signup, there
+    may be circumstances during which you really want to prevent
+    unverified users to proceed. This decorator ensures the user is
+    authenticated and has a verified email address. If the former is
+    not the case then the behavior is identical to that of the
+    standard `login_required` decorator. If the latter does not hold,
+    email verification mails are automatically resend and the user is
+    presented with a page informing them they needs to verify their email
+    address.
+    """
+    def decorator(view_func):
+        @login_required(redirect_field_name=redirect_field_name,
+                        login_url=login_url)
+        def _wrapped_view(request, *args, **kwargs):
+            if not EmailAddress.objects.filter(user=request.user,
+                                               verified=True).exists():
+                send_email_confirmation(request, request.user)
+                return render(request,
+                              'account/verified_email_required.html')
+            return view_func(request, *args, **kwargs)
+        return _wrapped_view
+
+    if function:
+        return decorator(function)
+    return decorator

+from django.core.management.base import BaseCommand
+from django.db.models import Count
+
+from allauth.account.models import EmailAddress
+from allauth.account.utils import user_email
+from allauth.utils import get_user_model
+
+
+class Command(BaseCommand):
+    def handle(self, *args, **options):
+        for user in self.get_users_with_multiple_primary_email():
+            self.unprimary_extra_primary_emails(user)
+
+    def get_users_with_multiple_primary_email(self):
+        user_pks = []
+        for email_address_dict in EmailAddress.objects.filter(
+                primary=True).values('user').annotate(
+                    Count('user')).filter(user__count__gt=1):
+            user_pks.append(email_address_dict['user'])
+        return get_user_model().objects.filter(pk__in=user_pks)
+
+    def unprimary_extra_primary_emails(self, user):
+        primary_email_addresses = EmailAddress.objects.filter(
+            user=user,
+            primary=True)
+
+        for primary_email_address in primary_email_addresses:
+            if primary_email_address.email == user_email(user):
+                break
+        else:
+            # Didn't find the main email addresses and break the for loop
+            print(
+                "WARNING: Multiple primary without a user.email match for"
+                "user pk %s; (tried: %s, using: %s)") % (
+                    user.pk,
+                    ", ".join([
+                        email_address.email
+                        for email_address
+                        in primary_email_addresses]),
+                    primary_email_address)
+
+        primary_email_addresses.exclude(
+            pk=primary_email_address.pk).update(primary=False)

+from datetime import timedelta
+
+from django.db import models
+from django.db.models import Q
+from django.utils import timezone
+
+from . import app_settings
+
+
+class EmailAddressManager(models.Manager):
+
+    def add_email(self, request, user, email,
+                  confirm=False, signup=False):
+        email_address, created = self.get_or_create(
+            user=user, email__iexact=email, defaults={"email": email}
+        )
+
+        if created and confirm:
+            email_address.send_confirmation(request, signup=signup)
+
+        return email_address
+
+    def get_primary(self, user):
+        try:
+            return self.get(user=user, primary=True)
+        except self.model.DoesNotExist:
+            return None
+
+    def get_users_for(self, email):
+        # this is a list rather than a generator because we probably want to
+        # do a len() on it right away
+        return [address.user for address in self.filter(verified=True,
+                                                        email__iexact=email)]
+
+    def fill_cache_for_user(self, user, addresses):
+        """
+        In a multi-db setup, inserting records and re-reading them later
+        on may result in not being able to find newly inserted
+        records. Therefore, we maintain a cache for the user so that
+        we can avoid database access when we need to re-read..
+        """
+        user._emailaddress_cache = addresses
+
+    def get_for_user(self, user, email):
+        cache_key = '_emailaddress_cache'
+        addresses = getattr(user, cache_key, None)
+        if addresses is None:
+            ret = self.get(user=user,
+                           email__iexact=email)
+            # To avoid additional lookups when e.g.
+            # EmailAddress.set_as_primary() starts touching self.user
+            ret.user = user
+            return ret
+        else:
+            for address in addresses:
+                if address.email.lower() == email.lower():
+                    return address
+            raise self.model.DoesNotExist()
+
+
+class EmailConfirmationManager(models.Manager):
+
+    def all_expired(self):
+        return self.filter(self.expired_q())
+
+    def all_valid(self):
+        return self.exclude(self.expired_q())
+
+    def expired_q(self):
+        sent_threshold = timezone.now() \
+            - timedelta(days=app_settings.EMAIL_CONFIRMATION_EXPIRE_DAYS)
+        return Q(sent__lt=sent_threshold)
+
+    def delete_expired_confirmations(self):
+        self.all_expired().delete()

+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+import django.utils.timezone
+from django.conf import settings
+
+UNIQUE_EMAIL = getattr(settings, 'ACCOUNT_UNIQUE_EMAIL', True)
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='EmailAddress',
+            fields=[
+                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
+                ('email', models.EmailField(unique=UNIQUE_EMAIL, max_length=75, verbose_name='e-mail address')),
+                ('verified', models.BooleanField(default=False, verbose_name='verified')),
+                ('primary', models.BooleanField(default=False, verbose_name='primary')),
+                ('user', models.ForeignKey(verbose_name='user', to=settings.AUTH_USER_MODEL, on_delete=models.CASCADE)),
+            ],
+            options={
+                'verbose_name': 'email address',
+                'verbose_name_plural': 'email addresses',
+            },
+            bases=(models.Model,),
+        ),
+        migrations.CreateModel(
+            name='EmailConfirmation',
+            fields=[
+                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
+                ('created', models.DateTimeField(default=django.utils.timezone.now, verbose_name='created')),
+                ('sent', models.DateTimeField(null=True, verbose_name='sent')),
+                ('key', models.CharField(unique=True, max_length=64, verbose_name='key')),
+                ('email_address', models.ForeignKey(verbose_name='e-mail address', to='account.EmailAddress', on_delete=models.CASCADE)),
+            ],
+            options={
+                'verbose_name': 'email confirmation',
+                'verbose_name_plural': 'email confirmations',
+            },
+            bases=(models.Model,),
+        ),
+    ]
+
+    if not UNIQUE_EMAIL:
+        operations += [
+            migrations.AlterUniqueTogether(
+                name='emailaddress',
+                unique_together=set([('user', 'email')]),
+            ),
+        ]

+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+from django.conf import settings
+
+UNIQUE_EMAIL = getattr(settings, 'ACCOUNT_UNIQUE_EMAIL', True)
+EMAIL_MAX_LENGTH = getattr(settings, 'ACCOUNT_EMAIL_MAX_LENGTH', 254)
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('account', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='emailaddress',
+            name='email',
+            field=models.EmailField(unique=UNIQUE_EMAIL, max_length=EMAIL_MAX_LENGTH, verbose_name='e-mail address'),
+        ),
+    ]
+
+    if not UNIQUE_EMAIL:
+       operations += [
+           migrations.AlterUniqueTogether(
+               name='emailaddress',
+               unique_together=set([('user', 'email')]),
+           ),
+       ]

+from __future__ import unicode_literals
+
+import datetime
+
+from django.core import signing
+from django.db import models, transaction
+from django.utils import timezone
+from django.utils.crypto import get_random_string
+from django.utils.translation import gettext_lazy as _
+
+from .. import app_settings as allauth_app_settings
+from . import app_settings, signals
+from .adapter import get_adapter
+from .managers import EmailAddressManager, EmailConfirmationManager
+from .utils import user_email
+
+
+class EmailAddress(models.Model):
+
+    user = models.ForeignKey(allauth_app_settings.USER_MODEL,
+                             verbose_name=_('user'),
+                             on_delete=models.CASCADE)
+    email = models.EmailField(unique=app_settings.UNIQUE_EMAIL,
+                              max_length=app_settings.EMAIL_MAX_LENGTH,
+                              verbose_name=_('e-mail address'))
+    verified = models.BooleanField(verbose_name=_('verified'), default=False)
+    primary = models.BooleanField(verbose_name=_('primary'), default=False)
+
+    objects = EmailAddressManager()
+
+    class Meta:
+        verbose_name = _("email address")
+        verbose_name_plural = _("email addresses")
+        if not app_settings.UNIQUE_EMAIL:
+            unique_together = [("user", "email")]
+
+    def __str__(self):
+        return self.email
+
+    def set_as_primary(self, conditional=False):
+        old_primary = EmailAddress.objects.get_primary(self.user)
+        if old_primary:
+            if conditional:
+                return False
+            old_primary.primary = False
+            old_primary.save()
+        self.primary = True
+        self.save()
+        user_email(self.user, self.email)
+        self.user.save()
+        return True
+
+    def send_confirmation(self, request=None, signup=False):
+        if app_settings.EMAIL_CONFIRMATION_HMAC:
+            confirmation = EmailConfirmationHMAC(self)
+        else:
+            confirmation = EmailConfirmation.create(self)
+        confirmation.send(request, signup=signup)
+        return confirmation
+
+    def change(self, request, new_email, confirm=True):
+        """
+        Given a new email address, change self and re-confirm.
+        """
+        with transaction.atomic():
+            user_email(self.user, new_email)
+            self.user.save()
+            self.email = new_email
+            self.verified = False
+            self.save()
+            if confirm:
+                self.send_confirmation(request)
+
+
+class EmailConfirmation(models.Model):
+
+    email_address = models.ForeignKey(EmailAddress,
+                                      verbose_name=_('e-mail address'),
+                                      on_delete=models.CASCADE)
+    created = models.DateTimeField(verbose_name=_('created'),
+                                   default=timezone.now)
+    sent = models.DateTimeField(verbose_name=_('sent'), null=True)
+    key = models.CharField(verbose_name=_('key'), max_length=64, unique=True)
+
+    objects = EmailConfirmationManager()
+
+    class Meta:
+        verbose_name = _("email confirmation")
+        verbose_name_plural = _("email confirmations")
+
+    def __str__(self):
+        return "confirmation for %s" % self.email_address
+
+    @classmethod
+    def create(cls, email_address):
+        key = get_random_string(64).lower()
+        return cls._default_manager.create(email_address=email_address,
+                                           key=key)
+
+    def key_expired(self):
+        expiration_date = self.sent \
+            + datetime.timedelta(days=app_settings
+                                 .EMAIL_CONFIRMATION_EXPIRE_DAYS)
+        return expiration_date <= timezone.now()
+    key_expired.boolean = True
+
+    def confirm(self, request):
+        if not self.key_expired() and not self.email_address.verified:
+            email_address = self.email_address
+            get_adapter(request).confirm_email(request, email_address)
+            signals.email_confirmed.send(sender=self.__class__,
+                                         request=request,
+                                         email_address=email_address)
+            return email_address
+
+    def send(self, request=None, signup=False):
+        get_adapter(request).send_confirmation_mail(request, self, signup)
+        self.sent = timezone.now()
+        self.save()
+        signals.email_confirmation_sent.send(sender=self.__class__,
+                                             request=request,
+                                             confirmation=self,
+                                             signup=signup)
+
+
+class EmailConfirmationHMAC:
+
+    def __init__(self, email_address):
+        self.email_address = email_address
+
+    @property
+    def key(self):
+        return signing.dumps(
+            obj=self.email_address.pk,
+            salt=app_settings.SALT)
+
+    @classmethod
+    def from_key(cls, key):
+        try:
+            max_age = (
+                60 * 60 * 24 * app_settings.EMAIL_CONFIRMATION_EXPIRE_DAYS)
+            pk = signing.loads(
+                key,
+                max_age=max_age,
+                salt=app_settings.SALT)
+            ret = EmailConfirmationHMAC(EmailAddress.objects.get(pk=pk))
+        except (signing.SignatureExpired,
+                signing.BadSignature,
+                EmailAddress.DoesNotExist):
+            ret = None
+        return ret
+
+    def confirm(self, request):
+        if not self.email_address.verified:
+            email_address = self.email_address
+            get_adapter(request).confirm_email(request, email_address)
+            signals.email_confirmed.send(sender=self.__class__,
+                                         request=request,
+                                         email_address=email_address)
+            return email_address
+
+    def send(self, request=None, signup=False):
+        get_adapter(request).send_confirmation_mail(request, self, signup)
+        signals.email_confirmation_sent.send(sender=self.__class__,
+                                             request=request,
+                                             confirmation=self,
+                                             signup=signup)

+from django.contrib.auth.signals import user_logged_out  # noqa
+from django.dispatch import Signal
+
+
+user_logged_in = Signal(providing_args=["request", "user"])
+
+# Typically followed by `user_logged_in` (unless, e-mail verification kicks in)
+user_signed_up = Signal(providing_args=["request", "user"])
+
+password_set = Signal(providing_args=["request", "user"])
+password_changed = Signal(providing_args=["request", "user"])
+password_reset = Signal(providing_args=["request", "user"])
+
+email_confirmed = Signal(providing_args=["request", "email_address"])
+email_confirmation_sent = Signal(
+    providing_args=["request", "confirmation", "signup"])
+
+email_changed = Signal(
+    providing_args=[
+        "request", "user",
+        "from_email_address", "to_email_address"])
+email_added = Signal(providing_args=["request", "user", "email_address"])
+email_removed = Signal(providing_args=["request", "user", "email_address"])