Sign in
{% endblock %} Flask-OpenID-1.2.5/example/templates/layout.html 0000664 0001750 0001750 00000001202 12464145144 024145 0 ustar puiterwijk puiterwijk 0000000 0000000Flask OpenID Example
{% for message in get_flashed_messages() %}Edit Profile
{% endblock %} Flask-OpenID-1.2.5/example/templates/index.html 0000664 0001750 0001750 00000000325 12464145144 023744 0 ustar puiterwijk puiterwijk 0000000 0000000 {% extends "layout.html" %} {% block body %}Overview
{% if g.user %}Hello {{ g.user.name }}! {% endif %}
This is just an example page so that something is here. {% endblock %} Flask-OpenID-1.2.5/example/templates/create_profile.html 0000664 0001750 0001750 00000001346 12464145144 025624 0 ustar puiterwijk puiterwijk 0000000 0000000 {% extends "layout.html" %} {% block title %}Create Profile{% endblock %} {% block body %}
Create Profile
Hey! This is the first time you signed in on this website. In order to proceed we need some extra information from you:
If you don't want to proceed, you can sign out again.
{% endblock %}
Flask-OpenID-1.2.5/example/static/ 0000775 0001750 0001750 00000000000 12575547273 021254 5 ustar puiterwijk puiterwijk 0000000 0000000 Flask-OpenID-1.2.5/example/static/style.css 0000664 0001750 0001750 00000001210 12464145144 023104 0 ustar puiterwijk puiterwijk 0000000 0000000 body {
font-family: 'Georgia', serif;
font-size: 16px;
margin: 30px;
padding: 0;
}
a {
color: #335E79;
}
p.message {
color: #335E79;
padding: 10px;
background: #CADEEB;
}
p.error {
color: #783232;
padding: 10px;
background: #EBCACA;
}
input {
font-family: 'Georgia', serif;
font-size: 16px;
border: 1px solid black;
color: #335E79;
padding: 2px;
}
input[type="submit"] {
background: #CADEEB;
color: #335E79;
border-color: #335E79;
}
input[name="openid"] {
background: url(openid.png) 4px no-repeat;
padding-left: 24px;
}
h1, h2 {
font-weight: normal;
}
Flask-OpenID-1.2.5/flask_openid.py 0000664 0001750 0001750 00000054133 12575546334 021345 0 ustar puiterwijk puiterwijk 0000000 0000000 # -* coding: utf-8 -*-
"""
flaskext.openid
~~~~~~~~~~~~~~~
Tiny wrapper around python-openid to make working with the basic
API in a flask application easier. Adapt this code for your own
project if necessary.
:copyright: (c) 2010 by Armin Ronacher.
:license: BSD, see LICENSE for more details.
"""
from __future__ import absolute_import
import os
import pickle
import tempfile
from functools import wraps
from datetime import date
import sys
import base64
from flask import request, session, redirect, current_app, url_for
from werkzeug.urls import url_quote
from openid.store.filestore import FileOpenIDStore
from openid.extensions import ax
from openid.extensions.sreg import SRegRequest, SRegResponse
from openid.consumer.consumer import Consumer, SUCCESS, CANCEL, FAILURE, \
SETUP_NEEDED
from openid.consumer import discover
# python-openid is a really stupid library in that regard, we have
# to disable logging by monkey patching. We still call the original
# implementation if we are in debug mode though.
from openid import oidutil
_original_log = oidutil.log
def _dispatching_log(message, level=None):
app = current_app._get_current_object()
if app is None or app.debug:
return _original_log(message, level)
oidutil.log = _dispatching_log
AX_MAPPING = {
'nickname': ['http://axschema.org/namePerson/friendly',
'http://schema.openid.net/namePerson/friendly'],
'email': ['http://axschema.org/contact/email',
'http://schema.openid.net/contact/email'],
'fullname': ['http://axschema.org/namePerson',
'http://axschema.org/namePerson/first',
'http://axschema.org/namePerson/last',
'http://schema.openid.net/namePerson'],
'dob': ['http://axschema.org/birthDate',
'http://axschema.org/birthDate/birthYear',
'http://axschema.org/birthDate/birthMonth',
'http://schema.openid.net/birthDate'],
'gender': ['http://axschema.org/person/gender',
'http://schema.openid.net/person/gender'],
'postcode': ['http://axschema.org/contact/postalCode/home',
'http://schema.openid.net/contact/postalCode/home'],
'country': ['http://axschema.org/contact/country/home',
'http://schema.openid.net/contact/country/home'],
'language': ['http://axschema.org/pref/language',
'http://schema.openid.net/pref/language'],
'timezone': ['http://axschema.org/pref/timezone',
'http://schema.openid.net/pref/timezone'],
'phone': ['http://axschema.org/contact/phone/default'],
'aim': ['http://axschema.org/contact/IM/AIM'],
'icq': ['http://axschema.org/contact/IM/ICQ'],
'msn': ['http://axschema.org/contact/IM/MSN'],
'yahoo': ['http://axschema.org/contact/IM/Yahoo'],
'jabber': ['http://axschema.org/contact/IM/Jabber'],
'skype': ['http://axschema.org/contact/IM/Skype'],
'website': ['http://axschema.org/contact/web/default',
'http://schema.openid.net/contact/web/default'],
'blog': ['http://axschema.org/contact/web/blog'],
'image': ['http://axschema.org/media/image/default',
'http://schema.openid.net/media/image/default']
}
FULL_NAME_URIS = ['http://axschema.org/namePerson',
'http://schema.openid.net/namePerson']
FULL_DOB_URIS = ['http://axschema.org/birthDate',
'http://schema.openid.net/birthDate']
SREG_KEYS = set(['nickname', 'email', 'fullname', 'dob', 'gender',
'postcode', 'country', 'language', 'timezone'])
# these are required if provided, otherwise google will not return
# the information for the application.
REQUIRED_KEYS = set(['country', 'email', 'fullname', 'language'])
ALL_KEYS = set(AX_MAPPING) | SREG_KEYS
COMMON_PROVIDERS = {
'google': 'https://www.google.com/accounts/o8/id',
'yahoo': 'https://yahoo.com/',
'aol': 'http://aol.com/',
'steam': 'https://steamcommunity.com/openid/'
}
def softint(x):
try:
return int(x)
except (ValueError, TypeError):
return None
def isstring(x):
if sys.version_info[0] >= 3:
return isinstance(x, str)
else:
return isinstance(x, basestring)
class SessionWrapper(object):
name_mapping = {
'_yadis_services__openid_consumer_': 'yoc',
'_openid_consumer_last_token': 'lt'
}
def __init__(self, ext):
self.ext = ext
def __getitem__(self, name):
rv = session[self.name_mapping.get(name, name)]
if isinstance(rv, dict) and len(rv) == 1 and ' p' in rv:
try:
return pickle.loads(base64.b64decode(rv[' p'].encode('utf-8')))
except:
return pickle.loads(rv[' p'])
return rv
def __setitem__(self, name, value):
if not getattr(current_app.session_interface, 'pickle_based', True):
b64 = base64.b64encode(pickle.dumps(value, 0))
value = {' p': b64.decode('utf-8')}
session[self.name_mapping.get(name, name)] = value
def __delitem__(self, name):
del session[self.name_mapping.get(name, name)]
def get(self, name, default=None):
try:
return self[name]
except KeyError:
return default
def __contains__(self, name):
try:
self[name]
return True
except KeyError:
return False
class RegLookup(object):
def __init__(self, resp, extensions):
sreg_resp = SRegResponse.fromSuccessResponse(resp)
self.sreg = sreg_resp and sreg_resp.data or {}
self.ax_resp = ax.FetchResponse.fromSuccessResponse(resp) or {}
# Process the OpenID response with the OpenIDResponse class provided
self.ext = {}
for extension in extensions:
ext_name = getattr(extension, 'ns_alias', extension.__name__)
self.ext[ext_name] = \
extension.fromSuccessResponse(resp)
def get(self, name, default=None):
assert name in ALL_KEYS, 'unknown key %r' % name
rv = self.sreg.get(name)
if rv is not None:
return rv
for uri in AX_MAPPING.get(name, ()):
rv = self.get_uri(uri)
if rv is not None:
return rv
return default
def get_uri(self, uri):
try:
return self.ax_resp.get(uri)[0]
except (TypeError, IndexError, KeyError):
return None
def get_combined(self, sreg_key, ax_uris):
rv = self.sreg.get(sreg_key)
if rv is not None:
return rv
for uri in ax_uris:
rv = self.get_uri(uri)
if rv is not None:
return rv
class OpenIDResponse(object):
"""Passed to the `after_login` function. Provides all the information
sent from the OpenID provider. The profile information has to be
requested from the server by passing a list of fields as `ask_for` to
the :meth:`~OpenID.try_login` function.
"""
def __init__(self, resp, extensions):
#: the openid the user used for sign in
self.identity_url = resp.identity_url
lookup = RegLookup(resp, extensions)
#: the full name of the user
self.fullname = lookup.get_combined('fullname', FULL_NAME_URIS)
if self.fullname is None:
first = lookup.get_uri('http://axschema.org/namePerson/first')
last = lookup.get_uri(u'http://axschema.org/namePerson/last')
self.fullname = u' '.join(x for x in [first, last] if x) or None
#: desired nickname of the user
self.nickname = lookup.get('nickname')
#: the email address of the user
self.email = lookup.get('email')
#: the gender of the user (``f`` for femail and ``m`` for male)
self.gender = (lookup.get('gender') or '').lower() or None
#: the country of the user as specified by ISO3166
self.country = lookup.get('country')
#: free text that should conform to the user's country's postal system
self.postcode = lookup.get('postcode')
#: the user's preferred language as specified by ISO639
self.language = lookup.get('language')
#: timezone string from the TimeZone database
self.timezone = lookup.get('timezone')
#: date of birth as :class:`~datetime.datetime` object.
self.date_of_birth = None
#: the year of birth of the user as integer
self.year_of_birth = None
#: the month of birth of the user as integer (1 based)
self.month_of_birth = None
# check if we can get the full birthday first
dobstr = lookup.get_combined('dob', FULL_DOB_URIS)
if dobstr is not None:
try:
pieces = [int(x) for x in dobstr.split('-')]
if len(pieces) != 3:
raise ValueError()
except (ValueError, TypeError):
pass
else:
if pieces[0]:
self.year_of_birth = pieces[0]
if pieces[1]:
self.month_of_birth = pieces[1]
try:
self.date_of_birth = date(*pieces)
except (ValueError, TypeError, OverflowError):
pass
# next try just year and month
if self.year_of_birth is None:
self.year_of_birth = softint(lookup.get_uri(
'http://axschema.org/birthDate/birthYear'))
self.month_of_birth = softint(lookup.get_uri(
'http://axschema.org/birthDate/birthMonth'))
#: phone number of the user as string
self.phone = lookup.get('phone')
#: AIM messenger address as string
self.aim = lookup.get('aim')
#: icq messenger number as string
self.icq = lookup.get('icq')
#: msn name as string
self.msn = lookup.get('msn')
#: yahoo messenger address as string
self.yahoo = lookup.get('yahoo')
#: jabber address as string
self.jabber = lookup.get('jabber')
#: skype name as string
self.skype = lookup.get('skype')
#: URL of website as string
self.website = lookup.get('website')
#: URL of blog as string
self.blog = lookup.get('blog')
#: URL to profile image as string
self.image = lookup.get('image')
#: Hash of the response object from the OpenID Extension by the
# OpenID Extension class name
self.extensions = lookup.ext
class OpenID(object):
"""Simple helper class for OpenID auth. Has to be created in advance
like a :class:`~flask.Flask` object.
There are two usage modes which work very similar. One is binding
the instance to a very specific Flask application::
app = Flask(__name__)
db = OpenID(app)
The second possibility is to create the object once and configure the
application later to support it::
oid = OpenID()
def create_app():
app = Flask(__name__)
oid.init_app(app)
return app
:param app: the application to register this openid controller with.
:param fs_store_path: if given this is the name of a folder where the
OpenID auth process can store temporary
information. If neither is provided a temporary
folder is assumed. This is overridden by the
``OPENID_FS_STORE_PATH`` configuration key.
:param store_factory: alternatively a function that creates a
python-openid store object.
:param fallback_endpoint: optionally a string with the name of an URL
endpoint the user should be redirected to
if the HTTP referrer is unreliable. By
default the user is redirected back to the
application's index in that case.
:param extension_responses: a list of OpenID Extensions Response class.
:param safe_roots: a list of trust roots to support returning to
:param url_root_as_trust_root: whether to use the url_root as trust_root
"""
def __init__(self, app=None, fs_store_path=None, store_factory=None,
fallback_endpoint=None, extension_responses=None,
safe_roots=None, url_root_as_trust_root=False):
# backwards compatibility support
if isstring(app):
from warnings import warn
warn(DeprecationWarning('OpenID constructor expects application '
'as first argument now. If you want to '
'provide a hardcoded fs_store_path you '
'have to use a keyword argument. It is '
'recommended though to use the config '
'key.'), stacklevel=2)
fs_store_path = app
app = None
self.app = app
if app is not None:
self.init_app(app)
self.fs_store_path = fs_store_path
if store_factory is None:
store_factory = self._default_store_factory
self.store_factory = store_factory
self.after_login_func = None
self.fallback_endpoint = fallback_endpoint
if not extension_responses:
extension_responses = []
self.extension_responses = extension_responses
if isstring(safe_roots):
self.safe_roots = [safe_roots]
else:
self.safe_roots = safe_roots
self.url_root_as_trust_root = url_root_as_trust_root
def init_app(self, app):
"""This callback can be used to initialize an application for the
use with this openid controller.
.. versionadded:: 1.0
"""
app.config.setdefault('OPENID_FS_STORE_PATH', None)
def _default_store_factory(self):
"""Default store factory that creates a filesystem store from
the configuration.
"""
app = self.app if self.app is not None else current_app
if 'OPENID_FS_STORE_PATH' not in app.config:
self.init_app(app)
from warnings import warn
warn(DeprecationWarning('init_app not called for this '
'application. This is deprecated functionality'))
path = app.config['OPENID_FS_STORE_PATH'] or self.fs_store_path
if path is None:
path = os.path.join(tempfile.gettempdir(), 'flask-openid')
return FileOpenIDStore(path)
def signal_error(self, msg):
"""Signals an error. It does this by storing the message in the
session. Use :meth:`errorhandler` to this method.
"""
session['openid_error'] = msg
def fetch_error(self):
"""Fetches the error from the session. This removes it from the
session and returns that error. This method is probably useless
if :meth:`errorhandler` is used.
"""
return session.pop('openid_error', None)
def get_next_url(self):
"""Returns the URL where we want to redirect to. This will
always return a valid URL.
"""
return (
self.check_safe_root(request.values.get('next')) or
self.check_safe_root(request.referrer) or
(self.fallback_endpoint and
self.check_safe_root(url_for(self.fallback_endpoint))) or
request.url_root
)
def check_safe_root(self, url):
if url is None:
return None
if self.safe_roots is None:
return url
if url.startswith(request.url_root) or url.startswith('/'):
# A URL inside the same app is deemed to always be safe
return url
for safe_root in self.safe_roots:
if url.startswith(safe_root):
return url
return None
def get_current_url(self):
"""the current URL + next."""
return request.base_url + '?next=' + url_quote(self.get_next_url())
def get_success_url(self):
"""Return the internal success URL.
:internal:
"""
return self.get_current_url() + '&openid_complete=yes'
def attach_reg_info(self, auth_request, keys, optional_keys):
"""Attaches sreg and ax requests to the auth request.
:internal:
"""
keys = set(keys or [])
optional_keys = set(optional_keys or [])
sreg_keys = list(SREG_KEYS & keys)
sreg_optional_keys = list(SREG_KEYS & optional_keys)
auth_request.addExtension(SRegRequest(required=sreg_keys,
optional=sreg_optional_keys))
ax_req = ax.FetchRequest()
for key in (keys | optional_keys):
for uri in AX_MAPPING.get(key, ()):
ax_req.add(ax.AttrInfo(uri, required=key in REQUIRED_KEYS))
auth_request.addExtension(ax_req)
def errorhandler(self, f):
"""Called if an error occurs with the message. By default
``'openid_error'`` is added to the session so that :meth:`fetch_error`
can fetch that error from the session. Alternatively it makes sense
to directly flash the error for example::
@oid.errorhandler
def on_error(message):
flash(u'Error: ' + message)
"""
self.signal_error = f
return f
def after_login(self, f):
"""This function will be called after login. It must redirect to
a different place and remember the user somewhere. The session
is not modified by SimpleOpenID. The decorated function is
passed a :class:`OpenIDResponse` object.
"""
self.after_login_func = f
return f
def loginhandler(self, f):
"""Marks a function as login handler. This decorator injects some
more OpenID required logic. Always decorate your login function with
this decorator.
"""
@wraps(f)
def decorated(*args, **kwargs):
if request.args.get('openid_complete') != u'yes':
return f(*args, **kwargs)
consumer = Consumer(SessionWrapper(self), self.store_factory())
args = request.args.to_dict()
args.update(request.form.to_dict())
openid_response = consumer.complete(args, self.get_current_url())
if openid_response.status == SUCCESS:
return self.after_login_func(OpenIDResponse(
openid_response, self.extension_responses))
elif openid_response.status == CANCEL:
self.signal_error(u'The request was cancelled')
elif openid_response.status == FAILURE:
self.signal_error(u'OpenID authentication failure. Mesage: %s'
% openid_response.message)
elif openid_response.status == SETUP_NEEDED:
# Unless immediate=True, we should never get here
self.signal_error(u'OpenID setup was needed')
else:
# We should also never get here, as this should be exhaustive
self.signal_error(u'OpenID authentication weird state: %s' %
openid_response.status)
return redirect(self.get_current_url())
return decorated
def try_login(self, identity_url, ask_for=None, ask_for_optional=None,
extensions=None, immediate=False):
"""This tries to login with the given identity URL. This function
must be called from the login_handler. The `ask_for` and
`ask_for_optional`parameter can be a set of values to be asked
from the openid provider, where keys in `ask_for` are marked as
required, and keys in `ask_for_optional` are marked as optional.
The following strings can be used in the `ask_for` and
`ask_for_optional` parameters:
``aim``, ``blog``, ``country``, ``dob`` (date of birth), ``email``,
``fullname``, ``gender``, ``icq``, ``image``, ``jabber``, ``language``,
``msn``, ``nickname``, ``phone``, ``postcode``, ``skype``,
``timezone``, ``website``, ``yahoo``
`extensions` can be a list of instances of OpenID extension requests
that should be passed on with the request. If you use this, please make
sure to pass the Response classes of these extensions when initializing
OpenID.
`immediate` can be used to indicate this request should be a so-called
checkid_immediate request, resulting in the provider not showing any
UI.
Note that this adds a new possible response: SetupNeeded, which is the
server saying it doesn't have enough information yet to authorized or
reject the authentication (probably, the user needs to sign in or
approve the trust root).
"""
if ask_for and __debug__:
for key in ask_for:
if key not in ALL_KEYS:
raise ValueError('invalid key %r' % key)
if ask_for_optional:
for key in ask_for_optional:
if key not in ALL_KEYS:
raise ValueError('invalid optional key %r' % key)
try:
consumer = Consumer(SessionWrapper(self), self.store_factory())
auth_request = consumer.begin(identity_url)
if ask_for or ask_for_optional:
self.attach_reg_info(auth_request, ask_for, ask_for_optional)
if extensions:
for extension in extensions:
auth_request.addExtension(extension)
except discover.DiscoveryFailure:
self.signal_error(u'The OpenID was invalid')
return redirect(self.get_current_url())
if self.url_root_as_trust_root:
trust_root = request.url_root
else:
trust_root = request.host_url
return redirect(auth_request.redirectURL(trust_root,
self.get_success_url(),
immediate=immediate))
Flask-OpenID-1.2.5/docs/ 0000775 0001750 0001750 00000000000 12575547273 017262 5 ustar puiterwijk puiterwijk 0000000 0000000 Flask-OpenID-1.2.5/docs/Makefile 0000664 0001750 0001750 00000010731 12464145144 020710 0 ustar puiterwijk puiterwijk 0000000 0000000 # Makefile for Sphinx documentation
#
# You can set these variables from the command line.
SPHINXOPTS =
SPHINXBUILD = sphinx-build
PAPER =
BUILDDIR = _build
# Internal variables.
PAPEROPT_a4 = -D latex_paper_size=a4
PAPEROPT_letter = -D latex_paper_size=letter
ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest
help:
@echo "Please use \`make +:< X>CoƝҘElgRWU) g+͛ _y| x8ogO3iib7x͆] kpna,pWZ" UԇPba;aߣD`gvEJ ]F ԫA(8eqed4x^,_uU4h5luI63Tk!4rX}No紧a
]s WvX
74ɉY:r 7Y`!y/Б&8M0XK O!K3|^_2 WczW~!.kb( 3wRj㫙E,xqFص%݁{Qgb`iaW$g+<ɷXQE_^䜢ݯ[>ے|G7L66)¢tf8 DI
Hey! This is the first time you signed in on this website. In
order to proceed we need a couple of more information from you:
If you don't want to proceed, you can sign out again.
{% endblock %}
Logging Out
-----------
The logout function is very simple, it just has to unset the openid from
the session and redirect back to where the user was before::
@app.route('/logout')
def logout():
session.pop('openid', None)
flash(u'You were signed out')
return redirect(oid.get_next_url())
Advanced usage
--------------
Flask-OpenID can also work with any python-openid extension.
To use this, pass a list of instantiated request openid.extension.Extension
objects in the `extensions` field of :meth:`~OpenID.try_login`.
The responses of these extensions are available during the :meth:`after_login`
function, as entries in resp.extensions.
Full Example
------------
To see the full code of that example, you can download the code `from
github Sign in
{% endblock %}
See how `error` and `next` are used. The name of the form field `next` is
required, so don't change it.
Responding to Successful Logins
-------------------------------
Next we have to define a function that is called after the login was
successful. The responsibility of that function is to remember the user
that just logged in and to figure out if it's a new user to the system or
one with an existing profile (if you want to use profiles).
Such a function is decorated with :meth:`~OpenID.after_login` and must
remember the user in the session and redirect to the proper page::
from flask import flash
@oid.after_login
def create_or_login(resp):
session['openid'] = resp.identity_url
user = User.query.filter_by(openid=resp.identity_url).first()
if user is not None:
flash(u'Successfully signed in')
g.user = user
return redirect(oid.get_next_url())
return redirect(url_for('create_profile', next=oid.get_next_url(),
name=resp.fullname or resp.nickname,
email=resp.email))
The `resp` object passed is a :class:`OpenIDResponse` object with all the
information you might desire. As you can see, we memorize the user's
openid and try to get the user with that OpenID from the database. If
that fails we redirect the user to a page to create a new profile and also
forward the name (or nickname if no name is provided) and the email
address. Please keep in mind that an openid provider does not have to
support these profile information and not every value you ask for will be
there. If it's missing it will be `None`. Again make sure to not lose
the information about the next URL.
Creating a Profile
------------------
A typical page to create such a profile might look like this::
@app.route('/create-profile', methods=['GET', 'POST'])
def create_profile():
if g.user is not None or 'openid' not in session:
return redirect(url_for('index'))
if request.method == 'POST':
name = request.form['name']
email = request.form['email']
if not name:
flash(u'Error: you have to provide a name')
elif '@' not in email:
flash(u'Error: you have to enter a valid email address')
else:
flash(u'Profile successfully created')
db_session.add(User(name, email, session['openid']))
db_session.commit()
return redirect(oid.get_next_url())
return render_template('create_profile.html', next=oid.get_next_url())
If you're using the same names for the URL parameters in the step before
and in this form, you have nice looking and simple templates:
.. sourcecode:: html+jinja
{% extends "layout.html" %}
{% block title %}Create Profile{% endblock %}
{% block body %}
Create Profile
{% endif %}
{% endblock %}
{% block sidebar1 %}{% endblock %}
{% block sidebar2 %}{% endblock %}
Flask-OpenID-1.2.5/docs/_themes/flask_small/theme.conf 0000664 0001750 0001750 00000000270 12464145171 025132 0 ustar puiterwijk puiterwijk 0000000 0000000 [theme]
inherit = basic
stylesheet = flasky.css
nosidebar = true
pygments_style = flask_theme_support.FlaskyStyle
[options]
index_logo = ''
index_logo_height = 120px
github_fork = ''
Flask-OpenID-1.2.5/docs/_themes/flask_small/static/ 0000775 0001750 0001750 00000000000 12575547273 024465 5 ustar puiterwijk puiterwijk 0000000 0000000 Flask-OpenID-1.2.5/docs/_themes/flask_small/static/flasky.css_t 0000664 0001750 0001750 00000011001 12464145171 026770 0 ustar puiterwijk puiterwijk 0000000 0000000 /*
* flasky.css_t
* ~~~~~~~~~~~~
*
* Sphinx stylesheet -- flasky theme based on nature theme.
*
* :copyright: Copyright 2007-2010 by the Sphinx team, see AUTHORS.
* :license: BSD, see LICENSE for details.
*
*/
@import url("basic.css");
/* -- page layout ----------------------------------------------------------- */
body {
font-family: 'Georgia', serif;
font-size: 17px;
color: #000;
background: white;
margin: 0;
padding: 0;
}
div.documentwrapper {
float: left;
width: 100%;
}
div.bodywrapper {
margin: 40px auto 0 auto;
width: 700px;
}
hr {
border: 1px solid #B1B4B6;
}
div.body {
background-color: #ffffff;
color: #3E4349;
padding: 0 30px 30px 30px;
}
img.floatingflask {
padding: 0 0 10px 10px;
float: right;
}
div.footer {
text-align: right;
color: #888;
padding: 10px;
font-size: 14px;
width: 650px;
margin: 0 auto 40px auto;
}
div.footer a {
color: #888;
text-decoration: underline;
}
div.related {
line-height: 32px;
color: #888;
}
div.related ul {
padding: 0 0 0 10px;
}
div.related a {
color: #444;
}
/* -- body styles ----------------------------------------------------------- */
a {
color: #004B6B;
text-decoration: underline;
}
a:hover {
color: #6D4100;
text-decoration: underline;
}
div.body {
padding-bottom: 40px; /* saved for footer */
}
div.body h1,
div.body h2,
div.body h3,
div.body h4,
div.body h5,
div.body h6 {
font-family: 'Garamond', 'Georgia', serif;
font-weight: normal;
margin: 30px 0px 10px 0px;
padding: 0;
}
{% if theme_index_logo %}
div.indexwrapper h1 {
text-indent: -999999px;
background: url({{ theme_index_logo }}) no-repeat center center;
height: {{ theme_index_logo_height }};
}
{% endif %}
div.body h2 { font-size: 180%; }
div.body h3 { font-size: 150%; }
div.body h4 { font-size: 130%; }
div.body h5 { font-size: 100%; }
div.body h6 { font-size: 100%; }
a.headerlink {
color: white;
padding: 0 4px;
text-decoration: none;
}
a.headerlink:hover {
color: #444;
background: #eaeaea;
}
div.body p, div.body dd, div.body li {
line-height: 1.4em;
}
div.admonition {
background: #fafafa;
margin: 20px -30px;
padding: 10px 30px;
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
}
div.admonition p.admonition-title {
font-family: 'Garamond', 'Georgia', serif;
font-weight: normal;
font-size: 24px;
margin: 0 0 10px 0;
padding: 0;
line-height: 1;
}
div.admonition p.last {
margin-bottom: 0;
}
div.highlight{
background-color: white;
}
dt:target, .highlight {
background: #FAF3E8;
}
div.note {
background-color: #eee;
border: 1px solid #ccc;
}
div.seealso {
background-color: #ffc;
border: 1px solid #ff6;
}
div.topic {
background-color: #eee;
}
div.warning {
background-color: #ffe4e4;
border: 1px solid #f66;
}
p.admonition-title {
display: inline;
}
p.admonition-title:after {
content: ":";
}
pre, tt {
font-family: 'Consolas', 'Menlo', 'Deja Vu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
font-size: 0.85em;
}
img.screenshot {
}
tt.descname, tt.descclassname {
font-size: 0.95em;
}
tt.descname {
padding-right: 0.08em;
}
img.screenshot {
-moz-box-shadow: 2px 2px 4px #eee;
-webkit-box-shadow: 2px 2px 4px #eee;
box-shadow: 2px 2px 4px #eee;
}
table.docutils {
border: 1px solid #888;
-moz-box-shadow: 2px 2px 4px #eee;
-webkit-box-shadow: 2px 2px 4px #eee;
box-shadow: 2px 2px 4px #eee;
}
table.docutils td, table.docutils th {
border: 1px solid #888;
padding: 0.25em 0.7em;
}
table.field-list, table.footnote {
border: none;
-moz-box-shadow: none;
-webkit-box-shadow: none;
box-shadow: none;
}
table.footnote {
margin: 15px 0;
width: 100%;
border: 1px solid #eee;
}
table.field-list th {
padding: 0 0.8em 0 0;
}
table.field-list td {
padding: 0;
}
table.footnote td {
padding: 0.5em;
}
dl {
margin: 0;
padding: 0;
}
dl dd {
margin-left: 30px;
}
pre {
padding: 0;
margin: 15px -30px;
padding: 8px;
line-height: 1.3em;
padding: 7px 30px;
background: #eee;
border-radius: 2px;
-moz-border-radius: 2px;
-webkit-border-radius: 2px;
}
dl pre {
margin-left: -60px;
padding-left: 60px;
}
tt {
background-color: #ecf0f3;
color: #222;
/* padding: 1px 2px; */
}
tt.xref, a tt {
background-color: #FBFBFB;
}
a:hover tt {
background: #EEE;
}
Flask-OpenID-1.2.5/docs/_themes/flask/ 0000775 0001750 0001750 00000000000 12575547273 022006 5 ustar puiterwijk puiterwijk 0000000 0000000 Flask-OpenID-1.2.5/docs/_themes/flask/layout.html 0000664 0001750 0001750 00000001106 12464145171 024173 0 ustar puiterwijk puiterwijk 0000000 0000000 {%- extends "basic/layout.html" %}
{%- block extrahead %}
{{ super() }}
{% if theme_touch_icon %}
{% endif %}
{% endblock %}
{%- block relbar2 %}{% endblock %}
{%- block footer %}
{%- endblock %}
Flask-OpenID-1.2.5/docs/_themes/flask/theme.conf 0000664 0001750 0001750 00000000172 12464145171 023743 0 ustar puiterwijk puiterwijk 0000000 0000000 [theme]
inherit = basic
stylesheet = flasky.css
pygments_style = flask_theme_support.FlaskyStyle
[options]
touch_icon =
Flask-OpenID-1.2.5/docs/_themes/flask/static/ 0000775 0001750 0001750 00000000000 12575547273 023275 5 ustar puiterwijk puiterwijk 0000000 0000000 Flask-OpenID-1.2.5/docs/_themes/flask/static/flasky.css_t 0000664 0001750 0001750 00000014131 12464145171 025607 0 ustar puiterwijk puiterwijk 0000000 0000000 /*
* flasky.css_t
* ~~~~~~~~~~~~
*
* :copyright: Copyright 2010 by Armin Ronacher.
* :license: Flask Design License, see LICENSE for details.
*/
{% set page_width = '940px' %}
{% set sidebar_width = '220px' %}
@import url("basic.css");
/* -- page layout ----------------------------------------------------------- */
body {
font-family: 'Georgia', serif;
font-size: 17px;
background-color: white;
color: #000;
margin: 0;
padding: 0;
}
div.document {
width: {{ page_width }};
margin: 30px auto 0 auto;
}
div.documentwrapper {
float: left;
width: 100%;
}
div.bodywrapper {
margin: 0 0 0 {{ sidebar_width }};
}
div.sphinxsidebar {
width: {{ sidebar_width }};
}
hr {
border: 1px solid #B1B4B6;
}
div.body {
background-color: #ffffff;
color: #3E4349;
padding: 0 30px 0 30px;
}
img.floatingflask {
padding: 0 0 10px 10px;
float: right;
}
div.footer {
width: {{ page_width }};
margin: 20px auto 30px auto;
font-size: 14px;
color: #888;
text-align: right;
}
div.footer a {
color: #888;
}
div.related {
display: none;
}
div.sphinxsidebar a {
color: #444;
text-decoration: none;
border-bottom: 1px dotted #999;
}
div.sphinxsidebar a:hover {
border-bottom: 1px solid #999;
}
div.sphinxsidebar {
font-size: 14px;
line-height: 1.5;
}
div.sphinxsidebarwrapper {
padding: 18px 10px;
}
div.sphinxsidebarwrapper p.logo {
padding: 0 0 20px 0;
margin: 0;
text-align: center;
}
div.sphinxsidebar h3,
div.sphinxsidebar h4 {
font-family: 'Garamond', 'Georgia', serif;
color: #444;
font-size: 24px;
font-weight: normal;
margin: 0 0 5px 0;
padding: 0;
}
div.sphinxsidebar h4 {
font-size: 20px;
}
div.sphinxsidebar h3 a {
color: #444;
}
div.sphinxsidebar p.logo a,
div.sphinxsidebar h3 a,
div.sphinxsidebar p.logo a:hover,
div.sphinxsidebar h3 a:hover {
border: none;
}
div.sphinxsidebar p {
color: #555;
margin: 10px 0;
}
div.sphinxsidebar ul {
margin: 10px 0;
padding: 0;
color: #000;
}
div.sphinxsidebar input {
border: 1px solid #ccc;
font-family: 'Georgia', serif;
font-size: 1em;
}
/* -- body styles ----------------------------------------------------------- */
a {
color: #004B6B;
text-decoration: underline;
}
a:hover {
color: #6D4100;
text-decoration: underline;
}
div.body h1,
div.body h2,
div.body h3,
div.body h4,
div.body h5,
div.body h6 {
font-family: 'Garamond', 'Georgia', serif;
font-weight: normal;
margin: 30px 0px 10px 0px;
padding: 0;
}
div.body h1 { margin-top: 0; padding-top: 0; font-size: 240%; }
div.body h2 { font-size: 180%; }
div.body h3 { font-size: 150%; }
div.body h4 { font-size: 130%; }
div.body h5 { font-size: 100%; }
div.body h6 { font-size: 100%; }
a.headerlink {
color: #ddd;
padding: 0 4px;
text-decoration: none;
}
a.headerlink:hover {
color: #444;
background: #eaeaea;
}
div.body p, div.body dd, div.body li {
line-height: 1.4em;
}
div.admonition {
background: #fafafa;
margin: 20px -30px;
padding: 10px 30px;
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
}
div.admonition tt.xref, div.admonition a tt {
border-bottom: 1px solid #fafafa;
}
dd div.admonition {
margin-left: -60px;
padding-left: 60px;
}
div.admonition p.admonition-title {
font-family: 'Garamond', 'Georgia', serif;
font-weight: normal;
font-size: 24px;
margin: 0 0 10px 0;
padding: 0;
line-height: 1;
}
div.admonition p.last {
margin-bottom: 0;
}
div.highlight {
background-color: white;
}
dt:target, .highlight {
background: #FAF3E8;
}
div.note {
background-color: #eee;
border: 1px solid #ccc;
}
div.seealso {
background-color: #ffc;
border: 1px solid #ff6;
}
div.topic {
background-color: #eee;
}
p.admonition-title {
display: inline;
}
p.admonition-title:after {
content: ":";
}
pre, tt {
font-family: 'Consolas', 'Menlo', 'Deja Vu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
font-size: 0.9em;
}
img.screenshot {
}
tt.descname, tt.descclassname {
font-size: 0.95em;
}
tt.descname {
padding-right: 0.08em;
}
img.screenshot {
-moz-box-shadow: 2px 2px 4px #eee;
-webkit-box-shadow: 2px 2px 4px #eee;
box-shadow: 2px 2px 4px #eee;
}
table.docutils {
border: 1px solid #888;
-moz-box-shadow: 2px 2px 4px #eee;
-webkit-box-shadow: 2px 2px 4px #eee;
box-shadow: 2px 2px 4px #eee;
}
table.docutils td, table.docutils th {
border: 1px solid #888;
padding: 0.25em 0.7em;
}
table.field-list, table.footnote {
border: none;
-moz-box-shadow: none;
-webkit-box-shadow: none;
box-shadow: none;
}
table.footnote {
margin: 15px 0;
width: 100%;
border: 1px solid #eee;
background: #fdfdfd;
font-size: 0.9em;
}
table.footnote + table.footnote {
margin-top: -15px;
border-top: none;
}
table.field-list th {
padding: 0 0.8em 0 0;
}
table.field-list td {
padding: 0;
}
table.footnote td.label {
width: 0px;
padding: 0.3em 0 0.3em 0.5em;
}
table.footnote td {
padding: 0.3em 0.5em;
}
dl {
margin: 0;
padding: 0;
}
dl dd {
margin-left: 30px;
}
blockquote {
margin: 0 0 0 30px;
padding: 0;
}
ul, ol {
margin: 10px 0 10px 30px;
padding: 0;
}
pre {
background: #eee;
padding: 7px 30px;
margin: 15px -30px;
line-height: 1.3em;
}
dl pre, blockquote pre, li pre {
margin-left: -60px;
padding-left: 60px;
}
dl dl pre {
margin-left: -90px;
padding-left: 90px;
}
tt {
background-color: #ecf0f3;
color: #222;
/* padding: 1px 2px; */
}
tt.xref, a tt {
background-color: #FBFBFB;
border-bottom: 1px solid white;
}
a.reference {
text-decoration: none;
border-bottom: 1px dotted #004B6B;
}
a.reference:hover {
border-bottom: 1px solid #6D4100;
}
a.footnote-reference {
text-decoration: none;
font-size: 0.7em;
vertical-align: top;
border-bottom: 1px dotted #004B6B;
}
a.footnote-reference:hover {
border-bottom: 1px solid #6D4100;
}
a:hover tt {
background: #EEE;
}
Flask-OpenID-1.2.5/docs/_themes/flask/static/small_flask.css 0000664 0001750 0001750 00000001720 12464145171 026263 0 ustar puiterwijk puiterwijk 0000000 0000000 /*
* small_flask.css_t
* ~~~~~~~~~~~~~~~~~
*
* :copyright: Copyright 2010 by Armin Ronacher.
* :license: Flask Design License, see LICENSE for details.
*/
body {
margin: 0;
padding: 20px 30px;
}
div.documentwrapper {
float: none;
background: white;
}
div.sphinxsidebar {
display: block;
float: none;
width: 102.5%;
margin: 50px -30px -20px -30px;
padding: 10px 20px;
background: #333;
color: white;
}
div.sphinxsidebar h3, div.sphinxsidebar h4, div.sphinxsidebar p,
div.sphinxsidebar h3 a {
color: white;
}
div.sphinxsidebar a {
color: #aaa;
}
div.sphinxsidebar p.logo {
display: none;
}
div.document {
width: 100%;
margin: 0;
}
div.related {
display: block;
margin: 0;
padding: 10px 0 20px 0;
}
div.related ul,
div.related ul li {
margin: 0;
padding: 0;
}
div.footer {
display: none;
}
div.bodywrapper {
margin: 0;
}
div.body {
min-height: 0;
padding: 0;
}
Flask-OpenID-1.2.5/docs/_themes/flask/relations.html 0000664 0001750 0001750 00000001116 12464145171 024657 0 ustar puiterwijk puiterwijk 0000000 0000000 Related Topics
Flask-OpenID-1.2.5/docs/_themes/flask_theme_support.py 0000664 0001750 0001750 00000011413 12464145171 025322 0 ustar puiterwijk puiterwijk 0000000 0000000 # flasky extensions. flasky pygments style based on tango style
from pygments.style import Style
from pygments.token import Keyword, Name, Comment, String, Error, \
Number, Operator, Generic, Whitespace, Punctuation, Other, Literal
class FlaskyStyle(Style):
background_color = "#f8f8f8"
default_style = ""
styles = {
# No corresponding class for the following:
#Text: "", # class: ''
Whitespace: "underline #f8f8f8", # class: 'w'
Error: "#a40000 border:#ef2929", # class: 'err'
Other: "#000000", # class 'x'
Comment: "italic #8f5902", # class: 'c'
Comment.Preproc: "noitalic", # class: 'cp'
Keyword: "bold #004461", # class: 'k'
Keyword.Constant: "bold #004461", # class: 'kc'
Keyword.Declaration: "bold #004461", # class: 'kd'
Keyword.Namespace: "bold #004461", # class: 'kn'
Keyword.Pseudo: "bold #004461", # class: 'kp'
Keyword.Reserved: "bold #004461", # class: 'kr'
Keyword.Type: "bold #004461", # class: 'kt'
Operator: "#582800", # class: 'o'
Operator.Word: "bold #004461", # class: 'ow' - like keywords
Punctuation: "bold #000000", # class: 'p'
# because special names such as Name.Class, Name.Function, etc.
# are not recognized as such later in the parsing, we choose them
# to look the same as ordinary variables.
Name: "#000000", # class: 'n'
Name.Attribute: "#c4a000", # class: 'na' - to be revised
Name.Builtin: "#004461", # class: 'nb'
Name.Builtin.Pseudo: "#3465a4", # class: 'bp'
Name.Class: "#000000", # class: 'nc' - to be revised
Name.Constant: "#000000", # class: 'no' - to be revised
Name.Decorator: "#888", # class: 'nd' - to be revised
Name.Entity: "#ce5c00", # class: 'ni'
Name.Exception: "bold #cc0000", # class: 'ne'
Name.Function: "#000000", # class: 'nf'
Name.Property: "#000000", # class: 'py'
Name.Label: "#f57900", # class: 'nl'
Name.Namespace: "#000000", # class: 'nn' - to be revised
Name.Other: "#000000", # class: 'nx'
Name.Tag: "bold #004461", # class: 'nt' - like a keyword
Name.Variable: "#000000", # class: 'nv' - to be revised
Name.Variable.Class: "#000000", # class: 'vc' - to be revised
Name.Variable.Global: "#000000", # class: 'vg' - to be revised
Name.Variable.Instance: "#000000", # class: 'vi' - to be revised
Number: "#990000", # class: 'm'
Literal: "#000000", # class: 'l'
Literal.Date: "#000000", # class: 'ld'
String: "#4e9a06", # class: 's'
String.Backtick: "#4e9a06", # class: 'sb'
String.Char: "#4e9a06", # class: 'sc'
String.Doc: "italic #8f5902", # class: 'sd' - like a comment
String.Double: "#4e9a06", # class: 's2'
String.Escape: "#4e9a06", # class: 'se'
String.Heredoc: "#4e9a06", # class: 'sh'
String.Interpol: "#4e9a06", # class: 'si'
String.Other: "#4e9a06", # class: 'sx'
String.Regex: "#4e9a06", # class: 'sr'
String.Single: "#4e9a06", # class: 's1'
String.Symbol: "#4e9a06", # class: 'ss'
Generic: "#000000", # class: 'g'
Generic.Deleted: "#a40000", # class: 'gd'
Generic.Emph: "italic #000000", # class: 'ge'
Generic.Error: "#ef2929", # class: 'gr'
Generic.Heading: "bold #000080", # class: 'gh'
Generic.Inserted: "#00A000", # class: 'gi'
Generic.Output: "#888", # class: 'go'
Generic.Prompt: "#745334", # class: 'gp'
Generic.Strong: "bold #000000", # class: 'gs'
Generic.Subheading: "bold #800080", # class: 'gu'
Generic.Traceback: "bold #a40000", # class: 'gt'
}
Flask-OpenID-1.2.5/PKG-INFO 0000664 0001750 0001750 00000002064 12575547273 017431 0 ustar puiterwijk puiterwijk 0000000 0000000 Metadata-Version: 1.1
Name: Flask-OpenID
Version: 1.2.5
Summary: OpenID support for Flask
Home-page: http://github.com/mitsuhiko/flask-openid/
Author: Armin Ronacher, Patrick Uiterwijk
Author-email: armin.ronacher@active-4.com, puiterwijk@redhat.com
License: BSD
Description:
Flask-OpenID
============
Adds OpenID support to Flask.
Links:
* `Flask-OpenID Documentation
{%- for parent in parents %}
{%- endfor %}
{%- if prev %}