Django-1.11.11/ 0000775 0001750 0001750 00000000000 13247520354 012471 5 ustar tim tim 0000000 0000000 Django-1.11.11/extras/ 0000775 0001750 0001750 00000000000 13247520353 013776 5 ustar tim tim 0000000 0000000 Django-1.11.11/extras/django_bash_completion 0000775 0001750 0001750 00000004434 13247520251 020416 0 ustar tim tim 0000000 0000000 # #########################################################################
# This bash script adds tab-completion feature to django-admin.py and
# manage.py.
#
# Testing it out without installing
# =================================
#
# To test out the completion without "installing" this, just run this file
# directly, like so:
#
# . ~/path/to/django_bash_completion
#
# Note: There's a dot ('.') at the beginning of that command.
#
# After you do that, tab completion will immediately be made available in your
# current Bash shell. But it won't be available next time you log in.
#
# Installing
# ==========
#
# To install this, point to this file from your .bash_profile, like so:
#
# . ~/path/to/django_bash_completion
#
# Do the same in your .bashrc if .bashrc doesn't invoke .bash_profile.
#
# Settings will take effect the next time you log in.
#
# Uninstalling
# ============
#
# To uninstall, just remove the line from your .bash_profile and .bashrc.
_django_completion()
{
COMPREPLY=( $( COMP_WORDS="${COMP_WORDS[*]}" \
COMP_CWORD=$COMP_CWORD \
DJANGO_AUTO_COMPLETE=1 $1 ) )
}
complete -F _django_completion -o default django-admin.py manage.py django-admin
_python_django_completion()
{
if [[ ${COMP_CWORD} -ge 2 ]]; then
local PYTHON_EXE=${COMP_WORDS[0]##*/}
echo $PYTHON_EXE | egrep "python([2-9]\.[0-9])?" >/dev/null 2>&1
if [[ $? == 0 ]]; then
local PYTHON_SCRIPT=${COMP_WORDS[1]##*/}
echo $PYTHON_SCRIPT | egrep "manage\.py|django-admin(\.py)?" >/dev/null 2>&1
if [[ $? == 0 ]]; then
COMPREPLY=( $( COMP_WORDS="${COMP_WORDS[*]:1}" \
COMP_CWORD=$(( COMP_CWORD-1 )) \
DJANGO_AUTO_COMPLETE=1 ${COMP_WORDS[*]} ) )
fi
fi
fi
}
# Support for multiple interpreters.
unset pythons
if command -v whereis &>/dev/null; then
python_interpreters=$(whereis python | cut -d " " -f 2-)
for python in $python_interpreters; do
[[ $python != *-config ]] && pythons="${pythons} ${python##*/}"
done
unset python_interpreters
pythons=$(echo $pythons | tr " " "\n" | sort -u | tr "\n" " ")
else
pythons=python
fi
complete -F _python_django_completion -o default $pythons
unset pythons
Django-1.11.11/extras/Makefile 0000664 0001750 0001750 00000000175 13213463123 015433 0 ustar tim tim 0000000 0000000 all: sdist bdist_wheel
sdist:
python setup.py sdist
bdist_wheel:
python setup.py bdist_wheel
.PHONY : sdist bdist_wheel
Django-1.11.11/extras/README.TXT 0000664 0001750 0001750 00000000115 12542572724 015337 0 ustar tim tim 0000000 0000000 This directory contains extra stuff that can improve your Django experience.
Django-1.11.11/js_tests/ 0000775 0001750 0001750 00000000000 13247520353 014326 5 ustar tim tim 0000000 0000000 Django-1.11.11/js_tests/admin/ 0000775 0001750 0001750 00000000000 13247520353 015416 5 ustar tim tim 0000000 0000000 Django-1.11.11/js_tests/admin/core.test.js 0000664 0001750 0001750 00000010766 13247517144 017700 0 ustar tim tim 0000000 0000000 /* global QUnit */
/* eslint global-strict: 0, strict: 0 */
'use strict';
QUnit.module('admin.core');
QUnit.test('Date.getTwelveHours', function(assert) {
assert.equal(new Date(2011, 0, 1, 0, 0).getTwelveHours(), 12, '0:00');
assert.equal(new Date(2011, 0, 1, 11, 0).getTwelveHours(), 11, '11:00');
assert.equal(new Date(2011, 0, 1, 16, 0).getTwelveHours(), 4, '16:00');
});
QUnit.test('Date.getTwoDigitMonth', function(assert) {
assert.equal(new Date(2011, 0, 1).getTwoDigitMonth(), '01', 'jan 1');
assert.equal(new Date(2011, 9, 1).getTwoDigitMonth(), '10', 'oct 1');
});
QUnit.test('Date.getTwoDigitDate', function(assert) {
assert.equal(new Date(2011, 0, 1).getTwoDigitDate(), '01', 'jan 1');
assert.equal(new Date(2011, 0, 15).getTwoDigitDate(), '15', 'jan 15');
});
QUnit.test('Date.getTwoDigitTwelveHour', function(assert) {
assert.equal(new Date(2011, 0, 1, 0, 0).getTwoDigitTwelveHour(), '12', '0:00');
assert.equal(new Date(2011, 0, 1, 4, 0).getTwoDigitTwelveHour(), '04', '4:00');
assert.equal(new Date(2011, 0, 1, 22, 0).getTwoDigitTwelveHour(), '10', '22:00');
});
QUnit.test('Date.getTwoDigitHour', function(assert) {
assert.equal(new Date(2014, 6, 1, 9, 0).getTwoDigitHour(), '09', '9:00 am is 09');
assert.equal(new Date(2014, 6, 1, 11, 0).getTwoDigitHour(), '11', '11:00 am is 11');
});
QUnit.test('Date.getTwoDigitMinute', function(assert) {
assert.equal(new Date(2014, 6, 1, 0, 5).getTwoDigitMinute(), '05', '12:05 am is 05');
assert.equal(new Date(2014, 6, 1, 0, 15).getTwoDigitMinute(), '15', '12:15 am is 15');
});
QUnit.test('Date.getTwoDigitSecond', function(assert) {
assert.equal(new Date(2014, 6, 1, 0, 0, 2).getTwoDigitSecond(), '02', '12:00:02 am is 02');
assert.equal(new Date(2014, 6, 1, 0, 0, 20).getTwoDigitSecond(), '20', '12:00:20 am is 20');
});
QUnit.test('Date.getHourMinute', function(assert) {
assert.equal(new Date(2014, 6, 1, 11, 0).getHourMinute(), '11:00', '11:00 am is 11:00');
assert.equal(new Date(2014, 6, 1, 13, 25).getHourMinute(), '13:25', '1:25 pm is 13:25');
});
QUnit.test('Date.getHourMinuteSecond', function(assert) {
assert.equal(new Date(2014, 6, 1, 11, 0, 0).getHourMinuteSecond(), '11:00:00', '11:00 am is 11:00:00');
assert.equal(new Date(2014, 6, 1, 17, 45, 30).getHourMinuteSecond(), '17:45:30', '5:45:30 pm is 17:45:30');
});
QUnit.test('Date.strftime', function(assert) {
var date = new Date(2014, 6, 1, 11, 0, 5);
assert.equal(date.strftime('%Y-%m-%d %H:%M:%S'), '2014-07-01 11:00:05');
assert.equal(date.strftime('%B %d, %Y'), 'July 01, 2014');
});
QUnit.test('String.strptime', function(assert) {
// Use UTC functions for extracting dates since the calendar uses them as
// well. Month numbering starts with 0 (January).
var firstParsedDate = '1988-02-26'.strptime('%Y-%m-%d');
assert.equal(firstParsedDate.getUTCDate(), 26);
assert.equal(firstParsedDate.getUTCMonth(), 1);
assert.equal(firstParsedDate.getUTCFullYear(), 1988);
var secondParsedDate = '26/02/88'.strptime('%d/%m/%y');
assert.equal(secondParsedDate.getUTCDate(), 26);
assert.equal(secondParsedDate.getUTCMonth(), 1);
assert.equal(secondParsedDate.getUTCFullYear(), 1988);
var format = django.get_format('DATE_INPUT_FORMATS')[0];
var thirdParsedDate = '1983-11-20'.strptime(format);
assert.equal(thirdParsedDate.getUTCDate(), 20);
assert.equal(thirdParsedDate.getUTCMonth(), 10);
assert.equal(thirdParsedDate.getUTCFullYear(), 1983);
// Extracting from a Date object with local time must give the correct
// result. Without proper conversion, timezones from GMT+0100 to GMT+1200
// gives a date one day earlier than necessary, e.g. converting local time
// Feb 26, 1988 00:00:00 EEST is Feb 25, 21:00:00 UTC.
// Checking timezones from GMT+0100 to GMT+1200
var i, tz, date;
for (i = 1; i <= 12; i++) {
tz = i > 9 ? '' + i : '0' + i;
date = new Date(Date.parse('Feb 26, 1988 00:00:00 GMT+' + tz + '00'));
assert.notEqual(date.getUTCDate(), 26);
assert.equal(date.getUTCDate(), 25);
assert.equal(date.getUTCMonth(), 1);
assert.equal(date.getUTCFullYear(), 1988);
}
// Checking timezones from GMT+0000 to GMT-1100
for (i = 0; i <= 11; i++) {
tz = i > 9 ? '' + i : '0' + i;
date = new Date(Date.parse('Feb 26, 1988 00:00:00 GMT-' + tz + '00'));
assert.equal(date.getUTCDate(), 26);
assert.equal(date.getUTCMonth(), 1);
assert.equal(date.getUTCFullYear(), 1988);
}
});
Django-1.11.11/js_tests/admin/actions.test.js 0000664 0001750 0001750 00000001174 13247517144 020401 0 ustar tim tim 0000000 0000000 /* global QUnit */
/* eslint global-strict: 0, strict: 0 */
'use strict';
QUnit.module('admin.actions', {
beforeEach: function() {
// Number of results shown on page
/* eslint-disable */
window._actions_icnt = '100';
/* eslint-enable */
var $ = django.jQuery;
$('#qunit-fixture').append($('#result-table').text());
$('tr input.action-select').actions();
}
});
QUnit.test('check', function(assert) {
var $ = django.jQuery;
assert.notOk($('.action-select').is(':checked'));
$('#action-toggle').click();
assert.ok($('.action-select').is(':checked'));
});
Django-1.11.11/js_tests/admin/timeparse.test.js 0000664 0001750 0001750 00000001566 13247517144 020737 0 ustar tim tim 0000000 0000000 /* global QUnit, parseTimeString */
/* eslint global-strict: 0, strict: 0 */
'use strict';
QUnit.module('admin.timeparse');
QUnit.test('parseTimeString', function(assert) {
function time(then, expected) {
assert.equal(parseTimeString(then), expected);
}
time('9', '09:00');
time('09', '09:00');
time('13:00', '13:00');
time('13.00', '13:00');
time('9:00', '09:00');
time('9.00', '09:00');
time('3 am', '03:00');
time('3 a.m.', '03:00');
time('12 am', '00:00');
time('11 am', '11:00');
time('12 pm', '12:00');
time('3am', '03:00');
time('3.30 am', '03:30');
time('3:15 a.m.', '03:15');
time('3.00am', '03:00');
time('12.00am', '00:00');
time('11.00am', '11:00');
time('12.00pm', '12:00');
time('noon', '12:00');
time('midnight', '00:00');
time('something else', 'something else');
});
Django-1.11.11/js_tests/admin/DateTimeShortcuts.test.js 0000664 0001750 0001750 00000001436 13247520251 022346 0 ustar tim tim 0000000 0000000 /* global QUnit, DateTimeShortcuts */
/* eslint global-strict: 0, strict: 0 */
'use strict';
QUnit.module('admin.DateTimeShortcuts');
QUnit.test('init', function(assert) {
var $ = django.jQuery;
var dateField = $(' ');
$('#qunit-fixture').append(dateField);
DateTimeShortcuts.init();
var shortcuts = $('.datetimeshortcuts');
assert.equal(shortcuts.length, 1);
assert.equal(shortcuts.find('a:first').text(), 'Today');
assert.equal(shortcuts.find('a:last .date-icon').length, 1);
// To prevent incorrect timezone warnings on date/time widgets, timezoneOffset
// should be 0 when a timezone offset isn't set in the HTML body attribute.
assert.equal(DateTimeShortcuts.timezoneOffset, 0);
});
Django-1.11.11/js_tests/admin/inlines.test.js 0000664 0001750 0001750 00000004616 13247517144 020406 0 ustar tim tim 0000000 0000000 /* global QUnit */
/* eslint global-strict: 0, strict: 0 */
'use strict';
QUnit.module('admin.inlines: tabular formsets', {
beforeEach: function() {
var $ = django.jQuery;
var that = this;
this.addText = 'Add another';
$('#qunit-fixture').append($('#tabular-formset').text());
this.table = $('table.inline');
this.inlineRow = this.table.find('tr');
that.inlineRow.tabularFormset({
prefix: 'first',
addText: that.addText,
deleteText: 'Remove'
});
}
});
QUnit.test('no forms', function(assert) {
assert.ok(this.inlineRow.hasClass('dynamic-first'));
assert.equal(this.table.find('.add-row a').text(), this.addText);
});
QUnit.test('add form', function(assert) {
var addButton = this.table.find('.add-row a');
assert.equal(addButton.text(), this.addText);
addButton.click();
assert.ok(this.table.find('#first-1').hasClass('row2'));
});
QUnit.test('add/remove form events', function(assert) {
assert.expect(6);
var $ = django.jQuery;
var $document = $(document);
var addButton = this.table.find('.add-row a');
$document.on('formset:added', function(event, $row, formsetName) {
assert.ok(true, 'event `formset:added` triggered');
assert.equal(true, $row.is($('.row2')));
assert.equal(formsetName, 'first');
});
addButton.click();
var deletedRow = $('.row2');
var deleteLink = this.table.find('.inline-deletelink');
$document.on('formset:removed', function(event, $row, formsetName) {
assert.ok(true, 'event `formset:removed` triggered');
assert.equal(true, $row.is(deletedRow));
assert.equal(formsetName, 'first');
});
deleteLink.click();
});
QUnit.test('existing add button', function(assert) {
var $ = django.jQuery;
$('#qunit-fixture').empty(); // Clear the table added in beforeEach
$('#qunit-fixture').append($('#tabular-formset').text());
this.table = $('table.inline');
this.inlineRow = this.table.find('tr');
this.table.append('');
var addButton = this.table.find('.add-button');
this.inlineRow.tabularFormset({
prefix: 'first',
deleteText: 'Remove',
addButton: addButton
});
assert.equal(this.table.find('.add-row a').length, 0);
addButton.click();
assert.ok(this.table.find('#first-1').hasClass('row2'));
});
Django-1.11.11/js_tests/admin/SelectBox.test.js 0000664 0001750 0001750 00000001413 13247517144 020625 0 ustar tim tim 0000000 0000000 /* global QUnit, SelectBox */
/* eslint global-strict: 0, strict: 0 */
'use strict';
QUnit.module('admin.SelectBox');
QUnit.test('init: no options', function(assert) {
var $ = django.jQuery;
$('').appendTo('#qunit-fixture');
SelectBox.init('id');
assert.equal(SelectBox.cache.id.length, 0);
});
QUnit.test('filter', function(assert) {
var $ = django.jQuery;
$('').appendTo('#qunit-fixture');
$('').appendTo('#id');
$('').appendTo('#id');
SelectBox.init('id');
assert.equal($('#id option').length, 2);
SelectBox.filter('id', "A");
assert.equal($('#id option').length, 1);
assert.equal($('#id option').text(), "A");
});
Django-1.11.11/js_tests/admin/jsi18n-mocks.test.js 0000664 0001750 0001750 00000005220 13247520251 021154 0 ustar tim tim 0000000 0000000 (function(globals) {
'use strict';
var django = globals.django || (globals.django = {});
django.pluralidx = function(count) { return (count === 1) ? 0 : 1; };
/* gettext identity library */
django.gettext = function(msgid) { return msgid; };
django.ngettext = function(singular, plural, count) {
return (count === 1) ? singular : plural;
};
django.gettext_noop = function(msgid) { return msgid; };
django.pgettext = function(context, msgid) { return msgid; };
django.npgettext = function(context, singular, plural, count) {
return (count === 1) ? singular : plural;
};
django.interpolate = function(fmt, obj, named) {
if (named) {
return fmt.replace(/%\(\w+\)s/g, function(match) {
return String(obj[match.slice(2, -2)]);
});
} else {
return fmt.replace(/%s/g, function(match) {
return String(obj.shift());
});
}
};
/* formatting library */
django.formats = {
"DATETIME_FORMAT": "N j, Y, P",
"DATETIME_INPUT_FORMATS": [
"%Y-%m-%d %H:%M:%S",
"%Y-%m-%d %H:%M:%S.%f",
"%Y-%m-%d %H:%M",
"%Y-%m-%d",
"%m/%d/%Y %H:%M:%S",
"%m/%d/%Y %H:%M:%S.%f",
"%m/%d/%Y %H:%M",
"%m/%d/%Y",
"%m/%d/%y %H:%M:%S",
"%m/%d/%y %H:%M:%S.%f",
"%m/%d/%y %H:%M",
"%m/%d/%y"
],
"DATE_FORMAT": "N j, Y",
"DATE_INPUT_FORMATS": [
"%Y-%m-%d",
"%m/%d/%Y",
"%m/%d/%y"
],
"DECIMAL_SEPARATOR": ".",
"FIRST_DAY_OF_WEEK": "0",
"MONTH_DAY_FORMAT": "F j",
"NUMBER_GROUPING": "3",
"SHORT_DATETIME_FORMAT": "m/d/Y P",
"SHORT_DATE_FORMAT": "m/d/Y",
"THOUSAND_SEPARATOR": ",",
"TIME_FORMAT": "P",
"TIME_INPUT_FORMATS": [
"%H:%M:%S",
"%H:%M:%S.%f",
"%H:%M"
],
"YEAR_MONTH_FORMAT": "F Y"
};
django.get_format = function(format_type) {
var value = django.formats[format_type];
if (typeof value === 'undefined') {
return format_type;
} else {
return value;
}
};
/* add to global namespace */
globals.pluralidx = django.pluralidx;
globals.gettext = django.gettext;
globals.ngettext = django.ngettext;
globals.gettext_noop = django.gettext_noop;
globals.pgettext = django.pgettext;
globals.npgettext = django.npgettext;
globals.interpolate = django.interpolate;
globals.get_format = django.get_format;
}(this));
Django-1.11.11/js_tests/admin/SelectFilter2.test.js 0000664 0001750 0001750 00000001377 13247517144 021415 0 ustar tim tim 0000000 0000000 /* global QUnit, SelectFilter */
/* eslint global-strict: 0, strict: 0 */
'use strict';
QUnit.module('admin.SelectFilter2');
QUnit.test('init', function(assert) {
var $ = django.jQuery;
$('
').appendTo('#qunit-fixture');
$('').appendTo('#id');
SelectFilter.init('id', 'things', 0);
assert.equal($('.selector-available h2').text().trim(), "Available things");
assert.equal($('.selector-chosen h2').text().trim(), "Chosen things");
assert.equal($('.selector-chooseall').text(), "Choose all");
assert.equal($('.selector-add').text(), "Choose");
assert.equal($('.selector-remove').text(), "Remove");
assert.equal($('.selector-clearall').text(), "Remove all");
});
Django-1.11.11/js_tests/admin/RelatedObjectLookups.test.js 0000664 0001750 0001750 00000001016 13247517144 023020 0 ustar tim tim 0000000 0000000 /* global QUnit, id_to_windowname,
windowname_to_id */
/* eslint global-strict: 0, strict: 0 */
'use strict';
QUnit.module('admin.RelatedObjectLookups');
QUnit.test('id_to_windowname', function(assert) {
assert.equal(id_to_windowname('.test'), '__dot__test');
assert.equal(id_to_windowname('misc-test'), 'misc__dash__test');
});
QUnit.test('windowname_to_id', function(assert) {
assert.equal(windowname_to_id('__dot__test'), '.test');
assert.equal(windowname_to_id('misc__dash__test'), 'misc-test');
});
Django-1.11.11/js_tests/gis/ 0000775 0001750 0001750 00000000000 13247520353 015110 5 ustar tim tim 0000000 0000000 Django-1.11.11/js_tests/gis/mapwidget.test.js 0000664 0001750 0001750 00000007126 13247517144 020417 0 ustar tim tim 0000000 0000000 /* global QUnit, MapWidget */
/* eslint global-strict: 0, strict: 0 */
'use strict';
QUnit.module('gis.OLMapWidget');
QUnit.test('MapWidget.featureAdded', function(assert) {
var options = {id: 'id_point', map_id: 'id_point_map', geom_name: 'Point'};
var widget = new MapWidget(options);
assert.equal(widget.featureCollection.getLength(), 1);
widget.serializeFeatures();
assert.equal(
document.getElementById('id_point').value,
'{"type":"Point","coordinates":[7.8177,47.397]}',
'Point added to vector layer'
);
});
QUnit.test('MapWidget.map_srid', function(assert) {
var options = {id: 'id_point', map_id: 'id_point_map', geom_name: 'Point'};
var widget = new MapWidget(options);
assert.equal(widget.map.getView().getProjection().getCode(), 'EPSG:3857', 'SRID 3857');
});
QUnit.test('MapWidget.defaultCenter', function(assert) {
var options = {id: 'id_point', map_id: 'id_point_map', geom_name: 'Point'};
var widget = new MapWidget(options);
assert.equal(widget.defaultCenter().toString(), '0,0', 'Default center at 0, 0');
options.default_lat = 47.08;
options.default_lon = 6.81;
widget = new MapWidget(options);
assert.equal(
widget.defaultCenter().toString(),
'6.81,47.08',
'Default center at 6.81, 47.08'
);
assert.equal(widget.map.getView().getZoom(), 12);
});
QUnit.test('MapWidget.interactions', function(assert) {
var options = {id: 'id_point', map_id: 'id_point_map', geom_name: 'Point'};
var widget = new MapWidget(options);
assert.equal(Object.keys(widget.interactions).length, 2);
assert.equal(widget.interactions.draw.getActive(), false, "Draw is inactive with an existing point");
assert.equal(widget.interactions.modify.getActive(), true, "Modify is active with an existing point");
});
QUnit.test('MapWidget.clearFeatures', function(assert) {
var options = {id: 'id_point', map_id: 'id_point_map', geom_name: 'Point'};
var widget = new MapWidget(options);
var initial_value = document.getElementById('id_point').value;
widget.clearFeatures();
assert.equal(document.getElementById('id_point').value, "");
document.getElementById('id_point').value = initial_value;
});
QUnit.test('MapWidget.multipolygon', function(assert) {
var options = {id: 'id_multipolygon', map_id: 'id_multipolygon_map', geom_name: 'MultiPolygon'};
var widget = new MapWidget(options);
assert.ok(widget.options.is_collection);
assert.equal(widget.interactions.draw.getActive(), true, "Draw is active with no existing content");
});
QUnit.test('MapWidget.IsCollection', function(assert) {
var options = {id: 'id_point', map_id: 'id_point_map', geom_name: 'Point'};
var widget = new MapWidget(options);
assert.notOk(widget.options.is_collection);
// Empty the default initial Point
document.getElementById('id_point').value = "";
options.geom_name = 'Polygon';
widget = new MapWidget(options);
assert.notOk(widget.options.is_collection);
options.geom_name = 'LineString';
widget = new MapWidget(options);
assert.notOk(widget.options.is_collection);
options.geom_name = 'MultiPoint';
widget = new MapWidget(options);
assert.ok(widget.options.is_collection);
options.geom_name = 'MultiPolygon';
widget = new MapWidget(options);
assert.ok(widget.options.is_collection);
options.geom_name = 'MultiLineString';
widget = new MapWidget(options);
assert.ok(widget.options.is_collection);
options.geom_name = 'GeometryCollection';
widget = new MapWidget(options);
assert.ok(widget.options.is_collection);
});
Django-1.11.11/js_tests/qunit/ 0000775 0001750 0001750 00000000000 13247520353 015466 5 ustar tim tim 0000000 0000000 Django-1.11.11/js_tests/qunit/qunit.js 0000664 0001750 0001750 00000346075 13247517144 017207 0 ustar tim tim 0000000 0000000 /*!
* QUnit 2.0.1
* https://qunitjs.com/
*
* Copyright jQuery Foundation and other contributors
* Released under the MIT license
* https://jquery.org/license
*
* Date: 2016-07-23T19:39Z
*/
( function( global ) {
var QUnit = {};
var Date = global.Date;
var now = Date.now || function() {
return new Date().getTime();
};
var setTimeout = global.setTimeout;
var clearTimeout = global.clearTimeout;
// Store a local window from the global to allow direct references.
var window = global.window;
var defined = {
document: window && window.document !== undefined,
setTimeout: setTimeout !== undefined,
sessionStorage: ( function() {
var x = "qunit-test-string";
try {
sessionStorage.setItem( x, x );
sessionStorage.removeItem( x );
return true;
} catch ( e ) {
return false;
}
}() )
};
var fileName = ( sourceFromStacktrace( 0 ) || "" ).replace( /(:\d+)+\)?/, "" ).replace( /.+\//, "" );
var globalStartCalled = false;
var runStarted = false;
var autorun = false;
var toString = Object.prototype.toString,
hasOwn = Object.prototype.hasOwnProperty;
// Returns a new Array with the elements that are in a but not in b
function diff( a, b ) {
var i, j,
result = a.slice();
for ( i = 0; i < result.length; i++ ) {
for ( j = 0; j < b.length; j++ ) {
if ( result[ i ] === b[ j ] ) {
result.splice( i, 1 );
i--;
break;
}
}
}
return result;
}
// From jquery.js
function inArray( elem, array ) {
if ( array.indexOf ) {
return array.indexOf( elem );
}
for ( var i = 0, length = array.length; i < length; i++ ) {
if ( array[ i ] === elem ) {
return i;
}
}
return -1;
}
/**
* Makes a clone of an object using only Array or Object as base,
* and copies over the own enumerable properties.
*
* @param {Object} obj
* @return {Object} New object with only the own properties (recursively).
*/
function objectValues ( obj ) {
var key, val,
vals = QUnit.is( "array", obj ) ? [] : {};
for ( key in obj ) {
if ( hasOwn.call( obj, key ) ) {
val = obj[ key ];
vals[ key ] = val === Object( val ) ? objectValues( val ) : val;
}
}
return vals;
}
function extend( a, b, undefOnly ) {
for ( var prop in b ) {
if ( hasOwn.call( b, prop ) ) {
if ( b[ prop ] === undefined ) {
delete a[ prop ];
} else if ( !( undefOnly && typeof a[ prop ] !== "undefined" ) ) {
a[ prop ] = b[ prop ];
}
}
}
return a;
}
function objectType( obj ) {
if ( typeof obj === "undefined" ) {
return "undefined";
}
// Consider: typeof null === object
if ( obj === null ) {
return "null";
}
var match = toString.call( obj ).match( /^\[object\s(.*)\]$/ ),
type = match && match[ 1 ];
switch ( type ) {
case "Number":
if ( isNaN( obj ) ) {
return "nan";
}
return "number";
case "String":
case "Boolean":
case "Array":
case "Set":
case "Map":
case "Date":
case "RegExp":
case "Function":
case "Symbol":
return type.toLowerCase();
}
if ( typeof obj === "object" ) {
return "object";
}
}
// Safe object type checking
function is( type, obj ) {
return QUnit.objectType( obj ) === type;
}
// Doesn't support IE9, it will return undefined on these browsers
// See also https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error/Stack
function extractStacktrace( e, offset ) {
offset = offset === undefined ? 4 : offset;
var stack, include, i;
if ( e.stack ) {
stack = e.stack.split( "\n" );
if ( /^error$/i.test( stack[ 0 ] ) ) {
stack.shift();
}
if ( fileName ) {
include = [];
for ( i = offset; i < stack.length; i++ ) {
if ( stack[ i ].indexOf( fileName ) !== -1 ) {
break;
}
include.push( stack[ i ] );
}
if ( include.length ) {
return include.join( "\n" );
}
}
return stack[ offset ];
}
}
function sourceFromStacktrace( offset ) {
var error = new Error();
// Support: Safari <=7 only, IE <=10 - 11 only
// Not all browsers generate the `stack` property for `new Error()`, see also #636
if ( !error.stack ) {
try {
throw error;
} catch ( err ) {
error = err;
}
}
return extractStacktrace( error, offset );
}
/**
* Config object: Maintain internal state
* Later exposed as QUnit.config
* `config` initialized at top of scope
*/
var config = {
// The queue of tests to run
queue: [],
// Block until document ready
blocking: true,
// By default, run previously failed tests first
// very useful in combination with "Hide passed tests" checked
reorder: true,
// By default, modify document.title when suite is done
altertitle: true,
// HTML Reporter: collapse every test except the first failing test
// If false, all failing tests will be expanded
collapse: true,
// By default, scroll to top of the page when suite is done
scrolltop: true,
// Depth up-to which object will be dumped
maxDepth: 5,
// When enabled, all tests must call expect()
requireExpects: false,
// Placeholder for user-configurable form-exposed URL parameters
urlConfig: [],
// Set of all modules.
modules: [],
// Stack of nested modules
moduleStack: [],
// The first unnamed module
currentModule: {
name: "",
tests: []
},
callbacks: {}
};
// Push a loose unnamed module to the modules collection
config.modules.push( config.currentModule );
// Register logging callbacks
function registerLoggingCallbacks( obj ) {
var i, l, key,
callbackNames = [ "begin", "done", "log", "testStart", "testDone",
"moduleStart", "moduleDone" ];
function registerLoggingCallback( key ) {
var loggingCallback = function( callback ) {
if ( objectType( callback ) !== "function" ) {
throw new Error(
"QUnit logging methods require a callback function as their first parameters."
);
}
config.callbacks[ key ].push( callback );
};
return loggingCallback;
}
for ( i = 0, l = callbackNames.length; i < l; i++ ) {
key = callbackNames[ i ];
// Initialize key collection of logging callback
if ( objectType( config.callbacks[ key ] ) === "undefined" ) {
config.callbacks[ key ] = [];
}
obj[ key ] = registerLoggingCallback( key );
}
}
function runLoggingCallbacks( key, args ) {
var i, l, callbacks;
callbacks = config.callbacks[ key ];
for ( i = 0, l = callbacks.length; i < l; i++ ) {
callbacks[ i ]( args );
}
}
( function() {
if ( !defined.document ) {
return;
}
// `onErrorFnPrev` initialized at top of scope
// Preserve other handlers
var onErrorFnPrev = window.onerror;
// Cover uncaught exceptions
// Returning true will suppress the default browser handler,
// returning false will let it run.
window.onerror = function( error, filePath, linerNr ) {
var ret = false;
if ( onErrorFnPrev ) {
ret = onErrorFnPrev( error, filePath, linerNr );
}
// Treat return value as window.onerror itself does,
// Only do our handling if not suppressed.
if ( ret !== true ) {
if ( QUnit.config.current ) {
if ( QUnit.config.current.ignoreGlobalErrors ) {
return true;
}
QUnit.pushFailure( error, filePath + ":" + linerNr );
} else {
QUnit.test( "global failure", extend( function() {
QUnit.pushFailure( error, filePath + ":" + linerNr );
}, { validTest: true } ) );
}
return false;
}
return ret;
};
}() );
// Figure out if we're running the tests from a server or not
QUnit.isLocal = !( defined.document && window.location.protocol !== "file:" );
// Expose the current QUnit version
QUnit.version = "2.0.1";
extend( QUnit, {
// Call on start of module test to prepend name to all tests
module: function( name, testEnvironment, executeNow ) {
var module, moduleFns;
var currentModule = config.currentModule;
if ( arguments.length === 2 ) {
if ( objectType( testEnvironment ) === "function" ) {
executeNow = testEnvironment;
testEnvironment = undefined;
}
}
module = createModule();
if ( testEnvironment && ( testEnvironment.setup || testEnvironment.teardown ) ) {
console.warn(
"Module's `setup` and `teardown` are not hooks anymore on QUnit 2.0, use " +
"`beforeEach` and `afterEach` instead\n" +
"Details in our upgrade guide at https://qunitjs.com/upgrade-guide-2.x/"
);
}
moduleFns = {
before: setHook( module, "before" ),
beforeEach: setHook( module, "beforeEach" ),
afterEach: setHook( module, "afterEach" ),
after: setHook( module, "after" )
};
if ( objectType( executeNow ) === "function" ) {
config.moduleStack.push( module );
setCurrentModule( module );
executeNow.call( module.testEnvironment, moduleFns );
config.moduleStack.pop();
module = module.parentModule || currentModule;
}
setCurrentModule( module );
function createModule() {
var parentModule = config.moduleStack.length ?
config.moduleStack.slice( -1 )[ 0 ] : null;
var moduleName = parentModule !== null ?
[ parentModule.name, name ].join( " > " ) : name;
var module = {
name: moduleName,
parentModule: parentModule,
tests: [],
moduleId: generateHash( moduleName ),
testsRun: 0
};
var env = {};
if ( parentModule ) {
parentModule.childModule = module;
extend( env, parentModule.testEnvironment );
delete env.beforeEach;
delete env.afterEach;
}
extend( env, testEnvironment );
module.testEnvironment = env;
config.modules.push( module );
return module;
}
function setCurrentModule( module ) {
config.currentModule = module;
}
},
test: test,
skip: skip,
only: only,
start: function( count ) {
var globalStartAlreadyCalled = globalStartCalled;
if ( !config.current ) {
globalStartCalled = true;
if ( runStarted ) {
throw new Error( "Called start() while test already started running" );
} else if ( globalStartAlreadyCalled || count > 1 ) {
throw new Error( "Called start() outside of a test context too many times" );
} else if ( config.autostart ) {
throw new Error( "Called start() outside of a test context when " +
"QUnit.config.autostart was true" );
} else if ( !config.pageLoaded ) {
// The page isn't completely loaded yet, so bail out and let `QUnit.load` handle it
config.autostart = true;
return;
}
} else {
throw new Error(
"QUnit.start cannot be called inside a test context. This feature is removed in " +
"QUnit 2.0. For async tests, use QUnit.test() with assert.async() instead.\n" +
"Details in our upgrade guide at https://qunitjs.com/upgrade-guide-2.x/"
);
}
scheduleBegin();
},
config: config,
is: is,
objectType: objectType,
extend: extend,
load: function() {
config.pageLoaded = true;
// Initialize the configuration options
extend( config, {
stats: { all: 0, bad: 0 },
moduleStats: { all: 0, bad: 0 },
started: 0,
updateRate: 1000,
autostart: true,
filter: ""
}, true );
if ( !runStarted ) {
config.blocking = false;
if ( config.autostart ) {
scheduleBegin();
}
}
},
stack: function( offset ) {
offset = ( offset || 0 ) + 2;
return sourceFromStacktrace( offset );
}
} );
registerLoggingCallbacks( QUnit );
function scheduleBegin() {
runStarted = true;
// Add a slight delay to allow definition of more modules and tests.
if ( defined.setTimeout ) {
setTimeout( function() {
begin();
}, 13 );
} else {
begin();
}
}
function begin() {
var i, l,
modulesLog = [];
// If the test run hasn't officially begun yet
if ( !config.started ) {
// Record the time of the test run's beginning
config.started = now();
// Delete the loose unnamed module if unused.
if ( config.modules[ 0 ].name === "" && config.modules[ 0 ].tests.length === 0 ) {
config.modules.shift();
}
// Avoid unnecessary information by not logging modules' test environments
for ( i = 0, l = config.modules.length; i < l; i++ ) {
modulesLog.push( {
name: config.modules[ i ].name,
tests: config.modules[ i ].tests
} );
}
// The test run is officially beginning now
runLoggingCallbacks( "begin", {
totalTests: Test.count,
modules: modulesLog
} );
}
config.blocking = false;
process( true );
}
function process( last ) {
function next() {
process( last );
}
var start = now();
config.depth = ( config.depth || 0 ) + 1;
while ( config.queue.length && !config.blocking ) {
if ( !defined.setTimeout || config.updateRate <= 0 ||
( ( now() - start ) < config.updateRate ) ) {
if ( config.current ) {
// Reset async tracking for each phase of the Test lifecycle
config.current.usedAsync = false;
}
config.queue.shift()();
} else {
setTimeout( next, 13 );
break;
}
}
config.depth--;
if ( last && !config.blocking && !config.queue.length && config.depth === 0 ) {
done();
}
}
function done() {
var runtime, passed;
autorun = true;
// Log the last module results
if ( config.previousModule ) {
runLoggingCallbacks( "moduleDone", {
name: config.previousModule.name,
tests: config.previousModule.tests,
failed: config.moduleStats.bad,
passed: config.moduleStats.all - config.moduleStats.bad,
total: config.moduleStats.all,
runtime: now() - config.moduleStats.started
} );
}
delete config.previousModule;
runtime = now() - config.started;
passed = config.stats.all - config.stats.bad;
runLoggingCallbacks( "done", {
failed: config.stats.bad,
passed: passed,
total: config.stats.all,
runtime: runtime
} );
}
function setHook( module, hookName ) {
if ( module.testEnvironment === undefined ) {
module.testEnvironment = {};
}
return function( callback ) {
module.testEnvironment[ hookName ] = callback;
};
}
var unitSampler,
focused = false,
priorityCount = 0;
function Test( settings ) {
var i, l;
++Test.count;
this.expected = null;
extend( this, settings );
this.assertions = [];
this.semaphore = 0;
this.usedAsync = false;
this.module = config.currentModule;
this.stack = sourceFromStacktrace( 3 );
// Register unique strings
for ( i = 0, l = this.module.tests; i < l.length; i++ ) {
if ( this.module.tests[ i ].name === this.testName ) {
this.testName += " ";
}
}
this.testId = generateHash( this.module.name, this.testName );
this.module.tests.push( {
name: this.testName,
testId: this.testId
} );
if ( settings.skip ) {
// Skipped tests will fully ignore any sent callback
this.callback = function() {};
this.async = false;
this.expected = 0;
} else {
this.assert = new Assert( this );
}
}
Test.count = 0;
Test.prototype = {
before: function() {
if (
// Emit moduleStart when we're switching from one module to another
this.module !== config.previousModule ||
// They could be equal (both undefined) but if the previousModule property doesn't
// yet exist it means this is the first test in a suite that isn't wrapped in a
// module, in which case we'll just emit a moduleStart event for 'undefined'.
// Without this, reporters can get testStart before moduleStart which is a problem.
!hasOwn.call( config, "previousModule" )
) {
if ( hasOwn.call( config, "previousModule" ) ) {
runLoggingCallbacks( "moduleDone", {
name: config.previousModule.name,
tests: config.previousModule.tests,
failed: config.moduleStats.bad,
passed: config.moduleStats.all - config.moduleStats.bad,
total: config.moduleStats.all,
runtime: now() - config.moduleStats.started
} );
}
config.previousModule = this.module;
config.moduleStats = { all: 0, bad: 0, started: now() };
runLoggingCallbacks( "moduleStart", {
name: this.module.name,
tests: this.module.tests
} );
}
config.current = this;
if ( this.module.testEnvironment ) {
delete this.module.testEnvironment.before;
delete this.module.testEnvironment.beforeEach;
delete this.module.testEnvironment.afterEach;
delete this.module.testEnvironment.after;
}
this.testEnvironment = extend( {}, this.module.testEnvironment );
this.started = now();
runLoggingCallbacks( "testStart", {
name: this.testName,
module: this.module.name,
testId: this.testId
} );
if ( !config.pollution ) {
saveGlobal();
}
},
run: function() {
var promise;
config.current = this;
this.callbackStarted = now();
if ( config.notrycatch ) {
runTest( this );
return;
}
try {
runTest( this );
} catch ( e ) {
this.pushFailure( "Died on test #" + ( this.assertions.length + 1 ) + " " +
this.stack + ": " + ( e.message || e ), extractStacktrace( e, 0 ) );
// Else next test will carry the responsibility
saveGlobal();
// Restart the tests if they're blocking
if ( config.blocking ) {
internalRecover( this );
}
}
function runTest( test ) {
promise = test.callback.call( test.testEnvironment, test.assert );
test.resolvePromise( promise );
}
},
after: function() {
checkPollution();
},
queueHook: function( hook, hookName, hookOwner ) {
var promise,
test = this;
return function runHook() {
if ( hookName === "before" ) {
if ( hookOwner.testsRun !== 0 ) {
return;
}
test.preserveEnvironment = true;
}
if ( hookName === "after" && hookOwner.testsRun !== numberOfTests( hookOwner ) - 1 ) {
return;
}
config.current = test;
if ( config.notrycatch ) {
callHook();
return;
}
try {
callHook();
} catch ( error ) {
test.pushFailure( hookName + " failed on " + test.testName + ": " +
( error.message || error ), extractStacktrace( error, 0 ) );
}
function callHook() {
promise = hook.call( test.testEnvironment, test.assert );
test.resolvePromise( promise, hookName );
}
};
},
// Currently only used for module level hooks, can be used to add global level ones
hooks: function( handler ) {
var hooks = [];
function processHooks( test, module ) {
if ( module.parentModule ) {
processHooks( test, module.parentModule );
}
if ( module.testEnvironment &&
QUnit.objectType( module.testEnvironment[ handler ] ) === "function" ) {
hooks.push( test.queueHook( module.testEnvironment[ handler ], handler, module ) );
}
}
// Hooks are ignored on skipped tests
if ( !this.skip ) {
processHooks( this, this.module );
}
return hooks;
},
finish: function() {
config.current = this;
if ( config.requireExpects && this.expected === null ) {
this.pushFailure( "Expected number of assertions to be defined, but expect() was " +
"not called.", this.stack );
} else if ( this.expected !== null && this.expected !== this.assertions.length ) {
this.pushFailure( "Expected " + this.expected + " assertions, but " +
this.assertions.length + " were run", this.stack );
} else if ( this.expected === null && !this.assertions.length ) {
this.pushFailure( "Expected at least one assertion, but none were run - call " +
"expect(0) to accept zero assertions.", this.stack );
}
var i,
skipped = !!this.skip,
bad = 0;
this.runtime = now() - this.started;
config.stats.all += this.assertions.length;
config.moduleStats.all += this.assertions.length;
for ( i = 0; i < this.assertions.length; i++ ) {
if ( !this.assertions[ i ].result ) {
bad++;
config.stats.bad++;
config.moduleStats.bad++;
}
}
notifyTestsRan( this.module );
runLoggingCallbacks( "testDone", {
name: this.testName,
module: this.module.name,
skipped: skipped,
failed: bad,
passed: this.assertions.length - bad,
total: this.assertions.length,
runtime: skipped ? 0 : this.runtime,
// HTML Reporter use
assertions: this.assertions,
testId: this.testId,
// Source of Test
source: this.stack
} );
config.current = undefined;
},
preserveTestEnvironment: function() {
if ( this.preserveEnvironment ) {
this.module.testEnvironment = this.testEnvironment;
this.testEnvironment = extend( {}, this.module.testEnvironment );
}
},
queue: function() {
var priority,
test = this;
if ( !this.valid() ) {
return;
}
function run() {
// Each of these can by async
synchronize( [
function() {
test.before();
},
test.hooks( "before" ),
function() {
test.preserveTestEnvironment();
},
test.hooks( "beforeEach" ),
function() {
test.run();
},
test.hooks( "afterEach" ).reverse(),
test.hooks( "after" ).reverse(),
function() {
test.after();
},
function() {
test.finish();
}
] );
}
// Prioritize previously failed tests, detected from sessionStorage
priority = QUnit.config.reorder && defined.sessionStorage &&
+sessionStorage.getItem( "qunit-test-" + this.module.name + "-" + this.testName );
return synchronize( run, priority, config.seed );
},
pushResult: function( resultInfo ) {
// Destructure of resultInfo = { result, actual, expected, message, negative }
var source,
details = {
module: this.module.name,
name: this.testName,
result: resultInfo.result,
message: resultInfo.message,
actual: resultInfo.actual,
expected: resultInfo.expected,
testId: this.testId,
negative: resultInfo.negative || false,
runtime: now() - this.started
};
if ( !resultInfo.result ) {
source = sourceFromStacktrace();
if ( source ) {
details.source = source;
}
}
runLoggingCallbacks( "log", details );
this.assertions.push( {
result: !!resultInfo.result,
message: resultInfo.message
} );
},
pushFailure: function( message, source, actual ) {
if ( !( this instanceof Test ) ) {
throw new Error( "pushFailure() assertion outside test context, was " +
sourceFromStacktrace( 2 ) );
}
var details = {
module: this.module.name,
name: this.testName,
result: false,
message: message || "error",
actual: actual || null,
testId: this.testId,
runtime: now() - this.started
};
if ( source ) {
details.source = source;
}
runLoggingCallbacks( "log", details );
this.assertions.push( {
result: false,
message: message
} );
},
resolvePromise: function( promise, phase ) {
var then, resume, message,
test = this;
if ( promise != null ) {
then = promise.then;
if ( QUnit.objectType( then ) === "function" ) {
resume = internalStop( test );
then.call(
promise,
function() { resume(); },
function( error ) {
message = "Promise rejected " +
( !phase ? "during" : phase.replace( /Each$/, "" ) ) +
" " + test.testName + ": " + ( error.message || error );
test.pushFailure( message, extractStacktrace( error, 0 ) );
// Else next test will carry the responsibility
saveGlobal();
// Unblock
resume();
}
);
}
}
},
valid: function() {
var filter = config.filter,
regexFilter = /^(!?)\/([\w\W]*)\/(i?$)/.exec( filter ),
module = config.module && config.module.toLowerCase(),
fullName = ( this.module.name + ": " + this.testName );
function moduleChainNameMatch( testModule ) {
var testModuleName = testModule.name ? testModule.name.toLowerCase() : null;
if ( testModuleName === module ) {
return true;
} else if ( testModule.parentModule ) {
return moduleChainNameMatch( testModule.parentModule );
} else {
return false;
}
}
function moduleChainIdMatch( testModule ) {
return inArray( testModule.moduleId, config.moduleId ) > -1 ||
testModule.parentModule && moduleChainIdMatch( testModule.parentModule );
}
// Internally-generated tests are always valid
if ( this.callback && this.callback.validTest ) {
return true;
}
if ( config.moduleId && config.moduleId.length > 0 &&
!moduleChainIdMatch( this.module ) ) {
return false;
}
if ( config.testId && config.testId.length > 0 &&
inArray( this.testId, config.testId ) < 0 ) {
return false;
}
if ( module && !moduleChainNameMatch( this.module ) ) {
return false;
}
if ( !filter ) {
return true;
}
return regexFilter ?
this.regexFilter( !!regexFilter[ 1 ], regexFilter[ 2 ], regexFilter[ 3 ], fullName ) :
this.stringFilter( filter, fullName );
},
regexFilter: function( exclude, pattern, flags, fullName ) {
var regex = new RegExp( pattern, flags );
var match = regex.test( fullName );
return match !== exclude;
},
stringFilter: function( filter, fullName ) {
filter = filter.toLowerCase();
fullName = fullName.toLowerCase();
var include = filter.charAt( 0 ) !== "!";
if ( !include ) {
filter = filter.slice( 1 );
}
// If the filter matches, we need to honour include
if ( fullName.indexOf( filter ) !== -1 ) {
return include;
}
// Otherwise, do the opposite
return !include;
}
};
QUnit.pushFailure = function() {
if ( !QUnit.config.current ) {
throw new Error( "pushFailure() assertion outside test context, in " +
sourceFromStacktrace( 2 ) );
}
// Gets current test obj
var currentTest = QUnit.config.current;
return currentTest.pushFailure.apply( currentTest, arguments );
};
// Based on Java's String.hashCode, a simple but not
// rigorously collision resistant hashing function
function generateHash( module, testName ) {
var hex,
i = 0,
hash = 0,
str = module + "\x1C" + testName,
len = str.length;
for ( ; i < len; i++ ) {
hash = ( ( hash << 5 ) - hash ) + str.charCodeAt( i );
hash |= 0;
}
// Convert the possibly negative integer hash code into an 8 character hex string, which isn't
// strictly necessary but increases user understanding that the id is a SHA-like hash
hex = ( 0x100000000 + hash ).toString( 16 );
if ( hex.length < 8 ) {
hex = "0000000" + hex;
}
return hex.slice( -8 );
}
function synchronize( callback, priority, seed ) {
var last = !priority,
index;
if ( QUnit.objectType( callback ) === "array" ) {
while ( callback.length ) {
synchronize( callback.shift() );
}
return;
}
if ( priority ) {
config.queue.splice( priorityCount++, 0, callback );
} else if ( seed ) {
if ( !unitSampler ) {
unitSampler = unitSamplerGenerator( seed );
}
// Insert into a random position after all priority items
index = Math.floor( unitSampler() * ( config.queue.length - priorityCount + 1 ) );
config.queue.splice( priorityCount + index, 0, callback );
} else {
config.queue.push( callback );
}
if ( autorun && !config.blocking ) {
process( last );
}
}
function unitSamplerGenerator( seed ) {
// 32-bit xorshift, requires only a nonzero seed
// http://excamera.com/sphinx/article-xorshift.html
var sample = parseInt( generateHash( seed ), 16 ) || -1;
return function() {
sample ^= sample << 13;
sample ^= sample >>> 17;
sample ^= sample << 5;
// ECMAScript has no unsigned number type
if ( sample < 0 ) {
sample += 0x100000000;
}
return sample / 0x100000000;
};
}
function saveGlobal() {
config.pollution = [];
if ( config.noglobals ) {
for ( var key in global ) {
if ( hasOwn.call( global, key ) ) {
// In Opera sometimes DOM element ids show up here, ignore them
if ( /^qunit-test-output/.test( key ) ) {
continue;
}
config.pollution.push( key );
}
}
}
}
function checkPollution() {
var newGlobals,
deletedGlobals,
old = config.pollution;
saveGlobal();
newGlobals = diff( config.pollution, old );
if ( newGlobals.length > 0 ) {
QUnit.pushFailure( "Introduced global variable(s): " + newGlobals.join( ", " ) );
}
deletedGlobals = diff( old, config.pollution );
if ( deletedGlobals.length > 0 ) {
QUnit.pushFailure( "Deleted global variable(s): " + deletedGlobals.join( ", " ) );
}
}
// Will be exposed as QUnit.test
function test( testName, callback ) {
if ( focused ) { return; }
var newTest;
newTest = new Test( {
testName: testName,
callback: callback
} );
newTest.queue();
}
// Will be exposed as QUnit.skip
function skip( testName ) {
if ( focused ) { return; }
var test = new Test( {
testName: testName,
skip: true
} );
test.queue();
}
// Will be exposed as QUnit.only
function only( testName, callback ) {
var newTest;
if ( focused ) { return; }
QUnit.config.queue.length = 0;
focused = true;
newTest = new Test( {
testName: testName,
callback: callback
} );
newTest.queue();
}
// Put a hold on processing and return a function that will release it.
function internalStop( test ) {
var released = false;
test.semaphore += 1;
config.blocking = true;
// Set a recovery timeout, if so configured.
if ( config.testTimeout && defined.setTimeout ) {
clearTimeout( config.timeout );
config.timeout = setTimeout( function() {
QUnit.pushFailure( "Test timed out", sourceFromStacktrace( 2 ) );
internalRecover( test );
}, config.testTimeout );
}
return function resume() {
if ( released ) {
return;
}
released = true;
test.semaphore -= 1;
internalStart( test );
};
}
// Forcefully release all processing holds.
function internalRecover( test ) {
test.semaphore = 0;
internalStart( test );
}
// Release a processing hold, scheduling a resumption attempt if no holds remain.
function internalStart( test ) {
// If semaphore is non-numeric, throw error
if ( isNaN( test.semaphore ) ) {
test.semaphore = 0;
QUnit.pushFailure(
"Invalid value on test.semaphore",
sourceFromStacktrace( 2 )
);
return;
}
// Don't start until equal number of stop-calls
if ( test.semaphore > 0 ) {
return;
}
// Throw an Error if start is called more often than stop
if ( test.semaphore < 0 ) {
test.semaphore = 0;
QUnit.pushFailure(
"Tried to restart test while already started (test's semaphore was 0 already)",
sourceFromStacktrace( 2 )
);
return;
}
// Add a slight delay to allow more assertions etc.
if ( defined.setTimeout ) {
if ( config.timeout ) {
clearTimeout( config.timeout );
}
config.timeout = setTimeout( function() {
if ( test.semaphore > 0 ) {
return;
}
if ( config.timeout ) {
clearTimeout( config.timeout );
}
begin();
}, 13 );
} else {
begin();
}
}
function numberOfTests( module ) {
var count = module.tests.length;
while ( module = module.childModule ) {
count += module.tests.length;
}
return count;
}
function notifyTestsRan( module ) {
module.testsRun++;
while ( module = module.parentModule ) {
module.testsRun++;
}
}
function Assert( testContext ) {
this.test = testContext;
}
// Assert helpers
QUnit.assert = Assert.prototype = {
// Specify the number of expected assertions to guarantee that failed test
// (no assertions are run at all) don't slip through.
expect: function( asserts ) {
if ( arguments.length === 1 ) {
this.test.expected = asserts;
} else {
return this.test.expected;
}
},
// Put a hold on processing and return a function that will release it a maximum of once.
async: function( count ) {
var resume,
test = this.test,
popped = false,
acceptCallCount = count;
if ( typeof acceptCallCount === "undefined" ) {
acceptCallCount = 1;
}
test.usedAsync = true;
resume = internalStop( test );
return function done() {
if ( popped ) {
test.pushFailure( "Too many calls to the `assert.async` callback",
sourceFromStacktrace( 2 ) );
return;
}
acceptCallCount -= 1;
if ( acceptCallCount > 0 ) {
return;
}
popped = true;
resume();
};
},
// Exports test.push() to the user API
// Alias of pushResult.
push: function( result, actual, expected, message, negative ) {
var currentAssert = this instanceof Assert ? this : QUnit.config.current.assert;
return currentAssert.pushResult( {
result: result,
actual: actual,
expected: expected,
message: message,
negative: negative
} );
},
pushResult: function( resultInfo ) {
// Destructure of resultInfo = { result, actual, expected, message, negative }
var assert = this,
currentTest = ( assert instanceof Assert && assert.test ) || QUnit.config.current;
// Backwards compatibility fix.
// Allows the direct use of global exported assertions and QUnit.assert.*
// Although, it's use is not recommended as it can leak assertions
// to other tests from async tests, because we only get a reference to the current test,
// not exactly the test where assertion were intended to be called.
if ( !currentTest ) {
throw new Error( "assertion outside test context, in " + sourceFromStacktrace( 2 ) );
}
if ( currentTest.usedAsync === true && currentTest.semaphore === 0 ) {
currentTest.pushFailure( "Assertion after the final `assert.async` was resolved",
sourceFromStacktrace( 2 ) );
// Allow this assertion to continue running anyway...
}
if ( !( assert instanceof Assert ) ) {
assert = currentTest.assert;
}
return assert.test.pushResult( resultInfo );
},
ok: function( result, message ) {
message = message || ( result ? "okay" : "failed, expected argument to be truthy, was: " +
QUnit.dump.parse( result ) );
this.pushResult( {
result: !!result,
actual: result,
expected: true,
message: message
} );
},
notOk: function( result, message ) {
message = message || ( !result ? "okay" : "failed, expected argument to be falsy, was: " +
QUnit.dump.parse( result ) );
this.pushResult( {
result: !result,
actual: result,
expected: false,
message: message
} );
},
equal: function( actual, expected, message ) {
/*jshint eqeqeq:false */
this.pushResult( {
result: expected == actual,
actual: actual,
expected: expected,
message: message
} );
},
notEqual: function( actual, expected, message ) {
/*jshint eqeqeq:false */
this.pushResult( {
result: expected != actual,
actual: actual,
expected: expected,
message: message,
negative: true
} );
},
propEqual: function( actual, expected, message ) {
actual = objectValues( actual );
expected = objectValues( expected );
this.pushResult( {
result: QUnit.equiv( actual, expected ),
actual: actual,
expected: expected,
message: message
} );
},
notPropEqual: function( actual, expected, message ) {
actual = objectValues( actual );
expected = objectValues( expected );
this.pushResult( {
result: !QUnit.equiv( actual, expected ),
actual: actual,
expected: expected,
message: message,
negative: true
} );
},
deepEqual: function( actual, expected, message ) {
this.pushResult( {
result: QUnit.equiv( actual, expected ),
actual: actual,
expected: expected,
message: message
} );
},
notDeepEqual: function( actual, expected, message ) {
this.pushResult( {
result: !QUnit.equiv( actual, expected ),
actual: actual,
expected: expected,
message: message,
negative: true
} );
},
strictEqual: function( actual, expected, message ) {
this.pushResult( {
result: expected === actual,
actual: actual,
expected: expected,
message: message
} );
},
notStrictEqual: function( actual, expected, message ) {
this.pushResult( {
result: expected !== actual,
actual: actual,
expected: expected,
message: message,
negative: true
} );
},
"throws": function( block, expected, message ) {
var actual, expectedType,
expectedOutput = expected,
ok = false,
currentTest = ( this instanceof Assert && this.test ) || QUnit.config.current;
// 'expected' is optional unless doing string comparison
if ( QUnit.objectType( expected ) === "string" ) {
if ( message == null ) {
message = expected;
expected = null;
} else {
throw new Error(
"throws/raises does not accept a string value for the expected argument.\n" +
"Use a non-string object value (e.g. regExp) instead if it's necessary." +
"Details in our upgrade guide at https://qunitjs.com/upgrade-guide-2.x/"
);
}
}
currentTest.ignoreGlobalErrors = true;
try {
block.call( currentTest.testEnvironment );
} catch ( e ) {
actual = e;
}
currentTest.ignoreGlobalErrors = false;
if ( actual ) {
expectedType = QUnit.objectType( expected );
// We don't want to validate thrown error
if ( !expected ) {
ok = true;
expectedOutput = null;
// Expected is a regexp
} else if ( expectedType === "regexp" ) {
ok = expected.test( errorString( actual ) );
// Expected is a constructor, maybe an Error constructor
} else if ( expectedType === "function" && actual instanceof expected ) {
ok = true;
// Expected is an Error object
} else if ( expectedType === "object" ) {
ok = actual instanceof expected.constructor &&
actual.name === expected.name &&
actual.message === expected.message;
// Expected is a validation function which returns true if validation passed
} else if ( expectedType === "function" && expected.call( {}, actual ) === true ) {
expectedOutput = null;
ok = true;
}
}
currentTest.assert.pushResult( {
result: ok,
actual: actual,
expected: expectedOutput,
message: message
} );
}
};
// Provide an alternative to assert.throws(), for environments that consider throws a reserved word
// Known to us are: Closure Compiler, Narwhal
( function() {
/*jshint sub:true */
Assert.prototype.raises = Assert.prototype [ "throws" ]; //jscs:ignore requireDotNotation
}() );
function errorString( error ) {
var name, message,
resultErrorString = error.toString();
if ( resultErrorString.substring( 0, 7 ) === "[object" ) {
name = error.name ? error.name.toString() : "Error";
message = error.message ? error.message.toString() : "";
if ( name && message ) {
return name + ": " + message;
} else if ( name ) {
return name;
} else if ( message ) {
return message;
} else {
return "Error";
}
} else {
return resultErrorString;
}
}
// Test for equality any JavaScript type.
// Author: Philippe Rathé
QUnit.equiv = ( function() {
// Stack to decide between skip/abort functions
var callers = [];
// Stack to avoiding loops from circular referencing
var parents = [];
var parentsB = [];
var getProto = Object.getPrototypeOf || function( obj ) {
/*jshint proto: true */
return obj.__proto__;
};
function useStrictEquality( b, a ) {
// To catch short annotation VS 'new' annotation of a declaration. e.g.:
// `var i = 1;`
// `var j = new Number(1);`
if ( typeof a === "object" ) {
a = a.valueOf();
}
if ( typeof b === "object" ) {
b = b.valueOf();
}
return a === b;
}
function compareConstructors( a, b ) {
var protoA = getProto( a );
var protoB = getProto( b );
// Comparing constructors is more strict than using `instanceof`
if ( a.constructor === b.constructor ) {
return true;
}
// Ref #851
// If the obj prototype descends from a null constructor, treat it
// as a null prototype.
if ( protoA && protoA.constructor === null ) {
protoA = null;
}
if ( protoB && protoB.constructor === null ) {
protoB = null;
}
// Allow objects with no prototype to be equivalent to
// objects with Object as their constructor.
if ( ( protoA === null && protoB === Object.prototype ) ||
( protoB === null && protoA === Object.prototype ) ) {
return true;
}
return false;
}
function getRegExpFlags( regexp ) {
return "flags" in regexp ? regexp.flags : regexp.toString().match( /[gimuy]*$/ )[ 0 ];
}
var callbacks = {
"string": useStrictEquality,
"boolean": useStrictEquality,
"number": useStrictEquality,
"null": useStrictEquality,
"undefined": useStrictEquality,
"symbol": useStrictEquality,
"date": useStrictEquality,
"nan": function() {
return true;
},
"regexp": function( b, a ) {
return a.source === b.source &&
// Include flags in the comparison
getRegExpFlags( a ) === getRegExpFlags( b );
},
// - skip when the property is a method of an instance (OOP)
// - abort otherwise,
// initial === would have catch identical references anyway
"function": function() {
var caller = callers[ callers.length - 1 ];
return caller !== Object && typeof caller !== "undefined";
},
"array": function( b, a ) {
var i, j, len, loop, aCircular, bCircular;
len = a.length;
if ( len !== b.length ) {
// Safe and faster
return false;
}
// Track reference to avoid circular references
parents.push( a );
parentsB.push( b );
for ( i = 0; i < len; i++ ) {
loop = false;
for ( j = 0; j < parents.length; j++ ) {
aCircular = parents[ j ] === a[ i ];
bCircular = parentsB[ j ] === b[ i ];
if ( aCircular || bCircular ) {
if ( a[ i ] === b[ i ] || aCircular && bCircular ) {
loop = true;
} else {
parents.pop();
parentsB.pop();
return false;
}
}
}
if ( !loop && !innerEquiv( a[ i ], b[ i ] ) ) {
parents.pop();
parentsB.pop();
return false;
}
}
parents.pop();
parentsB.pop();
return true;
},
"set": function( b, a ) {
var innerEq,
outerEq = true;
if ( a.size !== b.size ) {
return false;
}
a.forEach( function( aVal ) {
innerEq = false;
b.forEach( function( bVal ) {
if ( innerEquiv( bVal, aVal ) ) {
innerEq = true;
}
} );
if ( !innerEq ) {
outerEq = false;
}
} );
return outerEq;
},
"map": function( b, a ) {
var innerEq,
outerEq = true;
if ( a.size !== b.size ) {
return false;
}
a.forEach( function( aVal, aKey ) {
innerEq = false;
b.forEach( function( bVal, bKey ) {
if ( innerEquiv( [ bVal, bKey ], [ aVal, aKey ] ) ) {
innerEq = true;
}
} );
if ( !innerEq ) {
outerEq = false;
}
} );
return outerEq;
},
"object": function( b, a ) {
var i, j, loop, aCircular, bCircular;
// Default to true
var eq = true;
var aProperties = [];
var bProperties = [];
if ( compareConstructors( a, b ) === false ) {
return false;
}
// Stack constructor before traversing properties
callers.push( a.constructor );
// Track reference to avoid circular references
parents.push( a );
parentsB.push( b );
// Be strict: don't ensure hasOwnProperty and go deep
for ( i in a ) {
loop = false;
for ( j = 0; j < parents.length; j++ ) {
aCircular = parents[ j ] === a[ i ];
bCircular = parentsB[ j ] === b[ i ];
if ( aCircular || bCircular ) {
if ( a[ i ] === b[ i ] || aCircular && bCircular ) {
loop = true;
} else {
eq = false;
break;
}
}
}
aProperties.push( i );
if ( !loop && !innerEquiv( a[ i ], b[ i ] ) ) {
eq = false;
break;
}
}
parents.pop();
parentsB.pop();
// Unstack, we are done
callers.pop();
for ( i in b ) {
// Collect b's properties
bProperties.push( i );
}
// Ensures identical properties name
return eq && innerEquiv( aProperties.sort(), bProperties.sort() );
}
};
function typeEquiv( a, b ) {
var type = QUnit.objectType( a );
return QUnit.objectType( b ) === type && callbacks[ type ]( b, a );
}
// The real equiv function
function innerEquiv( a, b ) {
// We're done when there's nothing more to compare
if ( arguments.length < 2 ) {
return true;
}
// Require type-specific equality
return ( a === b || typeEquiv( a, b ) ) &&
// ...across all consecutive argument pairs
( arguments.length === 2 || innerEquiv.apply( this, [].slice.call( arguments, 1 ) ) );
}
return innerEquiv;
}() );
// Based on jsDump by Ariel Flesler
// http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html
QUnit.dump = ( function() {
function quote( str ) {
return "\"" + str.toString().replace( /\\/g, "\\\\" ).replace( /"/g, "\\\"" ) + "\"";
}
function literal( o ) {
return o + "";
}
function join( pre, arr, post ) {
var s = dump.separator(),
base = dump.indent(),
inner = dump.indent( 1 );
if ( arr.join ) {
arr = arr.join( "," + s + inner );
}
if ( !arr ) {
return pre + post;
}
return [ pre, inner + arr, base + post ].join( s );
}
function array( arr, stack ) {
var i = arr.length,
ret = new Array( i );
if ( dump.maxDepth && dump.depth > dump.maxDepth ) {
return "[object Array]";
}
this.up();
while ( i-- ) {
ret[ i ] = this.parse( arr[ i ], undefined, stack );
}
this.down();
return join( "[", ret, "]" );
}
function isArray( obj ) {
return (
//Native Arrays
toString.call( obj ) === "[object Array]" ||
// NodeList objects
( typeof obj.length === "number" && obj.item !== undefined ) &&
( obj.length ?
obj.item( 0 ) === obj[ 0 ] :
( obj.item( 0 ) === null && obj[ 0 ] === undefined )
)
);
}
var reName = /^function (\w+)/,
dump = {
// The objType is used mostly internally, you can fix a (custom) type in advance
parse: function( obj, objType, stack ) {
stack = stack || [];
var res, parser, parserType,
inStack = inArray( obj, stack );
if ( inStack !== -1 ) {
return "recursion(" + ( inStack - stack.length ) + ")";
}
objType = objType || this.typeOf( obj );
parser = this.parsers[ objType ];
parserType = typeof parser;
if ( parserType === "function" ) {
stack.push( obj );
res = parser.call( this, obj, stack );
stack.pop();
return res;
}
return ( parserType === "string" ) ? parser : this.parsers.error;
},
typeOf: function( obj ) {
var type;
if ( obj === null ) {
type = "null";
} else if ( typeof obj === "undefined" ) {
type = "undefined";
} else if ( QUnit.is( "regexp", obj ) ) {
type = "regexp";
} else if ( QUnit.is( "date", obj ) ) {
type = "date";
} else if ( QUnit.is( "function", obj ) ) {
type = "function";
} else if ( obj.setInterval !== undefined &&
obj.document !== undefined &&
obj.nodeType === undefined ) {
type = "window";
} else if ( obj.nodeType === 9 ) {
type = "document";
} else if ( obj.nodeType ) {
type = "node";
} else if ( isArray( obj ) ) {
type = "array";
} else if ( obj.constructor === Error.prototype.constructor ) {
type = "error";
} else {
type = typeof obj;
}
return type;
},
separator: function() {
return this.multiline ? this.HTML ? " " : "\n" : this.HTML ? " " : " ";
},
// Extra can be a number, shortcut for increasing-calling-decreasing
indent: function( extra ) {
if ( !this.multiline ) {
return "";
}
var chr = this.indentChar;
if ( this.HTML ) {
chr = chr.replace( /\t/g, " " ).replace( / /g, " " );
}
return new Array( this.depth + ( extra || 0 ) ).join( chr );
},
up: function( a ) {
this.depth += a || 1;
},
down: function( a ) {
this.depth -= a || 1;
},
setParser: function( name, parser ) {
this.parsers[ name ] = parser;
},
// The next 3 are exposed so you can use them
quote: quote,
literal: literal,
join: join,
depth: 1,
maxDepth: QUnit.config.maxDepth,
// This is the list of parsers, to modify them, use dump.setParser
parsers: {
window: "[Window]",
document: "[Document]",
error: function( error ) {
return "Error(\"" + error.message + "\")";
},
unknown: "[Unknown]",
"null": "null",
"undefined": "undefined",
"function": function( fn ) {
var ret = "function",
// Functions never have name in IE
name = "name" in fn ? fn.name : ( reName.exec( fn ) || [] )[ 1 ];
if ( name ) {
ret += " " + name;
}
ret += "(";
ret = [ ret, dump.parse( fn, "functionArgs" ), "){" ].join( "" );
return join( ret, dump.parse( fn, "functionCode" ), "}" );
},
array: array,
nodelist: array,
"arguments": array,
object: function( map, stack ) {
var keys, key, val, i, nonEnumerableProperties,
ret = [];
if ( dump.maxDepth && dump.depth > dump.maxDepth ) {
return "[object Object]";
}
dump.up();
keys = [];
for ( key in map ) {
keys.push( key );
}
// Some properties are not always enumerable on Error objects.
nonEnumerableProperties = [ "message", "name" ];
for ( i in nonEnumerableProperties ) {
key = nonEnumerableProperties[ i ];
if ( key in map && inArray( key, keys ) < 0 ) {
keys.push( key );
}
}
keys.sort();
for ( i = 0; i < keys.length; i++ ) {
key = keys[ i ];
val = map[ key ];
ret.push( dump.parse( key, "key" ) + ": " +
dump.parse( val, undefined, stack ) );
}
dump.down();
return join( "{", ret, "}" );
},
node: function( node ) {
var len, i, val,
open = dump.HTML ? "<" : "<",
close = dump.HTML ? ">" : ">",
tag = node.nodeName.toLowerCase(),
ret = open + tag,
attrs = node.attributes;
if ( attrs ) {
for ( i = 0, len = attrs.length; i < len; i++ ) {
val = attrs[ i ].nodeValue;
// IE6 includes all attributes in .attributes, even ones not explicitly
// set. Those have values like undefined, null, 0, false, "" or
// "inherit".
if ( val && val !== "inherit" ) {
ret += " " + attrs[ i ].nodeName + "=" +
dump.parse( val, "attribute" );
}
}
}
ret += close;
// Show content of TextNode or CDATASection
if ( node.nodeType === 3 || node.nodeType === 4 ) {
ret += node.nodeValue;
}
return ret + open + "/" + tag + close;
},
// Function calls it internally, it's the arguments part of the function
functionArgs: function( fn ) {
var args,
l = fn.length;
if ( !l ) {
return "";
}
args = new Array( l );
while ( l-- ) {
// 97 is 'a'
args[ l ] = String.fromCharCode( 97 + l );
}
return " " + args.join( ", " ) + " ";
},
// Object calls it internally, the key part of an item in a map
key: quote,
// Function calls it internally, it's the content of the function
functionCode: "[code]",
// Node calls it internally, it's a html attribute value
attribute: quote,
string: quote,
date: quote,
regexp: literal,
number: literal,
"boolean": literal,
symbol: function( sym ) {
return sym.toString();
}
},
// If true, entities are escaped ( <, >, \t, space and \n )
HTML: false,
// Indentation unit
indentChar: " ",
// If true, items in a collection, are separated by a \n, else just a space.
multiline: true
};
return dump;
}() );
// Back compat
QUnit.jsDump = QUnit.dump;
function applyDeprecated( name ) {
return function() {
throw new Error(
name + " is removed in QUnit 2.0.\n" +
"Details in our upgrade guide at https://qunitjs.com/upgrade-guide-2.x/"
);
};
}
Object.keys( Assert.prototype ).forEach( function( key ) {
QUnit[ key ] = applyDeprecated( "`QUnit." + key + "`" );
} );
QUnit.asyncTest = function() {
throw new Error(
"asyncTest is removed in QUnit 2.0, use QUnit.test() with assert.async() instead.\n" +
"Details in our upgrade guide at https://qunitjs.com/upgrade-guide-2.x/"
);
};
QUnit.stop = function() {
throw new Error(
"QUnit.stop is removed in QUnit 2.0, use QUnit.test() with assert.async() instead.\n" +
"Details in our upgrade guide at https://qunitjs.com/upgrade-guide-2.x/"
);
};
function resetThrower() {
throw new Error(
"QUnit.reset is removed in QUnit 2.0 without replacement.\n" +
"Details in our upgrade guide at https://qunitjs.com/upgrade-guide-2.x/"
);
}
Object.defineProperty( QUnit, "reset", {
get: function() {
return resetThrower;
},
set: resetThrower
} );
if ( defined.document ) {
if ( window.QUnit ) {
throw new Error( "QUnit has already been defined." );
}
[
"test",
"module",
"expect",
"start",
"ok",
"notOk",
"equal",
"notEqual",
"propEqual",
"notPropEqual",
"deepEqual",
"notDeepEqual",
"strictEqual",
"notStrictEqual",
"throws",
"raises"
].forEach( function( key ) {
window[ key ] = applyDeprecated( "The global `" + key + "`" );
} );
window.QUnit = QUnit;
}
// For nodejs
if ( typeof module !== "undefined" && module && module.exports ) {
module.exports = QUnit;
// For consistency with CommonJS environments' exports
module.exports.QUnit = QUnit;
}
// For CommonJS with exports, but without module.exports, like Rhino
if ( typeof exports !== "undefined" && exports ) {
exports.QUnit = QUnit;
}
if ( typeof define === "function" && define.amd ) {
define( function() {
return QUnit;
} );
QUnit.config.autostart = false;
}
// Get a reference to the global object, like window in browsers
}( ( function() {
return this;
}() ) ) );
( function() {
if ( typeof window === "undefined" || !window.document ) {
return;
}
var config = QUnit.config,
hasOwn = Object.prototype.hasOwnProperty;
// Stores fixture HTML for resetting later
function storeFixture() {
// Avoid overwriting user-defined values
if ( hasOwn.call( config, "fixture" ) ) {
return;
}
var fixture = document.getElementById( "qunit-fixture" );
if ( fixture ) {
config.fixture = fixture.innerHTML;
}
}
QUnit.begin( storeFixture );
// Resets the fixture DOM element if available.
function resetFixture() {
if ( config.fixture == null ) {
return;
}
var fixture = document.getElementById( "qunit-fixture" );
if ( fixture ) {
fixture.innerHTML = config.fixture;
}
}
QUnit.testStart( resetFixture );
}() );
( function() {
// Only interact with URLs via window.location
var location = typeof window !== "undefined" && window.location;
if ( !location ) {
return;
}
var urlParams = getUrlParams();
QUnit.urlParams = urlParams;
// Match module/test by inclusion in an array
QUnit.config.moduleId = [].concat( urlParams.moduleId || [] );
QUnit.config.testId = [].concat( urlParams.testId || [] );
// Exact case-insensitive match of the module name
QUnit.config.module = urlParams.module;
// Regular expression or case-insenstive substring match against "moduleName: testName"
QUnit.config.filter = urlParams.filter;
// Test order randomization
if ( urlParams.seed === true ) {
// Generate a random seed if the option is specified without a value
QUnit.config.seed = Math.random().toString( 36 ).slice( 2 );
} else if ( urlParams.seed ) {
QUnit.config.seed = urlParams.seed;
}
// Add URL-parameter-mapped config values with UI form rendering data
QUnit.config.urlConfig.push(
{
id: "hidepassed",
label: "Hide passed tests",
tooltip: "Only show tests and assertions that fail. Stored as query-strings."
},
{
id: "noglobals",
label: "Check for Globals",
tooltip: "Enabling this will test if any test introduces new properties on the " +
"global object (`window` in Browsers). Stored as query-strings."
},
{
id: "notrycatch",
label: "No try-catch",
tooltip: "Enabling this will run tests outside of a try-catch block. Makes debugging " +
"exceptions in IE reasonable. Stored as query-strings."
}
);
QUnit.begin( function() {
var i, option,
urlConfig = QUnit.config.urlConfig;
for ( i = 0; i < urlConfig.length; i++ ) {
// Options can be either strings or objects with nonempty "id" properties
option = QUnit.config.urlConfig[ i ];
if ( typeof option !== "string" ) {
option = option.id;
}
if ( QUnit.config[ option ] === undefined ) {
QUnit.config[ option ] = urlParams[ option ];
}
}
} );
function getUrlParams() {
var i, param, name, value;
var urlParams = {};
var params = location.search.slice( 1 ).split( "&" );
var length = params.length;
for ( i = 0; i < length; i++ ) {
if ( params[ i ] ) {
param = params[ i ].split( "=" );
name = decodeQueryParam( param[ 0 ] );
// Allow just a key to turn on a flag, e.g., test.html?noglobals
value = param.length === 1 ||
decodeQueryParam( param.slice( 1 ).join( "=" ) ) ;
if ( urlParams[ name ] ) {
urlParams[ name ] = [].concat( urlParams[ name ], value );
} else {
urlParams[ name ] = value;
}
}
}
return urlParams;
}
function decodeQueryParam( param ) {
return decodeURIComponent( param.replace( /\+/g, "%20" ) );
}
// Don't load the HTML Reporter on non-browser environments
if ( typeof window === "undefined" || !window.document ) {
return;
}
QUnit.init = function() {
throw new Error(
"QUnit.init is removed in QUnit 2.0, use QUnit.test() with assert.async() instead.\n" +
"Details in our upgrade guide at https://qunitjs.com/upgrade-guide-2.x/"
);
};
var config = QUnit.config,
document = window.document,
collapseNext = false,
hasOwn = Object.prototype.hasOwnProperty,
unfilteredUrl = setUrl( { filter: undefined, module: undefined,
moduleId: undefined, testId: undefined } ),
defined = {
sessionStorage: ( function() {
var x = "qunit-test-string";
try {
sessionStorage.setItem( x, x );
sessionStorage.removeItem( x );
return true;
} catch ( e ) {
return false;
}
}() )
},
modulesList = [];
// Escape text for attribute or text content.
function escapeText( s ) {
if ( !s ) {
return "";
}
s = s + "";
// Both single quotes and double quotes (for attributes)
return s.replace( /['"<>&]/g, function( s ) {
switch ( s ) {
case "'":
return "'";
case "\"":
return """;
case "<":
return "<";
case ">":
return ">";
case "&":
return "&";
}
} );
}
function addEvent( elem, type, fn ) {
elem.addEventListener( type, fn, false );
}
function removeEvent( elem, type, fn ) {
elem.removeEventListener( type, fn, false );
}
function addEvents( elems, type, fn ) {
var i = elems.length;
while ( i-- ) {
addEvent( elems[ i ], type, fn );
}
}
function hasClass( elem, name ) {
return ( " " + elem.className + " " ).indexOf( " " + name + " " ) >= 0;
}
function addClass( elem, name ) {
if ( !hasClass( elem, name ) ) {
elem.className += ( elem.className ? " " : "" ) + name;
}
}
function toggleClass( elem, name, force ) {
if ( force || typeof force === "undefined" && !hasClass( elem, name ) ) {
addClass( elem, name );
} else {
removeClass( elem, name );
}
}
function removeClass( elem, name ) {
var set = " " + elem.className + " ";
// Class name may appear multiple times
while ( set.indexOf( " " + name + " " ) >= 0 ) {
set = set.replace( " " + name + " ", " " );
}
// Trim for prettiness
elem.className = typeof set.trim === "function" ? set.trim() : set.replace( /^\s+|\s+$/g, "" );
}
function id( name ) {
return document.getElementById && document.getElementById( name );
}
function interceptNavigation( ev ) {
applyUrlParams();
if ( ev && ev.preventDefault ) {
ev.preventDefault();
}
return false;
}
function getUrlConfigHtml() {
var i, j, val,
escaped, escapedTooltip,
selection = false,
urlConfig = config.urlConfig,
urlConfigHtml = "";
for ( i = 0; i < urlConfig.length; i++ ) {
// Options can be either strings or objects with nonempty "id" properties
val = config.urlConfig[ i ];
if ( typeof val === "string" ) {
val = {
id: val,
label: val
};
}
escaped = escapeText( val.id );
escapedTooltip = escapeText( val.tooltip );
if ( !val.value || typeof val.value === "string" ) {
urlConfigHtml += "";
} else {
urlConfigHtml += "";
}
}
return urlConfigHtml;
}
// Handle "click" events on toolbar checkboxes and "change" for select menus.
// Updates the URL with the new state of `config.urlConfig` values.
function toolbarChanged() {
var updatedUrl, value, tests,
field = this,
params = {};
// Detect if field is a select menu or a checkbox
if ( "selectedIndex" in field ) {
value = field.options[ field.selectedIndex ].value || undefined;
} else {
value = field.checked ? ( field.defaultValue || true ) : undefined;
}
params[ field.name ] = value;
updatedUrl = setUrl( params );
// Check if we can apply the change without a page refresh
if ( "hidepassed" === field.name && "replaceState" in window.history ) {
QUnit.urlParams[ field.name ] = value;
config[ field.name ] = value || false;
tests = id( "qunit-tests" );
if ( tests ) {
toggleClass( tests, "hidepass", value || false );
}
window.history.replaceState( null, "", updatedUrl );
} else {
window.location = updatedUrl;
}
}
function setUrl( params ) {
var key, arrValue, i,
querystring = "?",
location = window.location;
params = QUnit.extend( QUnit.extend( {}, QUnit.urlParams ), params );
for ( key in params ) {
// Skip inherited or undefined properties
if ( hasOwn.call( params, key ) && params[ key ] !== undefined ) {
// Output a parameter for each value of this key (but usually just one)
arrValue = [].concat( params[ key ] );
for ( i = 0; i < arrValue.length; i++ ) {
querystring += encodeURIComponent( key );
if ( arrValue[ i ] !== true ) {
querystring += "=" + encodeURIComponent( arrValue[ i ] );
}
querystring += "&";
}
}
}
return location.protocol + "//" + location.host +
location.pathname + querystring.slice( 0, -1 );
}
function applyUrlParams() {
var i,
selectedModules = [],
modulesList = id( "qunit-modulefilter-dropdown-list" ).getElementsByTagName( "input" ),
filter = id( "qunit-filter-input" ).value;
for ( i = 0; i < modulesList.length; i++ ) {
if ( modulesList[ i ].checked ) {
selectedModules.push( modulesList[ i ].value );
}
}
window.location = setUrl( {
filter: ( filter === "" ) ? undefined : filter,
moduleId: ( selectedModules.length === 0 ) ? undefined : selectedModules,
// Remove module and testId filter
module: undefined,
testId: undefined
} );
}
function toolbarUrlConfigContainer() {
var urlConfigContainer = document.createElement( "span" );
urlConfigContainer.innerHTML = getUrlConfigHtml();
addClass( urlConfigContainer, "qunit-url-config" );
addEvents( urlConfigContainer.getElementsByTagName( "input" ), "change", toolbarChanged );
addEvents( urlConfigContainer.getElementsByTagName( "select" ), "change", toolbarChanged );
return urlConfigContainer;
}
function toolbarLooseFilter() {
var filter = document.createElement( "form" ),
label = document.createElement( "label" ),
input = document.createElement( "input" ),
button = document.createElement( "button" );
addClass( filter, "qunit-filter" );
label.innerHTML = "Filter: ";
input.type = "text";
input.value = config.filter || "";
input.name = "filter";
input.id = "qunit-filter-input";
button.innerHTML = "Go";
label.appendChild( input );
filter.appendChild( label );
filter.appendChild( document.createTextNode( " " ) );
filter.appendChild( button );
addEvent( filter, "submit", interceptNavigation );
return filter;
}
function moduleListHtml () {
var i, checked,
html = "";
for ( i = 0; i < config.modules.length; i++ ) {
if ( config.modules[ i ].name !== "" ) {
checked = config.moduleId.indexOf( config.modules[ i ].moduleId ) > -1;
html += "";
}
}
return html;
}
function toolbarModuleFilter () {
var allCheckbox, commit, reset,
moduleFilter = document.createElement( "form" ),
label = document.createElement( "label" ),
moduleSearch = document.createElement( "input" ),
dropDown = document.createElement( "div" ),
actions = document.createElement( "span" ),
dropDownList = document.createElement( "ul" ),
dirty = false;
moduleSearch.id = "qunit-modulefilter-search";
addEvent( moduleSearch, "input", searchInput );
addEvent( moduleSearch, "input", searchFocus );
addEvent( moduleSearch, "focus", searchFocus );
addEvent( moduleSearch, "click", searchFocus );
label.id = "qunit-modulefilter-search-container";
label.innerHTML = "Module: ";
label.appendChild( moduleSearch );
actions.id = "qunit-modulefilter-actions";
actions.innerHTML =
"" +
"" +
"";
allCheckbox = actions.lastChild.firstChild;
commit = actions.firstChild;
reset = commit.nextSibling;
addEvent( commit, "click", applyUrlParams );
dropDownList.id = "qunit-modulefilter-dropdown-list";
dropDownList.innerHTML = moduleListHtml();
dropDown.id = "qunit-modulefilter-dropdown";
dropDown.style.display = "none";
dropDown.appendChild( actions );
dropDown.appendChild( dropDownList );
addEvent( dropDown, "change", selectionChange );
selectionChange();
moduleFilter.id = "qunit-modulefilter";
moduleFilter.appendChild( label );
moduleFilter.appendChild( dropDown ) ;
addEvent( moduleFilter, "submit", interceptNavigation );
addEvent( moduleFilter, "reset", function() {
// Let the reset happen, then update styles
window.setTimeout( selectionChange );
} );
// Enables show/hide for the dropdown
function searchFocus() {
if ( dropDown.style.display !== "none" ) {
return;
}
dropDown.style.display = "block";
addEvent( document, "click", hideHandler );
addEvent( document, "keydown", hideHandler );
// Hide on Escape keydown or outside-container click
function hideHandler( e ) {
var inContainer = moduleFilter.contains( e.target );
if ( e.keyCode === 27 || !inContainer ) {
if ( e.keyCode === 27 && inContainer ) {
moduleSearch.focus();
}
dropDown.style.display = "none";
removeEvent( document, "click", hideHandler );
removeEvent( document, "keydown", hideHandler );
moduleSearch.value = "";
searchInput();
}
}
}
// Processes module search box input
function searchInput() {
var i, item,
searchText = moduleSearch.value.toLowerCase(),
listItems = dropDownList.children;
for ( i = 0; i < listItems.length; i++ ) {
item = listItems[ i ];
if ( !searchText || item.textContent.toLowerCase().indexOf( searchText ) > -1 ) {
item.style.display = "";
} else {
item.style.display = "none";
}
}
}
// Processes selection changes
function selectionChange( evt ) {
var i, item,
checkbox = evt && evt.target || allCheckbox,
modulesList = dropDownList.getElementsByTagName( "input" ),
selectedNames = [];
toggleClass( checkbox.parentNode, "checked", checkbox.checked );
dirty = false;
if ( checkbox.checked && checkbox !== allCheckbox ) {
allCheckbox.checked = false;
removeClass( allCheckbox.parentNode, "checked" );
}
for ( i = 0; i < modulesList.length; i++ ) {
item = modulesList[ i ];
if ( !evt ) {
toggleClass( item.parentNode, "checked", item.checked );
} else if ( checkbox === allCheckbox && checkbox.checked ) {
item.checked = false;
removeClass( item.parentNode, "checked" );
}
dirty = dirty || ( item.checked !== item.defaultChecked );
if ( item.checked ) {
selectedNames.push( item.parentNode.textContent );
}
}
commit.style.display = reset.style.display = dirty ? "" : "none";
moduleSearch.placeholder = selectedNames.join( ", " ) || allCheckbox.parentNode.textContent;
moduleSearch.title = "Type to filter list. Current selection:\n" +
( selectedNames.join( "\n" ) || allCheckbox.parentNode.textContent );
}
return moduleFilter;
}
function appendToolbar() {
var toolbar = id( "qunit-testrunner-toolbar" );
if ( toolbar ) {
toolbar.appendChild( toolbarUrlConfigContainer() );
toolbar.appendChild( toolbarModuleFilter() );
toolbar.appendChild( toolbarLooseFilter() );
toolbar.appendChild( document.createElement( "div" ) ).className = "clearfix";
}
}
function appendHeader() {
var header = id( "qunit-header" );
if ( header ) {
header.innerHTML = "" + header.innerHTML +
" ";
}
}
function appendBanner() {
var banner = id( "qunit-banner" );
if ( banner ) {
banner.className = "";
}
}
function appendTestResults() {
var tests = id( "qunit-tests" ),
result = id( "qunit-testresult" );
if ( result ) {
result.parentNode.removeChild( result );
}
if ( tests ) {
tests.innerHTML = "";
result = document.createElement( "p" );
result.id = "qunit-testresult";
result.className = "result";
tests.parentNode.insertBefore( result, tests );
result.innerHTML = "Running... ";
}
}
function appendFilteredTest() {
var testId = QUnit.config.testId;
if ( !testId || testId.length <= 0 ) {
return "";
}
return "
Rerunning selected tests: " +
escapeText( testId.join( ", " ) ) +
" Run all tests
";
}
function appendUserAgent() {
var userAgent = id( "qunit-userAgent" );
if ( userAgent ) {
userAgent.innerHTML = "";
userAgent.appendChild(
document.createTextNode(
"QUnit " + QUnit.version + "; " + navigator.userAgent
)
);
}
}
function appendInterface() {
var qunit = id( "qunit" );
if ( qunit ) {
qunit.innerHTML =
"
" + escapeText( document.title ) + "
" +
"" +
"" +
appendFilteredTest() +
"" +
"";
}
appendHeader();
appendBanner();
appendTestResults();
appendUserAgent();
appendToolbar();
}
function appendTestsList( modules ) {
var i, l, x, z, test, moduleObj;
for ( i = 0, l = modules.length; i < l; i++ ) {
moduleObj = modules[ i ];
for ( x = 0, z = moduleObj.tests.length; x < z; x++ ) {
test = moduleObj.tests[ x ];
appendTest( test.name, test.testId, moduleObj.name );
}
}
}
function appendTest( name, testId, moduleName ) {
var title, rerunTrigger, testBlock, assertList,
tests = id( "qunit-tests" );
if ( !tests ) {
return;
}
title = document.createElement( "strong" );
title.innerHTML = getNameHtml( name, moduleName );
rerunTrigger = document.createElement( "a" );
rerunTrigger.innerHTML = "Rerun";
rerunTrigger.href = setUrl( { testId: testId } );
testBlock = document.createElement( "li" );
testBlock.appendChild( title );
testBlock.appendChild( rerunTrigger );
testBlock.id = "qunit-test-output-" + testId;
assertList = document.createElement( "ol" );
assertList.className = "qunit-assert-list";
testBlock.appendChild( assertList );
tests.appendChild( testBlock );
}
// HTML Reporter initialization and load
QUnit.begin( function( details ) {
var i, moduleObj, tests;
// Sort modules by name for the picker
for ( i = 0; i < details.modules.length; i++ ) {
moduleObj = details.modules[ i ];
if ( moduleObj.name ) {
modulesList.push( moduleObj.name );
}
}
modulesList.sort( function( a, b ) {
return a.localeCompare( b );
} );
// Initialize QUnit elements
appendInterface();
appendTestsList( details.modules );
tests = id( "qunit-tests" );
if ( tests && config.hidepassed ) {
addClass( tests, "hidepass" );
}
} );
QUnit.done( function( details ) {
var i, key,
banner = id( "qunit-banner" ),
tests = id( "qunit-tests" ),
html = [
"Tests completed in ",
details.runtime,
" milliseconds. ",
"",
details.passed,
" assertions of ",
details.total,
" passed, ",
details.failed,
" failed."
].join( "" );
if ( banner ) {
banner.className = details.failed ? "qunit-fail" : "qunit-pass";
}
if ( tests ) {
id( "qunit-testresult" ).innerHTML = html;
}
if ( config.altertitle && document.title ) {
// Show ✖ for good, ✔ for bad suite result in title
// use escape sequences in case file gets loaded with non-utf-8-charset
document.title = [
( details.failed ? "\u2716" : "\u2714" ),
document.title.replace( /^[\u2714\u2716] /i, "" )
].join( " " );
}
// Clear own sessionStorage items if all tests passed
if ( config.reorder && defined.sessionStorage && details.failed === 0 ) {
for ( i = 0; i < sessionStorage.length; i++ ) {
key = sessionStorage.key( i++ );
if ( key.indexOf( "qunit-test-" ) === 0 ) {
sessionStorage.removeItem( key );
}
}
}
// Scroll back to top to show results
if ( config.scrolltop && window.scrollTo ) {
window.scrollTo( 0, 0 );
}
} );
function getNameHtml( name, module ) {
var nameHtml = "";
if ( module ) {
nameHtml = "" + escapeText( module ) + ": ";
}
nameHtml += "" + escapeText( name ) + "";
return nameHtml;
}
QUnit.testStart( function( details ) {
var running, testBlock, bad;
testBlock = id( "qunit-test-output-" + details.testId );
if ( testBlock ) {
testBlock.className = "running";
} else {
// Report later registered tests
appendTest( details.name, details.testId, details.module );
}
running = id( "qunit-testresult" );
if ( running ) {
bad = QUnit.config.reorder && defined.sessionStorage &&
+sessionStorage.getItem( "qunit-test-" + details.module + "-" + details.name );
running.innerHTML = ( bad ?
"Rerunning previously failed test: " :
"Running: " ) +
getNameHtml( details.name, details.module );
}
} );
function stripHtml( string ) {
// Strip tags, html entity and whitespaces
return string.replace( /<\/?[^>]+(>|$)/g, "" ).replace( /\"/g, "" ).replace( /\s+/g, "" );
}
QUnit.log( function( details ) {
var assertList, assertLi,
message, expected, actual, diff,
showDiff = false,
testItem = id( "qunit-test-output-" + details.testId );
if ( !testItem ) {
return;
}
message = escapeText( details.message ) || ( details.result ? "okay" : "failed" );
message = "" + message + "";
message += "@ " + details.runtime + " ms";
// The pushFailure doesn't provide details.expected
// when it calls, it's implicit to also not show expected and diff stuff
// Also, we need to check details.expected existence, as it can exist and be undefined
if ( !details.result && hasOwn.call( details, "expected" ) ) {
if ( details.negative ) {
expected = "NOT " + QUnit.dump.parse( details.expected );
} else {
expected = QUnit.dump.parse( details.expected );
}
actual = QUnit.dump.parse( details.actual );
message += "
Expected:
" +
escapeText( expected ) +
"
";
if ( actual !== expected ) {
message += "
Result:
" +
escapeText( actual ) + "
";
// Don't show diff if actual or expected are booleans
if ( !( /^(true|false)$/.test( actual ) ) &&
!( /^(true|false)$/.test( expected ) ) ) {
diff = QUnit.diff( expected, actual );
showDiff = stripHtml( diff ).length !==
stripHtml( expected ).length +
stripHtml( actual ).length;
}
// Don't show diff if expected and actual are totally different
if ( showDiff ) {
message += "
" +
"Diff suppressed as the depth of object is more than current max depth (" +
QUnit.config.maxDepth + ").
Hint: Use QUnit.dump.maxDepth to " +
" run with a higher max depth or " +
"Rerun without max depth.
";
} else {
message += "
Message:
" +
"Diff suppressed as the expected and actual results have an equivalent" +
" serialization
";
}
if ( details.source ) {
message += "
Source:
" +
escapeText( details.source ) + "
";
}
message += "
";
// This occurs when pushFailure is set and we have an extracted stack trace
} else if ( !details.result && details.source ) {
message += "
" +
"
Source:
" +
escapeText( details.source ) + "
" +
"
";
}
assertList = testItem.getElementsByTagName( "ol" )[ 0 ];
assertLi = document.createElement( "li" );
assertLi.className = details.result ? "pass" : "fail";
assertLi.innerHTML = message;
assertList.appendChild( assertLi );
} );
QUnit.testDone( function( details ) {
var testTitle, time, testItem, assertList,
good, bad, testCounts, skipped, sourceName,
tests = id( "qunit-tests" );
if ( !tests ) {
return;
}
testItem = id( "qunit-test-output-" + details.testId );
assertList = testItem.getElementsByTagName( "ol" )[ 0 ];
good = details.passed;
bad = details.failed;
// Store result when possible
if ( config.reorder && defined.sessionStorage ) {
if ( bad ) {
sessionStorage.setItem( "qunit-test-" + details.module + "-" + details.name, bad );
} else {
sessionStorage.removeItem( "qunit-test-" + details.module + "-" + details.name );
}
}
if ( bad === 0 ) {
// Collapse the passing tests
addClass( assertList, "qunit-collapsed" );
} else if ( bad && config.collapse && !collapseNext ) {
// Skip collapsing the first failing test
collapseNext = true;
} else {
// Collapse remaining tests
addClass( assertList, "qunit-collapsed" );
}
// The testItem.firstChild is the test name
testTitle = testItem.firstChild;
testCounts = bad ?
"" + bad + ", " + "" + good + ", " :
"";
testTitle.innerHTML += " (" + testCounts +
details.assertions.length + ")";
if ( details.skipped ) {
testItem.className = "skipped";
skipped = document.createElement( "em" );
skipped.className = "qunit-skipped-label";
skipped.innerHTML = "skipped";
testItem.insertBefore( skipped, testTitle );
} else {
addEvent( testTitle, "click", function() {
toggleClass( assertList, "qunit-collapsed" );
} );
testItem.className = bad ? "fail" : "pass";
time = document.createElement( "span" );
time.className = "runtime";
time.innerHTML = details.runtime + " ms";
testItem.insertBefore( time, assertList );
}
// Show the source of the test when showing assertions
if ( details.source ) {
sourceName = document.createElement( "p" );
sourceName.innerHTML = "Source: " + details.source;
addClass( sourceName, "qunit-source" );
if ( bad === 0 ) {
addClass( sourceName, "qunit-collapsed" );
}
addEvent( testTitle, "click", function() {
toggleClass( sourceName, "qunit-collapsed" );
} );
testItem.appendChild( sourceName );
}
} );
// Avoid readyState issue with phantomjs
// Ref: #818
var notPhantom = ( function( p ) {
return !( p && p.version && p.version.major > 0 );
} )( window.phantom );
if ( notPhantom && document.readyState === "complete" ) {
QUnit.load();
} else {
addEvent( window, "load", QUnit.load );
}
/*
* This file is a modified version of google-diff-match-patch's JavaScript implementation
* (https://code.google.com/p/google-diff-match-patch/source/browse/trunk/javascript/diff_match_patch_uncompressed.js),
* modifications are licensed as more fully set forth in LICENSE.txt.
*
* The original source of google-diff-match-patch is attributable and licensed as follows:
*
* Copyright 2006 Google Inc.
* https://code.google.com/p/google-diff-match-patch/
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* More Info:
* https://code.google.com/p/google-diff-match-patch/
*
* Usage: QUnit.diff(expected, actual)
*
*/
QUnit.diff = ( function() {
function DiffMatchPatch() {
}
// DIFF FUNCTIONS
/**
* The data structure representing a diff is an array of tuples:
* [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]
* which means: delete 'Hello', add 'Goodbye' and keep ' world.'
*/
var DIFF_DELETE = -1,
DIFF_INSERT = 1,
DIFF_EQUAL = 0;
/**
* Find the differences between two texts. Simplifies the problem by stripping
* any common prefix or suffix off the texts before diffing.
* @param {string} text1 Old string to be diffed.
* @param {string} text2 New string to be diffed.
* @param {boolean=} optChecklines Optional speedup flag. If present and false,
* then don't run a line-level diff first to identify the changed areas.
* Defaults to true, which does a faster, slightly less optimal diff.
* @return {!Array.} Array of diff tuples.
*/
DiffMatchPatch.prototype.DiffMain = function( text1, text2, optChecklines ) {
var deadline, checklines, commonlength,
commonprefix, commonsuffix, diffs;
// The diff must be complete in up to 1 second.
deadline = ( new Date() ).getTime() + 1000;
// Check for null inputs.
if ( text1 === null || text2 === null ) {
throw new Error( "Null input. (DiffMain)" );
}
// Check for equality (speedup).
if ( text1 === text2 ) {
if ( text1 ) {
return [
[ DIFF_EQUAL, text1 ]
];
}
return [];
}
if ( typeof optChecklines === "undefined" ) {
optChecklines = true;
}
checklines = optChecklines;
// Trim off common prefix (speedup).
commonlength = this.diffCommonPrefix( text1, text2 );
commonprefix = text1.substring( 0, commonlength );
text1 = text1.substring( commonlength );
text2 = text2.substring( commonlength );
// Trim off common suffix (speedup).
commonlength = this.diffCommonSuffix( text1, text2 );
commonsuffix = text1.substring( text1.length - commonlength );
text1 = text1.substring( 0, text1.length - commonlength );
text2 = text2.substring( 0, text2.length - commonlength );
// Compute the diff on the middle block.
diffs = this.diffCompute( text1, text2, checklines, deadline );
// Restore the prefix and suffix.
if ( commonprefix ) {
diffs.unshift( [ DIFF_EQUAL, commonprefix ] );
}
if ( commonsuffix ) {
diffs.push( [ DIFF_EQUAL, commonsuffix ] );
}
this.diffCleanupMerge( diffs );
return diffs;
};
/**
* Reduce the number of edits by eliminating operationally trivial equalities.
* @param {!Array.} diffs Array of diff tuples.
*/
DiffMatchPatch.prototype.diffCleanupEfficiency = function( diffs ) {
var changes, equalities, equalitiesLength, lastequality,
pointer, preIns, preDel, postIns, postDel;
changes = false;
equalities = []; // Stack of indices where equalities are found.
equalitiesLength = 0; // Keeping our own length var is faster in JS.
/** @type {?string} */
lastequality = null;
// Always equal to diffs[equalities[equalitiesLength - 1]][1]
pointer = 0; // Index of current position.
// Is there an insertion operation before the last equality.
preIns = false;
// Is there a deletion operation before the last equality.
preDel = false;
// Is there an insertion operation after the last equality.
postIns = false;
// Is there a deletion operation after the last equality.
postDel = false;
while ( pointer < diffs.length ) {
// Equality found.
if ( diffs[ pointer ][ 0 ] === DIFF_EQUAL ) {
if ( diffs[ pointer ][ 1 ].length < 4 && ( postIns || postDel ) ) {
// Candidate found.
equalities[ equalitiesLength++ ] = pointer;
preIns = postIns;
preDel = postDel;
lastequality = diffs[ pointer ][ 1 ];
} else {
// Not a candidate, and can never become one.
equalitiesLength = 0;
lastequality = null;
}
postIns = postDel = false;
// An insertion or deletion.
} else {
if ( diffs[ pointer ][ 0 ] === DIFF_DELETE ) {
postDel = true;
} else {
postIns = true;
}
/*
* Five types to be split:
* ABXYCD
* AXCD
* ABXC
* AXCD
* ABXC
*/
if ( lastequality && ( ( preIns && preDel && postIns && postDel ) ||
( ( lastequality.length < 2 ) &&
( preIns + preDel + postIns + postDel ) === 3 ) ) ) {
// Duplicate record.
diffs.splice(
equalities[ equalitiesLength - 1 ],
0,
[ DIFF_DELETE, lastequality ]
);
// Change second copy to insert.
diffs[ equalities[ equalitiesLength - 1 ] + 1 ][ 0 ] = DIFF_INSERT;
equalitiesLength--; // Throw away the equality we just deleted;
lastequality = null;
if ( preIns && preDel ) {
// No changes made which could affect previous entry, keep going.
postIns = postDel = true;
equalitiesLength = 0;
} else {
equalitiesLength--; // Throw away the previous equality.
pointer = equalitiesLength > 0 ? equalities[ equalitiesLength - 1 ] : -1;
postIns = postDel = false;
}
changes = true;
}
}
pointer++;
}
if ( changes ) {
this.diffCleanupMerge( diffs );
}
};
/**
* Convert a diff array into a pretty HTML report.
* @param {!Array.} diffs Array of diff tuples.
* @param {integer} string to be beautified.
* @return {string} HTML representation.
*/
DiffMatchPatch.prototype.diffPrettyHtml = function( diffs ) {
var op, data, x,
html = [];
for ( x = 0; x < diffs.length; x++ ) {
op = diffs[ x ][ 0 ]; // Operation (insert, delete, equal)
data = diffs[ x ][ 1 ]; // Text of change.
switch ( op ) {
case DIFF_INSERT:
html[ x ] = "" + escapeText( data ) + "";
break;
case DIFF_DELETE:
html[ x ] = "" + escapeText( data ) + "";
break;
case DIFF_EQUAL:
html[ x ] = "" + escapeText( data ) + "";
break;
}
}
return html.join( "" );
};
/**
* Determine the common prefix of two strings.
* @param {string} text1 First string.
* @param {string} text2 Second string.
* @return {number} The number of characters common to the start of each
* string.
*/
DiffMatchPatch.prototype.diffCommonPrefix = function( text1, text2 ) {
var pointermid, pointermax, pointermin, pointerstart;
// Quick check for common null cases.
if ( !text1 || !text2 || text1.charAt( 0 ) !== text2.charAt( 0 ) ) {
return 0;
}
// Binary search.
// Performance analysis: https://neil.fraser.name/news/2007/10/09/
pointermin = 0;
pointermax = Math.min( text1.length, text2.length );
pointermid = pointermax;
pointerstart = 0;
while ( pointermin < pointermid ) {
if ( text1.substring( pointerstart, pointermid ) ===
text2.substring( pointerstart, pointermid ) ) {
pointermin = pointermid;
pointerstart = pointermin;
} else {
pointermax = pointermid;
}
pointermid = Math.floor( ( pointermax - pointermin ) / 2 + pointermin );
}
return pointermid;
};
/**
* Determine the common suffix of two strings.
* @param {string} text1 First string.
* @param {string} text2 Second string.
* @return {number} The number of characters common to the end of each string.
*/
DiffMatchPatch.prototype.diffCommonSuffix = function( text1, text2 ) {
var pointermid, pointermax, pointermin, pointerend;
// Quick check for common null cases.
if ( !text1 ||
!text2 ||
text1.charAt( text1.length - 1 ) !== text2.charAt( text2.length - 1 ) ) {
return 0;
}
// Binary search.
// Performance analysis: https://neil.fraser.name/news/2007/10/09/
pointermin = 0;
pointermax = Math.min( text1.length, text2.length );
pointermid = pointermax;
pointerend = 0;
while ( pointermin < pointermid ) {
if ( text1.substring( text1.length - pointermid, text1.length - pointerend ) ===
text2.substring( text2.length - pointermid, text2.length - pointerend ) ) {
pointermin = pointermid;
pointerend = pointermin;
} else {
pointermax = pointermid;
}
pointermid = Math.floor( ( pointermax - pointermin ) / 2 + pointermin );
}
return pointermid;
};
/**
* Find the differences between two texts. Assumes that the texts do not
* have any common prefix or suffix.
* @param {string} text1 Old string to be diffed.
* @param {string} text2 New string to be diffed.
* @param {boolean} checklines Speedup flag. If false, then don't run a
* line-level diff first to identify the changed areas.
* If true, then run a faster, slightly less optimal diff.
* @param {number} deadline Time when the diff should be complete by.
* @return {!Array.} Array of diff tuples.
* @private
*/
DiffMatchPatch.prototype.diffCompute = function( text1, text2, checklines, deadline ) {
var diffs, longtext, shorttext, i, hm,
text1A, text2A, text1B, text2B,
midCommon, diffsA, diffsB;
if ( !text1 ) {
// Just add some text (speedup).
return [
[ DIFF_INSERT, text2 ]
];
}
if ( !text2 ) {
// Just delete some text (speedup).
return [
[ DIFF_DELETE, text1 ]
];
}
longtext = text1.length > text2.length ? text1 : text2;
shorttext = text1.length > text2.length ? text2 : text1;
i = longtext.indexOf( shorttext );
if ( i !== -1 ) {
// Shorter text is inside the longer text (speedup).
diffs = [
[ DIFF_INSERT, longtext.substring( 0, i ) ],
[ DIFF_EQUAL, shorttext ],
[ DIFF_INSERT, longtext.substring( i + shorttext.length ) ]
];
// Swap insertions for deletions if diff is reversed.
if ( text1.length > text2.length ) {
diffs[ 0 ][ 0 ] = diffs[ 2 ][ 0 ] = DIFF_DELETE;
}
return diffs;
}
if ( shorttext.length === 1 ) {
// Single character string.
// After the previous speedup, the character can't be an equality.
return [
[ DIFF_DELETE, text1 ],
[ DIFF_INSERT, text2 ]
];
}
// Check to see if the problem can be split in two.
hm = this.diffHalfMatch( text1, text2 );
if ( hm ) {
// A half-match was found, sort out the return data.
text1A = hm[ 0 ];
text1B = hm[ 1 ];
text2A = hm[ 2 ];
text2B = hm[ 3 ];
midCommon = hm[ 4 ];
// Send both pairs off for separate processing.
diffsA = this.DiffMain( text1A, text2A, checklines, deadline );
diffsB = this.DiffMain( text1B, text2B, checklines, deadline );
// Merge the results.
return diffsA.concat( [
[ DIFF_EQUAL, midCommon ]
], diffsB );
}
if ( checklines && text1.length > 100 && text2.length > 100 ) {
return this.diffLineMode( text1, text2, deadline );
}
return this.diffBisect( text1, text2, deadline );
};
/**
* Do the two texts share a substring which is at least half the length of the
* longer text?
* This speedup can produce non-minimal diffs.
* @param {string} text1 First string.
* @param {string} text2 Second string.
* @return {Array.} Five element Array, containing the prefix of
* text1, the suffix of text1, the prefix of text2, the suffix of
* text2 and the common middle. Or null if there was no match.
* @private
*/
DiffMatchPatch.prototype.diffHalfMatch = function( text1, text2 ) {
var longtext, shorttext, dmp,
text1A, text2B, text2A, text1B, midCommon,
hm1, hm2, hm;
longtext = text1.length > text2.length ? text1 : text2;
shorttext = text1.length > text2.length ? text2 : text1;
if ( longtext.length < 4 || shorttext.length * 2 < longtext.length ) {
return null; // Pointless.
}
dmp = this; // 'this' becomes 'window' in a closure.
/**
* Does a substring of shorttext exist within longtext such that the substring
* is at least half the length of longtext?
* Closure, but does not reference any external variables.
* @param {string} longtext Longer string.
* @param {string} shorttext Shorter string.
* @param {number} i Start index of quarter length substring within longtext.
* @return {Array.} Five element Array, containing the prefix of
* longtext, the suffix of longtext, the prefix of shorttext, the suffix
* of shorttext and the common middle. Or null if there was no match.
* @private
*/
function diffHalfMatchI( longtext, shorttext, i ) {
var seed, j, bestCommon, prefixLength, suffixLength,
bestLongtextA, bestLongtextB, bestShorttextA, bestShorttextB;
// Start with a 1/4 length substring at position i as a seed.
seed = longtext.substring( i, i + Math.floor( longtext.length / 4 ) );
j = -1;
bestCommon = "";
while ( ( j = shorttext.indexOf( seed, j + 1 ) ) !== -1 ) {
prefixLength = dmp.diffCommonPrefix( longtext.substring( i ),
shorttext.substring( j ) );
suffixLength = dmp.diffCommonSuffix( longtext.substring( 0, i ),
shorttext.substring( 0, j ) );
if ( bestCommon.length < suffixLength + prefixLength ) {
bestCommon = shorttext.substring( j - suffixLength, j ) +
shorttext.substring( j, j + prefixLength );
bestLongtextA = longtext.substring( 0, i - suffixLength );
bestLongtextB = longtext.substring( i + prefixLength );
bestShorttextA = shorttext.substring( 0, j - suffixLength );
bestShorttextB = shorttext.substring( j + prefixLength );
}
}
if ( bestCommon.length * 2 >= longtext.length ) {
return [ bestLongtextA, bestLongtextB,
bestShorttextA, bestShorttextB, bestCommon
];
} else {
return null;
}
}
// First check if the second quarter is the seed for a half-match.
hm1 = diffHalfMatchI( longtext, shorttext,
Math.ceil( longtext.length / 4 ) );
// Check again based on the third quarter.
hm2 = diffHalfMatchI( longtext, shorttext,
Math.ceil( longtext.length / 2 ) );
if ( !hm1 && !hm2 ) {
return null;
} else if ( !hm2 ) {
hm = hm1;
} else if ( !hm1 ) {
hm = hm2;
} else {
// Both matched. Select the longest.
hm = hm1[ 4 ].length > hm2[ 4 ].length ? hm1 : hm2;
}
// A half-match was found, sort out the return data.
text1A, text1B, text2A, text2B;
if ( text1.length > text2.length ) {
text1A = hm[ 0 ];
text1B = hm[ 1 ];
text2A = hm[ 2 ];
text2B = hm[ 3 ];
} else {
text2A = hm[ 0 ];
text2B = hm[ 1 ];
text1A = hm[ 2 ];
text1B = hm[ 3 ];
}
midCommon = hm[ 4 ];
return [ text1A, text1B, text2A, text2B, midCommon ];
};
/**
* Do a quick line-level diff on both strings, then rediff the parts for
* greater accuracy.
* This speedup can produce non-minimal diffs.
* @param {string} text1 Old string to be diffed.
* @param {string} text2 New string to be diffed.
* @param {number} deadline Time when the diff should be complete by.
* @return {!Array.} Array of diff tuples.
* @private
*/
DiffMatchPatch.prototype.diffLineMode = function( text1, text2, deadline ) {
var a, diffs, linearray, pointer, countInsert,
countDelete, textInsert, textDelete, j;
// Scan the text on a line-by-line basis first.
a = this.diffLinesToChars( text1, text2 );
text1 = a.chars1;
text2 = a.chars2;
linearray = a.lineArray;
diffs = this.DiffMain( text1, text2, false, deadline );
// Convert the diff back to original text.
this.diffCharsToLines( diffs, linearray );
// Eliminate freak matches (e.g. blank lines)
this.diffCleanupSemantic( diffs );
// Rediff any replacement blocks, this time character-by-character.
// Add a dummy entry at the end.
diffs.push( [ DIFF_EQUAL, "" ] );
pointer = 0;
countDelete = 0;
countInsert = 0;
textDelete = "";
textInsert = "";
while ( pointer < diffs.length ) {
switch ( diffs[ pointer ][ 0 ] ) {
case DIFF_INSERT:
countInsert++;
textInsert += diffs[ pointer ][ 1 ];
break;
case DIFF_DELETE:
countDelete++;
textDelete += diffs[ pointer ][ 1 ];
break;
case DIFF_EQUAL:
// Upon reaching an equality, check for prior redundancies.
if ( countDelete >= 1 && countInsert >= 1 ) {
// Delete the offending records and add the merged ones.
diffs.splice( pointer - countDelete - countInsert,
countDelete + countInsert );
pointer = pointer - countDelete - countInsert;
a = this.DiffMain( textDelete, textInsert, false, deadline );
for ( j = a.length - 1; j >= 0; j-- ) {
diffs.splice( pointer, 0, a[ j ] );
}
pointer = pointer + a.length;
}
countInsert = 0;
countDelete = 0;
textDelete = "";
textInsert = "";
break;
}
pointer++;
}
diffs.pop(); // Remove the dummy entry at the end.
return diffs;
};
/**
* Find the 'middle snake' of a diff, split the problem in two
* and return the recursively constructed diff.
* See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations.
* @param {string} text1 Old string to be diffed.
* @param {string} text2 New string to be diffed.
* @param {number} deadline Time at which to bail if not yet complete.
* @return {!Array.} Array of diff tuples.
* @private
*/
DiffMatchPatch.prototype.diffBisect = function( text1, text2, deadline ) {
var text1Length, text2Length, maxD, vOffset, vLength,
v1, v2, x, delta, front, k1start, k1end, k2start,
k2end, k2Offset, k1Offset, x1, x2, y1, y2, d, k1, k2;
// Cache the text lengths to prevent multiple calls.
text1Length = text1.length;
text2Length = text2.length;
maxD = Math.ceil( ( text1Length + text2Length ) / 2 );
vOffset = maxD;
vLength = 2 * maxD;
v1 = new Array( vLength );
v2 = new Array( vLength );
// Setting all elements to -1 is faster in Chrome & Firefox than mixing
// integers and undefined.
for ( x = 0; x < vLength; x++ ) {
v1[ x ] = -1;
v2[ x ] = -1;
}
v1[ vOffset + 1 ] = 0;
v2[ vOffset + 1 ] = 0;
delta = text1Length - text2Length;
// If the total number of characters is odd, then the front path will collide
// with the reverse path.
front = ( delta % 2 !== 0 );
// Offsets for start and end of k loop.
// Prevents mapping of space beyond the grid.
k1start = 0;
k1end = 0;
k2start = 0;
k2end = 0;
for ( d = 0; d < maxD; d++ ) {
// Bail out if deadline is reached.
if ( ( new Date() ).getTime() > deadline ) {
break;
}
// Walk the front path one step.
for ( k1 = -d + k1start; k1 <= d - k1end; k1 += 2 ) {
k1Offset = vOffset + k1;
if ( k1 === -d || ( k1 !== d && v1[ k1Offset - 1 ] < v1[ k1Offset + 1 ] ) ) {
x1 = v1[ k1Offset + 1 ];
} else {
x1 = v1[ k1Offset - 1 ] + 1;
}
y1 = x1 - k1;
while ( x1 < text1Length && y1 < text2Length &&
text1.charAt( x1 ) === text2.charAt( y1 ) ) {
x1++;
y1++;
}
v1[ k1Offset ] = x1;
if ( x1 > text1Length ) {
// Ran off the right of the graph.
k1end += 2;
} else if ( y1 > text2Length ) {
// Ran off the bottom of the graph.
k1start += 2;
} else if ( front ) {
k2Offset = vOffset + delta - k1;
if ( k2Offset >= 0 && k2Offset < vLength && v2[ k2Offset ] !== -1 ) {
// Mirror x2 onto top-left coordinate system.
x2 = text1Length - v2[ k2Offset ];
if ( x1 >= x2 ) {
// Overlap detected.
return this.diffBisectSplit( text1, text2, x1, y1, deadline );
}
}
}
}
// Walk the reverse path one step.
for ( k2 = -d + k2start; k2 <= d - k2end; k2 += 2 ) {
k2Offset = vOffset + k2;
if ( k2 === -d || ( k2 !== d && v2[ k2Offset - 1 ] < v2[ k2Offset + 1 ] ) ) {
x2 = v2[ k2Offset + 1 ];
} else {
x2 = v2[ k2Offset - 1 ] + 1;
}
y2 = x2 - k2;
while ( x2 < text1Length && y2 < text2Length &&
text1.charAt( text1Length - x2 - 1 ) ===
text2.charAt( text2Length - y2 - 1 ) ) {
x2++;
y2++;
}
v2[ k2Offset ] = x2;
if ( x2 > text1Length ) {
// Ran off the left of the graph.
k2end += 2;
} else if ( y2 > text2Length ) {
// Ran off the top of the graph.
k2start += 2;
} else if ( !front ) {
k1Offset = vOffset + delta - k2;
if ( k1Offset >= 0 && k1Offset < vLength && v1[ k1Offset ] !== -1 ) {
x1 = v1[ k1Offset ];
y1 = vOffset + x1 - k1Offset;
// Mirror x2 onto top-left coordinate system.
x2 = text1Length - x2;
if ( x1 >= x2 ) {
// Overlap detected.
return this.diffBisectSplit( text1, text2, x1, y1, deadline );
}
}
}
}
}
// Diff took too long and hit the deadline or
// number of diffs equals number of characters, no commonality at all.
return [
[ DIFF_DELETE, text1 ],
[ DIFF_INSERT, text2 ]
];
};
/**
* Given the location of the 'middle snake', split the diff in two parts
* and recurse.
* @param {string} text1 Old string to be diffed.
* @param {string} text2 New string to be diffed.
* @param {number} x Index of split point in text1.
* @param {number} y Index of split point in text2.
* @param {number} deadline Time at which to bail if not yet complete.
* @return {!Array.} Array of diff tuples.
* @private
*/
DiffMatchPatch.prototype.diffBisectSplit = function( text1, text2, x, y, deadline ) {
var text1a, text1b, text2a, text2b, diffs, diffsb;
text1a = text1.substring( 0, x );
text2a = text2.substring( 0, y );
text1b = text1.substring( x );
text2b = text2.substring( y );
// Compute both diffs serially.
diffs = this.DiffMain( text1a, text2a, false, deadline );
diffsb = this.DiffMain( text1b, text2b, false, deadline );
return diffs.concat( diffsb );
};
/**
* Reduce the number of edits by eliminating semantically trivial equalities.
* @param {!Array.} diffs Array of diff tuples.
*/
DiffMatchPatch.prototype.diffCleanupSemantic = function( diffs ) {
var changes, equalities, equalitiesLength, lastequality,
pointer, lengthInsertions2, lengthDeletions2, lengthInsertions1,
lengthDeletions1, deletion, insertion, overlapLength1, overlapLength2;
changes = false;
equalities = []; // Stack of indices where equalities are found.
equalitiesLength = 0; // Keeping our own length var is faster in JS.
/** @type {?string} */
lastequality = null;
// Always equal to diffs[equalities[equalitiesLength - 1]][1]
pointer = 0; // Index of current position.
// Number of characters that changed prior to the equality.
lengthInsertions1 = 0;
lengthDeletions1 = 0;
// Number of characters that changed after the equality.
lengthInsertions2 = 0;
lengthDeletions2 = 0;
while ( pointer < diffs.length ) {
if ( diffs[ pointer ][ 0 ] === DIFF_EQUAL ) { // Equality found.
equalities[ equalitiesLength++ ] = pointer;
lengthInsertions1 = lengthInsertions2;
lengthDeletions1 = lengthDeletions2;
lengthInsertions2 = 0;
lengthDeletions2 = 0;
lastequality = diffs[ pointer ][ 1 ];
} else { // An insertion or deletion.
if ( diffs[ pointer ][ 0 ] === DIFF_INSERT ) {
lengthInsertions2 += diffs[ pointer ][ 1 ].length;
} else {
lengthDeletions2 += diffs[ pointer ][ 1 ].length;
}
// Eliminate an equality that is smaller or equal to the edits on both
// sides of it.
if ( lastequality && ( lastequality.length <=
Math.max( lengthInsertions1, lengthDeletions1 ) ) &&
( lastequality.length <= Math.max( lengthInsertions2,
lengthDeletions2 ) ) ) {
// Duplicate record.
diffs.splice(
equalities[ equalitiesLength - 1 ],
0,
[ DIFF_DELETE, lastequality ]
);
// Change second copy to insert.
diffs[ equalities[ equalitiesLength - 1 ] + 1 ][ 0 ] = DIFF_INSERT;
// Throw away the equality we just deleted.
equalitiesLength--;
// Throw away the previous equality (it needs to be reevaluated).
equalitiesLength--;
pointer = equalitiesLength > 0 ? equalities[ equalitiesLength - 1 ] : -1;
// Reset the counters.
lengthInsertions1 = 0;
lengthDeletions1 = 0;
lengthInsertions2 = 0;
lengthDeletions2 = 0;
lastequality = null;
changes = true;
}
}
pointer++;
}
// Normalize the diff.
if ( changes ) {
this.diffCleanupMerge( diffs );
}
// Find any overlaps between deletions and insertions.
// e.g: abcxxxxxxdef
// -> abcxxxdef
// e.g: xxxabcdefxxx
// -> defxxxabc
// Only extract an overlap if it is as big as the edit ahead or behind it.
pointer = 1;
while ( pointer < diffs.length ) {
if ( diffs[ pointer - 1 ][ 0 ] === DIFF_DELETE &&
diffs[ pointer ][ 0 ] === DIFF_INSERT ) {
deletion = diffs[ pointer - 1 ][ 1 ];
insertion = diffs[ pointer ][ 1 ];
overlapLength1 = this.diffCommonOverlap( deletion, insertion );
overlapLength2 = this.diffCommonOverlap( insertion, deletion );
if ( overlapLength1 >= overlapLength2 ) {
if ( overlapLength1 >= deletion.length / 2 ||
overlapLength1 >= insertion.length / 2 ) {
// Overlap found. Insert an equality and trim the surrounding edits.
diffs.splice(
pointer,
0,
[ DIFF_EQUAL, insertion.substring( 0, overlapLength1 ) ]
);
diffs[ pointer - 1 ][ 1 ] =
deletion.substring( 0, deletion.length - overlapLength1 );
diffs[ pointer + 1 ][ 1 ] = insertion.substring( overlapLength1 );
pointer++;
}
} else {
if ( overlapLength2 >= deletion.length / 2 ||
overlapLength2 >= insertion.length / 2 ) {
// Reverse overlap found.
// Insert an equality and swap and trim the surrounding edits.
diffs.splice(
pointer,
0,
[ DIFF_EQUAL, deletion.substring( 0, overlapLength2 ) ]
);
diffs[ pointer - 1 ][ 0 ] = DIFF_INSERT;
diffs[ pointer - 1 ][ 1 ] =
insertion.substring( 0, insertion.length - overlapLength2 );
diffs[ pointer + 1 ][ 0 ] = DIFF_DELETE;
diffs[ pointer + 1 ][ 1 ] =
deletion.substring( overlapLength2 );
pointer++;
}
}
pointer++;
}
pointer++;
}
};
/**
* Determine if the suffix of one string is the prefix of another.
* @param {string} text1 First string.
* @param {string} text2 Second string.
* @return {number} The number of characters common to the end of the first
* string and the start of the second string.
* @private
*/
DiffMatchPatch.prototype.diffCommonOverlap = function( text1, text2 ) {
var text1Length, text2Length, textLength,
best, length, pattern, found;
// Cache the text lengths to prevent multiple calls.
text1Length = text1.length;
text2Length = text2.length;
// Eliminate the null case.
if ( text1Length === 0 || text2Length === 0 ) {
return 0;
}
// Truncate the longer string.
if ( text1Length > text2Length ) {
text1 = text1.substring( text1Length - text2Length );
} else if ( text1Length < text2Length ) {
text2 = text2.substring( 0, text1Length );
}
textLength = Math.min( text1Length, text2Length );
// Quick check for the worst case.
if ( text1 === text2 ) {
return textLength;
}
// Start by looking for a single character match
// and increase length until no match is found.
// Performance analysis: https://neil.fraser.name/news/2010/11/04/
best = 0;
length = 1;
while ( true ) {
pattern = text1.substring( textLength - length );
found = text2.indexOf( pattern );
if ( found === -1 ) {
return best;
}
length += found;
if ( found === 0 || text1.substring( textLength - length ) ===
text2.substring( 0, length ) ) {
best = length;
length++;
}
}
};
/**
* Split two texts into an array of strings. Reduce the texts to a string of
* hashes where each Unicode character represents one line.
* @param {string} text1 First string.
* @param {string} text2 Second string.
* @return {{chars1: string, chars2: string, lineArray: !Array.}}
* An object containing the encoded text1, the encoded text2 and
* the array of unique strings.
* The zeroth element of the array of unique strings is intentionally blank.
* @private
*/
DiffMatchPatch.prototype.diffLinesToChars = function( text1, text2 ) {
var lineArray, lineHash, chars1, chars2;
lineArray = []; // E.g. lineArray[4] === 'Hello\n'
lineHash = {}; // E.g. lineHash['Hello\n'] === 4
// '\x00' is a valid character, but various debuggers don't like it.
// So we'll insert a junk entry to avoid generating a null character.
lineArray[ 0 ] = "";
/**
* Split a text into an array of strings. Reduce the texts to a string of
* hashes where each Unicode character represents one line.
* Modifies linearray and linehash through being a closure.
* @param {string} text String to encode.
* @return {string} Encoded string.
* @private
*/
function diffLinesToCharsMunge( text ) {
var chars, lineStart, lineEnd, lineArrayLength, line;
chars = "";
// Walk the text, pulling out a substring for each line.
// text.split('\n') would would temporarily double our memory footprint.
// Modifying text would create many large strings to garbage collect.
lineStart = 0;
lineEnd = -1;
// Keeping our own length variable is faster than looking it up.
lineArrayLength = lineArray.length;
while ( lineEnd < text.length - 1 ) {
lineEnd = text.indexOf( "\n", lineStart );
if ( lineEnd === -1 ) {
lineEnd = text.length - 1;
}
line = text.substring( lineStart, lineEnd + 1 );
lineStart = lineEnd + 1;
if ( lineHash.hasOwnProperty ? lineHash.hasOwnProperty( line ) :
( lineHash[ line ] !== undefined ) ) {
chars += String.fromCharCode( lineHash[ line ] );
} else {
chars += String.fromCharCode( lineArrayLength );
lineHash[ line ] = lineArrayLength;
lineArray[ lineArrayLength++ ] = line;
}
}
return chars;
}
chars1 = diffLinesToCharsMunge( text1 );
chars2 = diffLinesToCharsMunge( text2 );
return {
chars1: chars1,
chars2: chars2,
lineArray: lineArray
};
};
/**
* Rehydrate the text in a diff from a string of line hashes to real lines of
* text.
* @param {!Array.} diffs Array of diff tuples.
* @param {!Array.} lineArray Array of unique strings.
* @private
*/
DiffMatchPatch.prototype.diffCharsToLines = function( diffs, lineArray ) {
var x, chars, text, y;
for ( x = 0; x < diffs.length; x++ ) {
chars = diffs[ x ][ 1 ];
text = [];
for ( y = 0; y < chars.length; y++ ) {
text[ y ] = lineArray[ chars.charCodeAt( y ) ];
}
diffs[ x ][ 1 ] = text.join( "" );
}
};
/**
* Reorder and merge like edit sections. Merge equalities.
* Any edit section can move as long as it doesn't cross an equality.
* @param {!Array.} diffs Array of diff tuples.
*/
DiffMatchPatch.prototype.diffCleanupMerge = function( diffs ) {
var pointer, countDelete, countInsert, textInsert, textDelete,
commonlength, changes, diffPointer, position;
diffs.push( [ DIFF_EQUAL, "" ] ); // Add a dummy entry at the end.
pointer = 0;
countDelete = 0;
countInsert = 0;
textDelete = "";
textInsert = "";
commonlength;
while ( pointer < diffs.length ) {
switch ( diffs[ pointer ][ 0 ] ) {
case DIFF_INSERT:
countInsert++;
textInsert += diffs[ pointer ][ 1 ];
pointer++;
break;
case DIFF_DELETE:
countDelete++;
textDelete += diffs[ pointer ][ 1 ];
pointer++;
break;
case DIFF_EQUAL:
// Upon reaching an equality, check for prior redundancies.
if ( countDelete + countInsert > 1 ) {
if ( countDelete !== 0 && countInsert !== 0 ) {
// Factor out any common prefixes.
commonlength = this.diffCommonPrefix( textInsert, textDelete );
if ( commonlength !== 0 ) {
if ( ( pointer - countDelete - countInsert ) > 0 &&
diffs[ pointer - countDelete - countInsert - 1 ][ 0 ] ===
DIFF_EQUAL ) {
diffs[ pointer - countDelete - countInsert - 1 ][ 1 ] +=
textInsert.substring( 0, commonlength );
} else {
diffs.splice( 0, 0, [ DIFF_EQUAL,
textInsert.substring( 0, commonlength )
] );
pointer++;
}
textInsert = textInsert.substring( commonlength );
textDelete = textDelete.substring( commonlength );
}
// Factor out any common suffixies.
commonlength = this.diffCommonSuffix( textInsert, textDelete );
if ( commonlength !== 0 ) {
diffs[ pointer ][ 1 ] = textInsert.substring( textInsert.length -
commonlength ) + diffs[ pointer ][ 1 ];
textInsert = textInsert.substring( 0, textInsert.length -
commonlength );
textDelete = textDelete.substring( 0, textDelete.length -
commonlength );
}
}
// Delete the offending records and add the merged ones.
if ( countDelete === 0 ) {
diffs.splice( pointer - countInsert,
countDelete + countInsert, [ DIFF_INSERT, textInsert ] );
} else if ( countInsert === 0 ) {
diffs.splice( pointer - countDelete,
countDelete + countInsert, [ DIFF_DELETE, textDelete ] );
} else {
diffs.splice(
pointer - countDelete - countInsert,
countDelete + countInsert,
[ DIFF_DELETE, textDelete ], [ DIFF_INSERT, textInsert ]
);
}
pointer = pointer - countDelete - countInsert +
( countDelete ? 1 : 0 ) + ( countInsert ? 1 : 0 ) + 1;
} else if ( pointer !== 0 && diffs[ pointer - 1 ][ 0 ] === DIFF_EQUAL ) {
// Merge this equality with the previous one.
diffs[ pointer - 1 ][ 1 ] += diffs[ pointer ][ 1 ];
diffs.splice( pointer, 1 );
} else {
pointer++;
}
countInsert = 0;
countDelete = 0;
textDelete = "";
textInsert = "";
break;
}
}
if ( diffs[ diffs.length - 1 ][ 1 ] === "" ) {
diffs.pop(); // Remove the dummy entry at the end.
}
// Second pass: look for single edits surrounded on both sides by equalities
// which can be shifted sideways to eliminate an equality.
// e.g: ABAC -> ABAC
changes = false;
pointer = 1;
// Intentionally ignore the first and last element (don't need checking).
while ( pointer < diffs.length - 1 ) {
if ( diffs[ pointer - 1 ][ 0 ] === DIFF_EQUAL &&
diffs[ pointer + 1 ][ 0 ] === DIFF_EQUAL ) {
diffPointer = diffs[ pointer ][ 1 ];
position = diffPointer.substring(
diffPointer.length - diffs[ pointer - 1 ][ 1 ].length
);
// This is a single edit surrounded by equalities.
if ( position === diffs[ pointer - 1 ][ 1 ] ) {
// Shift the edit over the previous equality.
diffs[ pointer ][ 1 ] = diffs[ pointer - 1 ][ 1 ] +
diffs[ pointer ][ 1 ].substring( 0, diffs[ pointer ][ 1 ].length -
diffs[ pointer - 1 ][ 1 ].length );
diffs[ pointer + 1 ][ 1 ] =
diffs[ pointer - 1 ][ 1 ] + diffs[ pointer + 1 ][ 1 ];
diffs.splice( pointer - 1, 1 );
changes = true;
} else if ( diffPointer.substring( 0, diffs[ pointer + 1 ][ 1 ].length ) ===
diffs[ pointer + 1 ][ 1 ] ) {
// Shift the edit over the next equality.
diffs[ pointer - 1 ][ 1 ] += diffs[ pointer + 1 ][ 1 ];
diffs[ pointer ][ 1 ] =
diffs[ pointer ][ 1 ].substring( diffs[ pointer + 1 ][ 1 ].length ) +
diffs[ pointer + 1 ][ 1 ];
diffs.splice( pointer + 1, 1 );
changes = true;
}
}
pointer++;
}
// If shifts were made, the diff needs reordering and another shift sweep.
if ( changes ) {
this.diffCleanupMerge( diffs );
}
};
return function( o, n ) {
var diff, output, text;
diff = new DiffMatchPatch();
output = diff.DiffMain( o, n );
diff.diffCleanupEfficiency( output );
text = diff.diffPrettyHtml( output );
return text;
};
}() );
}() );
Django-1.11.11/js_tests/qunit/qunit.css 0000664 0001750 0001750 00000016440 13247517144 017351 0 ustar tim tim 0000000 0000000 /*!
* QUnit 2.0.1
* https://qunitjs.com/
*
* Copyright jQuery Foundation and other contributors
* Released under the MIT license
* https://jquery.org/license
*
* Date: 2016-07-23T19:39Z
*/
/** Font Family and Sizes */
#qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-filteredTest, #qunit-userAgent, #qunit-testresult {
font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
}
#qunit-testrunner-toolbar, #qunit-filteredTest, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
#qunit-tests { font-size: smaller; }
/** Resets */
#qunit-tests, #qunit-header, #qunit-banner, #qunit-filteredTest, #qunit-userAgent, #qunit-testresult, #qunit-modulefilter {
margin: 0;
padding: 0;
}
/** Header (excluding toolbar) */
#qunit-header {
padding: 0.5em 0 0.5em 1em;
color: #8699A4;
background-color: #0D3349;
font-size: 1.5em;
line-height: 1em;
font-weight: 400;
border-radius: 5px 5px 0 0;
}
#qunit-header a {
text-decoration: none;
color: #C2CCD1;
}
#qunit-header a:hover,
#qunit-header a:focus {
color: #FFF;
}
#qunit-banner {
height: 5px;
}
#qunit-filteredTest {
padding: 0.5em 1em 0.5em 1em;
color: #366097;
background-color: #F4FF77;
}
#qunit-userAgent {
padding: 0.5em 1em 0.5em 1em;
color: #FFF;
background-color: #2B81AF;
text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
}
/** Toolbar */
#qunit-testrunner-toolbar {
padding: 0.5em 1em 0.5em 1em;
color: #5E740B;
background-color: #EEE;
}
#qunit-testrunner-toolbar .clearfix {
height: 0;
clear: both;
}
#qunit-testrunner-toolbar label {
display: inline-block;
}
#qunit-testrunner-toolbar input[type=checkbox],
#qunit-testrunner-toolbar input[type=radio] {
margin: 3px;
vertical-align: -2px;
}
#qunit-testrunner-toolbar input[type=text] {
box-sizing: border-box;
height: 1.6em;
}
.qunit-url-config,
.qunit-filter,
#qunit-modulefilter {
display: inline-block;
line-height: 2.1em;
}
.qunit-filter,
#qunit-modulefilter {
float: right;
position: relative;
margin-left: 1em;
}
.qunit-url-config label {
margin-right: 0.5em;
}
#qunit-modulefilter-search {
box-sizing: border-box;
width: 400px;
}
#qunit-modulefilter-search-container:after {
position: absolute;
right: 0.3em;
content: "\25bc";
color: black;
}
#qunit-modulefilter-dropdown {
/* align with #qunit-modulefilter-search */
box-sizing: border-box;
width: 400px;
position: absolute;
right: 0;
top: 50%;
margin-top: 0.8em;
border: 1px solid #D3D3D3;
border-top: none;
border-radius: 0 0 .25em .25em;
color: #000;
background-color: #F5F5F5;
z-index: 99;
}
#qunit-modulefilter-dropdown a {
color: inherit;
text-decoration: none;
}
#qunit-modulefilter-dropdown .clickable.checked {
font-weight: bold;
color: #000;
background-color: #D2E0E6;
}
#qunit-modulefilter-dropdown .clickable:hover {
color: #FFF;
background-color: #0D3349;
}
#qunit-modulefilter-actions {
display: block;
overflow: auto;
/* align with #qunit-modulefilter-dropdown-list */
font: smaller/1.5em sans-serif;
}
#qunit-modulefilter-dropdown #qunit-modulefilter-actions > * {
box-sizing: border-box;
max-height: 2.8em;
display: block;
padding: 0.4em;
}
#qunit-modulefilter-dropdown #qunit-modulefilter-actions > button {
float: right;
font: inherit;
}
#qunit-modulefilter-dropdown #qunit-modulefilter-actions > :last-child {
/* insert padding to align with checkbox margins */
padding-left: 3px;
}
#qunit-modulefilter-dropdown-list {
max-height: 200px;
overflow-y: auto;
margin: 0;
border-top: 2px groove threedhighlight;
padding: 0.4em 0 0;
font: smaller/1.5em sans-serif;
}
#qunit-modulefilter-dropdown-list li {
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
#qunit-modulefilter-dropdown-list .clickable {
display: block;
padding-left: 0.15em;
}
/** Tests: Pass/Fail */
#qunit-tests {
list-style-position: inside;
}
#qunit-tests li {
padding: 0.4em 1em 0.4em 1em;
border-bottom: 1px solid #FFF;
list-style-position: inside;
}
#qunit-tests > li {
display: none;
}
#qunit-tests li.running,
#qunit-tests li.pass,
#qunit-tests li.fail,
#qunit-tests li.skipped {
display: list-item;
}
#qunit-tests.hidepass {
position: relative;
}
#qunit-tests.hidepass li.running,
#qunit-tests.hidepass li.pass {
visibility: hidden;
position: absolute;
width: 0;
height: 0;
padding: 0;
border: 0;
margin: 0;
}
#qunit-tests li strong {
cursor: pointer;
}
#qunit-tests li.skipped strong {
cursor: default;
}
#qunit-tests li a {
padding: 0.5em;
color: #C2CCD1;
text-decoration: none;
}
#qunit-tests li p a {
padding: 0.25em;
color: #6B6464;
}
#qunit-tests li a:hover,
#qunit-tests li a:focus {
color: #000;
}
#qunit-tests li .runtime {
float: right;
font-size: smaller;
}
.qunit-assert-list {
margin-top: 0.5em;
padding: 0.5em;
background-color: #FFF;
border-radius: 5px;
}
.qunit-source {
margin: 0.6em 0 0.3em;
}
.qunit-collapsed {
display: none;
}
#qunit-tests table {
border-collapse: collapse;
margin-top: 0.2em;
}
#qunit-tests th {
text-align: right;
vertical-align: top;
padding: 0 0.5em 0 0;
}
#qunit-tests td {
vertical-align: top;
}
#qunit-tests pre {
margin: 0;
white-space: pre-wrap;
word-wrap: break-word;
}
#qunit-tests del {
color: #374E0C;
background-color: #E0F2BE;
text-decoration: none;
}
#qunit-tests ins {
color: #500;
background-color: #FFCACA;
text-decoration: none;
}
/*** Test Counts */
#qunit-tests b.counts { color: #000; }
#qunit-tests b.passed { color: #5E740B; }
#qunit-tests b.failed { color: #710909; }
#qunit-tests li li {
padding: 5px;
background-color: #FFF;
border-bottom: none;
list-style-position: inside;
}
/*** Passing Styles */
#qunit-tests li li.pass {
color: #3C510C;
background-color: #FFF;
border-left: 10px solid #C6E746;
}
#qunit-tests .pass { color: #528CE0; background-color: #D2E0E6; }
#qunit-tests .pass .test-name { color: #366097; }
#qunit-tests .pass .test-actual,
#qunit-tests .pass .test-expected { color: #999; }
#qunit-banner.qunit-pass { background-color: #C6E746; }
/*** Failing Styles */
#qunit-tests li li.fail {
color: #710909;
background-color: #FFF;
border-left: 10px solid #EE5757;
white-space: pre;
}
#qunit-tests > li:last-child {
border-radius: 0 0 5px 5px;
}
#qunit-tests .fail { color: #000; background-color: #EE5757; }
#qunit-tests .fail .test-name,
#qunit-tests .fail .module-name { color: #000; }
#qunit-tests .fail .test-actual { color: #EE5757; }
#qunit-tests .fail .test-expected { color: #008000; }
#qunit-banner.qunit-fail { background-color: #EE5757; }
/*** Skipped tests */
#qunit-tests .skipped {
background-color: #EBECE9;
}
#qunit-tests .qunit-skipped-label {
background-color: #F4FF77;
display: inline-block;
font-style: normal;
color: #366097;
line-height: 1.8em;
padding: 0 0.5em;
margin: -0.4em 0.4em -0.4em 0;
}
/** Result */
#qunit-testresult {
padding: 0.5em 1em 0.5em 1em;
color: #2B81AF;
background-color: #D2E0E6;
border-bottom: 1px solid #FFF;
}
#qunit-testresult .module-name {
font-weight: 700;
}
/** Fixture */
#qunit-fixture {
position: absolute;
top: -10000px;
left: -10000px;
width: 1000px;
height: 1000px;
}
Django-1.11.11/js_tests/tests.html 0000664 0001750 0001750 00000007636 13247520251 016367 0 ustar tim tim 0000000 0000000
Django JavaScript Tests
Django-1.11.11/LICENSE.python 0000664 0001750 0001750 00000030737 13247517143 015032 0 ustar tim tim 0000000 0000000 A. HISTORY OF THE SOFTWARE
==========================
Python was created in the early 1990s by Guido van Rossum at Stichting
Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
as a successor of a language called ABC. Guido remains Python's
principal author, although it includes many contributions from others.
In 1995, Guido continued his work on Python at the Corporation for
National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
in Reston, Virginia where he released several versions of the
software.
In May 2000, Guido and the Python core development team moved to
BeOpen.com to form the BeOpen PythonLabs team. In October of the same
year, the PythonLabs team moved to Digital Creations (now Zope
Corporation, see http://www.zope.com). In 2001, the Python Software
Foundation (PSF, see http://www.python.org/psf/) was formed, a
non-profit organization created specifically to own Python-related
Intellectual Property. Zope Corporation is a sponsoring member of
the PSF.
All Python releases are Open Source (see http://www.opensource.org for
the Open Source Definition). Historically, most, but not all, Python
releases have also been GPL-compatible; the table below summarizes
the various releases.
Release Derived Year Owner GPL-
from compatible? (1)
0.9.0 thru 1.2 1991-1995 CWI yes
1.3 thru 1.5.2 1.2 1995-1999 CNRI yes
1.6 1.5.2 2000 CNRI no
2.0 1.6 2000 BeOpen.com no
1.6.1 1.6 2001 CNRI yes (2)
2.1 2.0+1.6.1 2001 PSF no
2.0.1 2.0+1.6.1 2001 PSF yes
2.1.1 2.1+2.0.1 2001 PSF yes
2.1.2 2.1.1 2002 PSF yes
2.1.3 2.1.2 2002 PSF yes
2.2 and above 2.1.1 2001-now PSF yes
Footnotes:
(1) GPL-compatible doesn't mean that we're distributing Python under
the GPL. All Python licenses, unlike the GPL, let you distribute
a modified version without making your changes open source. The
GPL-compatible licenses make it possible to combine Python with
other software that is released under the GPL; the others don't.
(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
because its license has a choice of law clause. According to
CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
is "not incompatible" with the GPL.
Thanks to the many outside volunteers who have worked under Guido's
direction to make these releases possible.
B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
===============================================================
PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
--------------------------------------------
1. This LICENSE AGREEMENT is between the Python Software Foundation
("PSF"), and the Individual or Organization ("Licensee") accessing and
otherwise using this software ("Python") in source or binary form and
its associated documentation.
2. Subject to the terms and conditions of this License Agreement, PSF hereby
grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
analyze, test, perform and/or display publicly, prepare derivative works,
distribute, and otherwise use Python alone or in any derivative version,
provided, however, that PSF's License Agreement and PSF's notice of copyright,
i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
2011, 2012, 2013, 2014, 2015, 2016 Python Software Foundation; All Rights
Reserved" are retained in Python alone or in any derivative version prepared by
Licensee.
3. In the event Licensee prepares a derivative work that is based on
or incorporates Python or any part thereof, and wants to make
the derivative work available to others as provided herein, then
Licensee hereby agrees to include in any such work a brief summary of
the changes made to Python.
4. PSF is making Python available to Licensee on an "AS IS"
basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
INFRINGE ANY THIRD PARTY RIGHTS.
5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
6. This License Agreement will automatically terminate upon a material
breach of its terms and conditions.
7. Nothing in this License Agreement shall be deemed to create any
relationship of agency, partnership, or joint venture between PSF and
Licensee. This License Agreement does not grant permission to use PSF
trademarks or trade name in a trademark sense to endorse or promote
products or services of Licensee, or any third party.
8. By copying, installing or otherwise using Python, Licensee
agrees to be bound by the terms and conditions of this License
Agreement.
BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
-------------------------------------------
BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
Individual or Organization ("Licensee") accessing and otherwise using
this software in source or binary form and its associated
documentation ("the Software").
2. Subject to the terms and conditions of this BeOpen Python License
Agreement, BeOpen hereby grants Licensee a non-exclusive,
royalty-free, world-wide license to reproduce, analyze, test, perform
and/or display publicly, prepare derivative works, distribute, and
otherwise use the Software alone or in any derivative version,
provided, however, that the BeOpen Python License is retained in the
Software, alone or in any derivative version prepared by Licensee.
3. BeOpen is making the Software available to Licensee on an "AS IS"
basis. BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
INFRINGE ANY THIRD PARTY RIGHTS.
4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
5. This License Agreement will automatically terminate upon a material
breach of its terms and conditions.
6. This License Agreement shall be governed by and interpreted in all
respects by the law of the State of California, excluding conflict of
law provisions. Nothing in this License Agreement shall be deemed to
create any relationship of agency, partnership, or joint venture
between BeOpen and Licensee. This License Agreement does not grant
permission to use BeOpen trademarks or trade names in a trademark
sense to endorse or promote products or services of Licensee, or any
third party. As an exception, the "BeOpen Python" logos available at
http://www.pythonlabs.com/logos.html may be used according to the
permissions granted on that web page.
7. By copying, installing or otherwise using the software, Licensee
agrees to be bound by the terms and conditions of this License
Agreement.
CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
---------------------------------------
1. This LICENSE AGREEMENT is between the Corporation for National
Research Initiatives, having an office at 1895 Preston White Drive,
Reston, VA 20191 ("CNRI"), and the Individual or Organization
("Licensee") accessing and otherwise using Python 1.6.1 software in
source or binary form and its associated documentation.
2. Subject to the terms and conditions of this License Agreement, CNRI
hereby grants Licensee a nonexclusive, royalty-free, world-wide
license to reproduce, analyze, test, perform and/or display publicly,
prepare derivative works, distribute, and otherwise use Python 1.6.1
alone or in any derivative version, provided, however, that CNRI's
License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
1995-2001 Corporation for National Research Initiatives; All Rights
Reserved" are retained in Python 1.6.1 alone or in any derivative
version prepared by Licensee. Alternately, in lieu of CNRI's License
Agreement, Licensee may substitute the following text (omitting the
quotes): "Python 1.6.1 is made available subject to the terms and
conditions in CNRI's License Agreement. This Agreement together with
Python 1.6.1 may be located on the Internet using the following
unique, persistent identifier (known as a handle): 1895.22/1013. This
Agreement may also be obtained from a proxy server on the Internet
using the following URL: http://hdl.handle.net/1895.22/1013".
3. In the event Licensee prepares a derivative work that is based on
or incorporates Python 1.6.1 or any part thereof, and wants to make
the derivative work available to others as provided herein, then
Licensee hereby agrees to include in any such work a brief summary of
the changes made to Python 1.6.1.
4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
basis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
INFRINGE ANY THIRD PARTY RIGHTS.
5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
6. This License Agreement will automatically terminate upon a material
breach of its terms and conditions.
7. This License Agreement shall be governed by the federal
intellectual property law of the United States, including without
limitation the federal copyright law, and, to the extent such
U.S. federal law does not apply, by the law of the Commonwealth of
Virginia, excluding Virginia's conflict of law provisions.
Notwithstanding the foregoing, with regard to derivative works based
on Python 1.6.1 that incorporate non-separable material that was
previously distributed under the GNU General Public License (GPL), the
law of the Commonwealth of Virginia shall govern this License
Agreement only as to issues arising under or with respect to
Paragraphs 4, 5, and 7 of this License Agreement. Nothing in this
License Agreement shall be deemed to create any relationship of
agency, partnership, or joint venture between CNRI and Licensee. This
License Agreement does not grant permission to use CNRI trademarks or
trade name in a trademark sense to endorse or promote products or
services of Licensee, or any third party.
8. By clicking on the "ACCEPT" button where indicated, or by copying,
installing or otherwise using Python 1.6.1, Licensee agrees to be
bound by the terms and conditions of this License Agreement.
ACCEPT
CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
--------------------------------------------------
Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
The Netherlands. All rights reserved.
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Stichting Mathematisch
Centrum or CWI not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.
STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
Django-1.11.11/PKG-INFO 0000664 0001750 0001750 00000002403 13247520354 013565 0 ustar tim tim 0000000 0000000 Metadata-Version: 1.1
Name: Django
Version: 1.11.11
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
Description-Content-Type: UNKNOWN
Description: UNKNOWN
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 :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
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
Django-1.11.11/scripts/ 0000775 0001750 0001750 00000000000 13247520353 014157 5 ustar tim tim 0000000 0000000 Django-1.11.11/scripts/manage_translations.py 0000664 0001750 0001750 00000015710 13247520251 020563 0 ustar tim tim 0000000 0000000 #!/usr/bin/env python
#
# This python file contains utility scripts to manage Django translations.
# It has to be run inside the django git root directory.
#
# The following commands are available:
#
# * update_catalogs: check for new strings in core and contrib catalogs, and
# output how much strings are new/changed.
#
# * lang_stats: output statistics for each catalog/language combination
#
# * fetch: fetch translations from transifex.com
#
# Each command support the --languages and --resources options to limit their
# operation to the specified language or resource. For example, to get stats
# for Spanish in contrib.admin, run:
#
# $ python scripts/manage_translations.py lang_stats --language=es --resources=admin
import os
from argparse import ArgumentParser
from subprocess import PIPE, Popen, call
import django
from django.conf import settings
from django.core.management import call_command
HAVE_JS = ['admin']
def _get_locale_dirs(resources, include_core=True):
"""
Return a tuple (contrib name, absolute path) for all locale directories,
optionally including the django core catalog.
If resources list is not None, filter directories matching resources content.
"""
contrib_dir = os.path.join(os.getcwd(), 'django', 'contrib')
dirs = []
# Collect all locale directories
for contrib_name in os.listdir(contrib_dir):
path = os.path.join(contrib_dir, contrib_name, 'locale')
if os.path.isdir(path):
dirs.append((contrib_name, path))
if contrib_name in HAVE_JS:
dirs.append(("%s-js" % contrib_name, path))
if include_core:
dirs.insert(0, ('core', os.path.join(os.getcwd(), 'django', 'conf', 'locale')))
# Filter by resources, if any
if resources is not None:
res_names = [d[0] for d in dirs]
dirs = [ld for ld in dirs if ld[0] in resources]
if len(resources) > len(dirs):
print("You have specified some unknown resources. "
"Available resource names are: %s" % (', '.join(res_names),))
exit(1)
return dirs
def _tx_resource_for_name(name):
""" Return the Transifex resource name """
if name == 'core':
return "django.core"
else:
return "django.contrib-%s" % name
def _check_diff(cat_name, base_path):
"""
Output the approximate number of changed/added strings in the en catalog.
"""
po_path = '%(path)s/en/LC_MESSAGES/django%(ext)s.po' % {
'path': base_path, 'ext': 'js' if cat_name.endswith('-js') else ''}
p = Popen("git diff -U0 %s | egrep '^[-+]msgid' | wc -l" % po_path,
stdout=PIPE, stderr=PIPE, shell=True)
output, errors = p.communicate()
num_changes = int(output.strip())
print("%d changed/added messages in '%s' catalog." % (num_changes, cat_name))
def update_catalogs(resources=None, languages=None):
"""
Update the en/LC_MESSAGES/django.po (main and contrib) files with
new/updated translatable strings.
"""
settings.configure()
django.setup()
if resources is not None:
print("`update_catalogs` will always process all resources.")
contrib_dirs = _get_locale_dirs(None, include_core=False)
os.chdir(os.path.join(os.getcwd(), 'django'))
print("Updating en catalogs for Django and contrib apps...")
call_command('makemessages', locale=['en'])
print("Updating en JS catalogs for Django and contrib apps...")
call_command('makemessages', locale=['en'], domain='djangojs')
# Output changed stats
_check_diff('core', os.path.join(os.getcwd(), 'conf', 'locale'))
for name, dir_ in contrib_dirs:
_check_diff(name, dir_)
def lang_stats(resources=None, languages=None):
"""
Output language statistics of committed translation files for each
Django catalog.
If resources is provided, it should be a list of translation resource to
limit the output (e.g. ['core', 'gis']).
"""
locale_dirs = _get_locale_dirs(resources)
for name, dir_ in locale_dirs:
print("\nShowing translations stats for '%s':" % name)
langs = sorted([d for d in os.listdir(dir_) if not d.startswith('_')])
for lang in langs:
if languages and lang not in languages:
continue
# TODO: merge first with the latest en catalog
p = Popen("msgfmt -vc -o /dev/null %(path)s/%(lang)s/LC_MESSAGES/django%(ext)s.po" % {
'path': dir_, 'lang': lang, 'ext': 'js' if name.endswith('-js') else ''},
stdout=PIPE, stderr=PIPE, shell=True)
output, errors = p.communicate()
if p.returncode == 0:
# msgfmt output stats on stderr
print("%s: %s" % (lang, errors.strip()))
else:
print("Errors happened when checking %s translation for %s:\n%s" % (
lang, name, errors))
def fetch(resources=None, languages=None):
"""
Fetch translations from Transifex, wrap long lines, generate mo files.
"""
locale_dirs = _get_locale_dirs(resources)
errors = []
for name, dir_ in locale_dirs:
# Transifex pull
if languages is None:
call('tx pull -r %(res)s -a -f --minimum-perc=5' % {'res': _tx_resource_for_name(name)}, shell=True)
target_langs = sorted([d for d in os.listdir(dir_) if not d.startswith('_') and d != 'en'])
else:
for lang in languages:
call('tx pull -r %(res)s -f -l %(lang)s' % {
'res': _tx_resource_for_name(name), 'lang': lang}, shell=True)
target_langs = languages
# msgcat to wrap lines and msgfmt for compilation of .mo file
for lang in target_langs:
po_path = '%(path)s/%(lang)s/LC_MESSAGES/django%(ext)s.po' % {
'path': dir_, 'lang': lang, 'ext': 'js' if name.endswith('-js') else ''}
if not os.path.exists(po_path):
print("No %(lang)s translation for resource %(name)s" % {
'lang': lang, 'name': name})
continue
call('msgcat --no-location -o %s %s' % (po_path, po_path), shell=True)
res = call('msgfmt -c -o %s.mo %s' % (po_path[:-3], po_path), shell=True)
if res != 0:
errors.append((name, lang))
if errors:
print("\nWARNING: Errors have occurred in following cases:")
for resource, lang in errors:
print("\tResource %s for language %s" % (resource, lang))
exit(1)
if __name__ == "__main__":
RUNABLE_SCRIPTS = ('update_catalogs', 'lang_stats', 'fetch')
parser = ArgumentParser()
parser.add_argument('cmd', nargs=1, choices=RUNABLE_SCRIPTS)
parser.add_argument("-r", "--resources", action='append', help="limit operation to the specified resources")
parser.add_argument("-l", "--languages", action='append', help="limit operation to the specified languages")
options = parser.parse_args()
eval(options.cmd[0])(options.resources, options.languages)
Django-1.11.11/scripts/rpm-install.sh 0000664 0001750 0001750 00000001451 13213463123 016750 0 ustar tim tim 0000000 0000000 #! /bin/sh
#
# This file becomes the install section of the generated spec file.
#
# This is what dist.py normally does.
%{__python} setup.py install --root=${RPM_BUILD_ROOT} --record="INSTALLED_FILES"
# Sort the filelist so that directories appear before files. This avoids
# duplicate filename problems on some systems.
touch DIRS
for i in `cat INSTALLED_FILES`; do
if [ -f ${RPM_BUILD_ROOT}/$i ]; then
echo $i >>FILES
fi
if [ -d ${RPM_BUILD_ROOT}/$i ]; then
echo %dir $i >>DIRS
fi
done
# Make sure we match foo.pyo and foo.pyc along with foo.py (but only once each)
sed -e "/\.py[co]$/d" -e "s/\.py$/.py*/" DIRS FILES >INSTALLED_FILES
mkdir -p ${RPM_BUILD_ROOT}/%{_mandir}/man1/
cp docs/man/* ${RPM_BUILD_ROOT}/%{_mandir}/man1/
cat << EOF >> INSTALLED_FILES
%doc %{_mandir}/man1/*"
EOF
Django-1.11.11/Django.egg-info/ 0000775 0001750 0001750 00000000000 13247520352 015363 5 ustar tim tim 0000000 0000000 Django-1.11.11/Django.egg-info/PKG-INFO 0000664 0001750 0001750 00000002403 13247520351 016456 0 ustar tim tim 0000000 0000000 Metadata-Version: 1.1
Name: Django
Version: 1.11.11
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
Description-Content-Type: UNKNOWN
Description: UNKNOWN
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 :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
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
Django-1.11.11/Django.egg-info/top_level.txt 0000664 0001750 0001750 00000000007 13247520351 020111 0 ustar tim tim 0000000 0000000 django
Django-1.11.11/Django.egg-info/entry_points.txt 0000664 0001750 0001750 00000000123 13247520351 020654 0 ustar tim tim 0000000 0000000 [console_scripts]
django-admin = django.core.management:execute_from_command_line
Django-1.11.11/Django.egg-info/requires.txt 0000664 0001750 0001750 00000000064 13247520351 017762 0 ustar tim tim 0000000 0000000 pytz
[argon2]
argon2-cffi>=16.1.0
[bcrypt]
bcrypt
Django-1.11.11/Django.egg-info/SOURCES.txt 0000664 0001750 0001750 00001004427 13247520351 017256 0 ustar tim tim 0000000 0000000 AUTHORS
CONTRIBUTING.rst
Gruntfile.js
INSTALL
LICENSE
LICENSE.python
MANIFEST.in
README.rst
package.json
setup.cfg
setup.py
Django.egg-info/PKG-INFO
Django.egg-info/SOURCES.txt
Django.egg-info/dependency_links.txt
Django.egg-info/entry_points.txt
Django.egg-info/not-zip-safe
Django.egg-info/requires.txt
Django.egg-info/top_level.txt
django/__init__.py
django/__main__.py
django/shortcuts.py
django/apps/__init__.py
django/apps/config.py
django/apps/registry.py
django/bin/django-admin.py
django/conf/__init__.py
django/conf/global_settings.py
django/conf/app_template/__init__.py-tpl
django/conf/app_template/admin.py-tpl
django/conf/app_template/apps.py-tpl
django/conf/app_template/models.py-tpl
django/conf/app_template/tests.py-tpl
django/conf/app_template/views.py-tpl
django/conf/app_template/migrations/__init__.py-tpl
django/conf/locale/__init__.py
django/conf/locale/af/LC_MESSAGES/django.mo
django/conf/locale/af/LC_MESSAGES/django.po
django/conf/locale/ar/__init__.py
django/conf/locale/ar/formats.py
django/conf/locale/ar/LC_MESSAGES/django.mo
django/conf/locale/ar/LC_MESSAGES/django.po
django/conf/locale/ast/LC_MESSAGES/django.mo
django/conf/locale/ast/LC_MESSAGES/django.po
django/conf/locale/az/__init__.py
django/conf/locale/az/formats.py
django/conf/locale/az/LC_MESSAGES/django.mo
django/conf/locale/az/LC_MESSAGES/django.po
django/conf/locale/be/LC_MESSAGES/django.mo
django/conf/locale/be/LC_MESSAGES/django.po
django/conf/locale/bg/__init__.py
django/conf/locale/bg/formats.py
django/conf/locale/bg/LC_MESSAGES/django.mo
django/conf/locale/bg/LC_MESSAGES/django.po
django/conf/locale/bn/__init__.py
django/conf/locale/bn/formats.py
django/conf/locale/bn/LC_MESSAGES/django.mo
django/conf/locale/bn/LC_MESSAGES/django.po
django/conf/locale/br/LC_MESSAGES/django.mo
django/conf/locale/br/LC_MESSAGES/django.po
django/conf/locale/bs/__init__.py
django/conf/locale/bs/formats.py
django/conf/locale/bs/LC_MESSAGES/django.mo
django/conf/locale/bs/LC_MESSAGES/django.po
django/conf/locale/ca/__init__.py
django/conf/locale/ca/formats.py
django/conf/locale/ca/LC_MESSAGES/django.mo
django/conf/locale/ca/LC_MESSAGES/django.po
django/conf/locale/cs/__init__.py
django/conf/locale/cs/formats.py
django/conf/locale/cs/LC_MESSAGES/django.mo
django/conf/locale/cs/LC_MESSAGES/django.po
django/conf/locale/cy/__init__.py
django/conf/locale/cy/formats.py
django/conf/locale/cy/LC_MESSAGES/django.mo
django/conf/locale/cy/LC_MESSAGES/django.po
django/conf/locale/da/__init__.py
django/conf/locale/da/formats.py
django/conf/locale/da/LC_MESSAGES/django.mo
django/conf/locale/da/LC_MESSAGES/django.po
django/conf/locale/de/__init__.py
django/conf/locale/de/formats.py
django/conf/locale/de/LC_MESSAGES/django.mo
django/conf/locale/de/LC_MESSAGES/django.po
django/conf/locale/de_CH/__init__.py
django/conf/locale/de_CH/formats.py
django/conf/locale/dsb/LC_MESSAGES/django.mo
django/conf/locale/dsb/LC_MESSAGES/django.po
django/conf/locale/el/__init__.py
django/conf/locale/el/formats.py
django/conf/locale/el/LC_MESSAGES/django.mo
django/conf/locale/el/LC_MESSAGES/django.po
django/conf/locale/en/__init__.py
django/conf/locale/en/formats.py
django/conf/locale/en/LC_MESSAGES/django.mo
django/conf/locale/en/LC_MESSAGES/django.po
django/conf/locale/en_AU/__init__.py
django/conf/locale/en_AU/formats.py
django/conf/locale/en_AU/LC_MESSAGES/django.mo
django/conf/locale/en_AU/LC_MESSAGES/django.po
django/conf/locale/en_GB/__init__.py
django/conf/locale/en_GB/formats.py
django/conf/locale/en_GB/LC_MESSAGES/django.mo
django/conf/locale/en_GB/LC_MESSAGES/django.po
django/conf/locale/eo/__init__.py
django/conf/locale/eo/formats.py
django/conf/locale/eo/LC_MESSAGES/django.mo
django/conf/locale/eo/LC_MESSAGES/django.po
django/conf/locale/es/__init__.py
django/conf/locale/es/formats.py
django/conf/locale/es/LC_MESSAGES/django.mo
django/conf/locale/es/LC_MESSAGES/django.po
django/conf/locale/es_AR/__init__.py
django/conf/locale/es_AR/formats.py
django/conf/locale/es_AR/LC_MESSAGES/django.mo
django/conf/locale/es_AR/LC_MESSAGES/django.po
django/conf/locale/es_CO/__init__.py
django/conf/locale/es_CO/formats.py
django/conf/locale/es_CO/LC_MESSAGES/django.mo
django/conf/locale/es_CO/LC_MESSAGES/django.po
django/conf/locale/es_MX/__init__.py
django/conf/locale/es_MX/formats.py
django/conf/locale/es_MX/LC_MESSAGES/django.mo
django/conf/locale/es_MX/LC_MESSAGES/django.po
django/conf/locale/es_NI/__init__.py
django/conf/locale/es_NI/formats.py
django/conf/locale/es_PR/__init__.py
django/conf/locale/es_PR/formats.py
django/conf/locale/es_VE/LC_MESSAGES/django.mo
django/conf/locale/es_VE/LC_MESSAGES/django.po
django/conf/locale/et/__init__.py
django/conf/locale/et/formats.py
django/conf/locale/et/LC_MESSAGES/django.mo
django/conf/locale/et/LC_MESSAGES/django.po
django/conf/locale/eu/__init__.py
django/conf/locale/eu/formats.py
django/conf/locale/eu/LC_MESSAGES/django.mo
django/conf/locale/eu/LC_MESSAGES/django.po
django/conf/locale/fa/__init__.py
django/conf/locale/fa/formats.py
django/conf/locale/fa/LC_MESSAGES/django.mo
django/conf/locale/fa/LC_MESSAGES/django.po
django/conf/locale/fi/__init__.py
django/conf/locale/fi/formats.py
django/conf/locale/fi/LC_MESSAGES/django.mo
django/conf/locale/fi/LC_MESSAGES/django.po
django/conf/locale/fr/__init__.py
django/conf/locale/fr/formats.py
django/conf/locale/fr/LC_MESSAGES/django.mo
django/conf/locale/fr/LC_MESSAGES/django.po
django/conf/locale/fy/__init__.py
django/conf/locale/fy/formats.py
django/conf/locale/fy/LC_MESSAGES/django.mo
django/conf/locale/fy/LC_MESSAGES/django.po
django/conf/locale/ga/__init__.py
django/conf/locale/ga/formats.py
django/conf/locale/ga/LC_MESSAGES/django.mo
django/conf/locale/ga/LC_MESSAGES/django.po
django/conf/locale/gd/__init__.py
django/conf/locale/gd/formats.py
django/conf/locale/gd/LC_MESSAGES/django.mo
django/conf/locale/gd/LC_MESSAGES/django.po
django/conf/locale/gl/__init__.py
django/conf/locale/gl/formats.py
django/conf/locale/gl/LC_MESSAGES/django.mo
django/conf/locale/gl/LC_MESSAGES/django.po
django/conf/locale/he/__init__.py
django/conf/locale/he/formats.py
django/conf/locale/he/LC_MESSAGES/django.mo
django/conf/locale/he/LC_MESSAGES/django.po
django/conf/locale/hi/__init__.py
django/conf/locale/hi/formats.py
django/conf/locale/hi/LC_MESSAGES/django.mo
django/conf/locale/hi/LC_MESSAGES/django.po
django/conf/locale/hr/__init__.py
django/conf/locale/hr/formats.py
django/conf/locale/hr/LC_MESSAGES/django.mo
django/conf/locale/hr/LC_MESSAGES/django.po
django/conf/locale/hsb/LC_MESSAGES/django.mo
django/conf/locale/hsb/LC_MESSAGES/django.po
django/conf/locale/hu/__init__.py
django/conf/locale/hu/formats.py
django/conf/locale/hu/LC_MESSAGES/django.mo
django/conf/locale/hu/LC_MESSAGES/django.po
django/conf/locale/ia/LC_MESSAGES/django.mo
django/conf/locale/ia/LC_MESSAGES/django.po
django/conf/locale/id/__init__.py
django/conf/locale/id/formats.py
django/conf/locale/id/LC_MESSAGES/django.mo
django/conf/locale/id/LC_MESSAGES/django.po
django/conf/locale/io/LC_MESSAGES/django.mo
django/conf/locale/io/LC_MESSAGES/django.po
django/conf/locale/is/__init__.py
django/conf/locale/is/formats.py
django/conf/locale/is/LC_MESSAGES/django.mo
django/conf/locale/is/LC_MESSAGES/django.po
django/conf/locale/it/__init__.py
django/conf/locale/it/formats.py
django/conf/locale/it/LC_MESSAGES/django.mo
django/conf/locale/it/LC_MESSAGES/django.po
django/conf/locale/ja/__init__.py
django/conf/locale/ja/formats.py
django/conf/locale/ja/LC_MESSAGES/django.mo
django/conf/locale/ja/LC_MESSAGES/django.po
django/conf/locale/ka/__init__.py
django/conf/locale/ka/formats.py
django/conf/locale/ka/LC_MESSAGES/django.mo
django/conf/locale/ka/LC_MESSAGES/django.po
django/conf/locale/kk/LC_MESSAGES/django.mo
django/conf/locale/kk/LC_MESSAGES/django.po
django/conf/locale/km/__init__.py
django/conf/locale/km/formats.py
django/conf/locale/km/LC_MESSAGES/django.mo
django/conf/locale/km/LC_MESSAGES/django.po
django/conf/locale/kn/__init__.py
django/conf/locale/kn/formats.py
django/conf/locale/kn/LC_MESSAGES/django.mo
django/conf/locale/kn/LC_MESSAGES/django.po
django/conf/locale/ko/__init__.py
django/conf/locale/ko/formats.py
django/conf/locale/ko/LC_MESSAGES/django.mo
django/conf/locale/ko/LC_MESSAGES/django.po
django/conf/locale/lb/LC_MESSAGES/django.mo
django/conf/locale/lb/LC_MESSAGES/django.po
django/conf/locale/lt/__init__.py
django/conf/locale/lt/formats.py
django/conf/locale/lt/LC_MESSAGES/django.mo
django/conf/locale/lt/LC_MESSAGES/django.po
django/conf/locale/lv/__init__.py
django/conf/locale/lv/formats.py
django/conf/locale/lv/LC_MESSAGES/django.mo
django/conf/locale/lv/LC_MESSAGES/django.po
django/conf/locale/mk/__init__.py
django/conf/locale/mk/formats.py
django/conf/locale/mk/LC_MESSAGES/django.mo
django/conf/locale/mk/LC_MESSAGES/django.po
django/conf/locale/ml/__init__.py
django/conf/locale/ml/formats.py
django/conf/locale/ml/LC_MESSAGES/django.mo
django/conf/locale/ml/LC_MESSAGES/django.po
django/conf/locale/mn/__init__.py
django/conf/locale/mn/formats.py
django/conf/locale/mn/LC_MESSAGES/django.mo
django/conf/locale/mn/LC_MESSAGES/django.po
django/conf/locale/mr/LC_MESSAGES/django.mo
django/conf/locale/mr/LC_MESSAGES/django.po
django/conf/locale/my/LC_MESSAGES/django.mo
django/conf/locale/my/LC_MESSAGES/django.po
django/conf/locale/nb/__init__.py
django/conf/locale/nb/formats.py
django/conf/locale/nb/LC_MESSAGES/django.mo
django/conf/locale/nb/LC_MESSAGES/django.po
django/conf/locale/ne/LC_MESSAGES/django.mo
django/conf/locale/ne/LC_MESSAGES/django.po
django/conf/locale/nl/__init__.py
django/conf/locale/nl/formats.py
django/conf/locale/nl/LC_MESSAGES/django.mo
django/conf/locale/nl/LC_MESSAGES/django.po
django/conf/locale/nn/__init__.py
django/conf/locale/nn/formats.py
django/conf/locale/nn/LC_MESSAGES/django.mo
django/conf/locale/nn/LC_MESSAGES/django.po
django/conf/locale/os/LC_MESSAGES/django.mo
django/conf/locale/os/LC_MESSAGES/django.po
django/conf/locale/pa/LC_MESSAGES/django.mo
django/conf/locale/pa/LC_MESSAGES/django.po
django/conf/locale/pl/__init__.py
django/conf/locale/pl/formats.py
django/conf/locale/pl/LC_MESSAGES/django.mo
django/conf/locale/pl/LC_MESSAGES/django.po
django/conf/locale/pt/__init__.py
django/conf/locale/pt/formats.py
django/conf/locale/pt/LC_MESSAGES/django.mo
django/conf/locale/pt/LC_MESSAGES/django.po
django/conf/locale/pt_BR/__init__.py
django/conf/locale/pt_BR/formats.py
django/conf/locale/pt_BR/LC_MESSAGES/django.mo
django/conf/locale/pt_BR/LC_MESSAGES/django.po
django/conf/locale/ro/__init__.py
django/conf/locale/ro/formats.py
django/conf/locale/ro/LC_MESSAGES/django.mo
django/conf/locale/ro/LC_MESSAGES/django.po
django/conf/locale/ru/__init__.py
django/conf/locale/ru/formats.py
django/conf/locale/ru/LC_MESSAGES/django.mo
django/conf/locale/ru/LC_MESSAGES/django.po
django/conf/locale/sk/__init__.py
django/conf/locale/sk/formats.py
django/conf/locale/sk/LC_MESSAGES/django.mo
django/conf/locale/sk/LC_MESSAGES/django.po
django/conf/locale/sl/__init__.py
django/conf/locale/sl/formats.py
django/conf/locale/sl/LC_MESSAGES/django.mo
django/conf/locale/sl/LC_MESSAGES/django.po
django/conf/locale/sq/__init__.py
django/conf/locale/sq/formats.py
django/conf/locale/sq/LC_MESSAGES/django.mo
django/conf/locale/sq/LC_MESSAGES/django.po
django/conf/locale/sr/__init__.py
django/conf/locale/sr/formats.py
django/conf/locale/sr/LC_MESSAGES/django.mo
django/conf/locale/sr/LC_MESSAGES/django.po
django/conf/locale/sr_Latn/__init__.py
django/conf/locale/sr_Latn/formats.py
django/conf/locale/sr_Latn/LC_MESSAGES/django.mo
django/conf/locale/sr_Latn/LC_MESSAGES/django.po
django/conf/locale/sv/__init__.py
django/conf/locale/sv/formats.py
django/conf/locale/sv/LC_MESSAGES/django.mo
django/conf/locale/sv/LC_MESSAGES/django.po
django/conf/locale/sw/LC_MESSAGES/django.mo
django/conf/locale/sw/LC_MESSAGES/django.po
django/conf/locale/ta/__init__.py
django/conf/locale/ta/formats.py
django/conf/locale/ta/LC_MESSAGES/django.mo
django/conf/locale/ta/LC_MESSAGES/django.po
django/conf/locale/te/__init__.py
django/conf/locale/te/formats.py
django/conf/locale/te/LC_MESSAGES/django.mo
django/conf/locale/te/LC_MESSAGES/django.po
django/conf/locale/th/__init__.py
django/conf/locale/th/formats.py
django/conf/locale/th/LC_MESSAGES/django.mo
django/conf/locale/th/LC_MESSAGES/django.po
django/conf/locale/tr/__init__.py
django/conf/locale/tr/formats.py
django/conf/locale/tr/LC_MESSAGES/django.mo
django/conf/locale/tr/LC_MESSAGES/django.po
django/conf/locale/tt/LC_MESSAGES/django.mo
django/conf/locale/tt/LC_MESSAGES/django.po
django/conf/locale/udm/LC_MESSAGES/django.mo
django/conf/locale/udm/LC_MESSAGES/django.po
django/conf/locale/uk/__init__.py
django/conf/locale/uk/formats.py
django/conf/locale/uk/LC_MESSAGES/django.mo
django/conf/locale/uk/LC_MESSAGES/django.po
django/conf/locale/ur/LC_MESSAGES/django.mo
django/conf/locale/ur/LC_MESSAGES/django.po
django/conf/locale/vi/__init__.py
django/conf/locale/vi/formats.py
django/conf/locale/vi/LC_MESSAGES/django.mo
django/conf/locale/vi/LC_MESSAGES/django.po
django/conf/locale/zh_Hans/__init__.py
django/conf/locale/zh_Hans/formats.py
django/conf/locale/zh_Hans/LC_MESSAGES/django.mo
django/conf/locale/zh_Hans/LC_MESSAGES/django.po
django/conf/locale/zh_Hant/__init__.py
django/conf/locale/zh_Hant/formats.py
django/conf/locale/zh_Hant/LC_MESSAGES/django.mo
django/conf/locale/zh_Hant/LC_MESSAGES/django.po
django/conf/project_template/manage.py-tpl
django/conf/project_template/project_name/__init__.py-tpl
django/conf/project_template/project_name/settings.py-tpl
django/conf/project_template/project_name/urls.py-tpl
django/conf/project_template/project_name/wsgi.py-tpl
django/conf/urls/__init__.py
django/conf/urls/i18n.py
django/conf/urls/static.py
django/contrib/__init__.py
django/contrib/admin/__init__.py
django/contrib/admin/actions.py
django/contrib/admin/apps.py
django/contrib/admin/checks.py
django/contrib/admin/decorators.py
django/contrib/admin/exceptions.py
django/contrib/admin/filters.py
django/contrib/admin/forms.py
django/contrib/admin/helpers.py
django/contrib/admin/models.py
django/contrib/admin/options.py
django/contrib/admin/sites.py
django/contrib/admin/tests.py
django/contrib/admin/utils.py
django/contrib/admin/widgets.py
django/contrib/admin/locale/af/LC_MESSAGES/django.mo
django/contrib/admin/locale/af/LC_MESSAGES/django.po
django/contrib/admin/locale/af/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/af/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/am/LC_MESSAGES/django.mo
django/contrib/admin/locale/am/LC_MESSAGES/django.po
django/contrib/admin/locale/ar/LC_MESSAGES/django.mo
django/contrib/admin/locale/ar/LC_MESSAGES/django.po
django/contrib/admin/locale/ar/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/ar/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/ast/LC_MESSAGES/django.mo
django/contrib/admin/locale/ast/LC_MESSAGES/django.po
django/contrib/admin/locale/ast/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/ast/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/az/LC_MESSAGES/django.mo
django/contrib/admin/locale/az/LC_MESSAGES/django.po
django/contrib/admin/locale/az/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/az/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/be/LC_MESSAGES/django.mo
django/contrib/admin/locale/be/LC_MESSAGES/django.po
django/contrib/admin/locale/be/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/be/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/bg/LC_MESSAGES/django.mo
django/contrib/admin/locale/bg/LC_MESSAGES/django.po
django/contrib/admin/locale/bg/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/bg/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/bn/LC_MESSAGES/django.mo
django/contrib/admin/locale/bn/LC_MESSAGES/django.po
django/contrib/admin/locale/bn/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/bn/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/br/LC_MESSAGES/django.mo
django/contrib/admin/locale/br/LC_MESSAGES/django.po
django/contrib/admin/locale/br/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/br/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/bs/LC_MESSAGES/django.mo
django/contrib/admin/locale/bs/LC_MESSAGES/django.po
django/contrib/admin/locale/bs/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/bs/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/ca/LC_MESSAGES/django.mo
django/contrib/admin/locale/ca/LC_MESSAGES/django.po
django/contrib/admin/locale/ca/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/ca/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/cs/LC_MESSAGES/django.mo
django/contrib/admin/locale/cs/LC_MESSAGES/django.po
django/contrib/admin/locale/cs/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/cs/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/cy/LC_MESSAGES/django.mo
django/contrib/admin/locale/cy/LC_MESSAGES/django.po
django/contrib/admin/locale/cy/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/cy/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/da/LC_MESSAGES/django.mo
django/contrib/admin/locale/da/LC_MESSAGES/django.po
django/contrib/admin/locale/da/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/da/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/de/LC_MESSAGES/django.mo
django/contrib/admin/locale/de/LC_MESSAGES/django.po
django/contrib/admin/locale/de/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/de/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/dsb/LC_MESSAGES/django.mo
django/contrib/admin/locale/dsb/LC_MESSAGES/django.po
django/contrib/admin/locale/dsb/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/dsb/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/el/LC_MESSAGES/django.mo
django/contrib/admin/locale/el/LC_MESSAGES/django.po
django/contrib/admin/locale/el/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/el/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/en/LC_MESSAGES/django.mo
django/contrib/admin/locale/en/LC_MESSAGES/django.po
django/contrib/admin/locale/en/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/en/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/en_AU/LC_MESSAGES/django.mo
django/contrib/admin/locale/en_AU/LC_MESSAGES/django.po
django/contrib/admin/locale/en_AU/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/en_AU/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/en_GB/LC_MESSAGES/django.mo
django/contrib/admin/locale/en_GB/LC_MESSAGES/django.po
django/contrib/admin/locale/en_GB/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/en_GB/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/eo/LC_MESSAGES/django.mo
django/contrib/admin/locale/eo/LC_MESSAGES/django.po
django/contrib/admin/locale/eo/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/eo/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/es/LC_MESSAGES/django.mo
django/contrib/admin/locale/es/LC_MESSAGES/django.po
django/contrib/admin/locale/es/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/es/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/es_AR/LC_MESSAGES/django.mo
django/contrib/admin/locale/es_AR/LC_MESSAGES/django.po
django/contrib/admin/locale/es_AR/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/es_AR/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/es_CO/LC_MESSAGES/django.mo
django/contrib/admin/locale/es_CO/LC_MESSAGES/django.po
django/contrib/admin/locale/es_CO/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/es_CO/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/es_MX/LC_MESSAGES/django.mo
django/contrib/admin/locale/es_MX/LC_MESSAGES/django.po
django/contrib/admin/locale/es_MX/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/es_MX/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/es_VE/LC_MESSAGES/django.mo
django/contrib/admin/locale/es_VE/LC_MESSAGES/django.po
django/contrib/admin/locale/es_VE/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/es_VE/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/et/LC_MESSAGES/django.mo
django/contrib/admin/locale/et/LC_MESSAGES/django.po
django/contrib/admin/locale/et/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/et/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/eu/LC_MESSAGES/django.mo
django/contrib/admin/locale/eu/LC_MESSAGES/django.po
django/contrib/admin/locale/eu/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/eu/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/fa/LC_MESSAGES/django.mo
django/contrib/admin/locale/fa/LC_MESSAGES/django.po
django/contrib/admin/locale/fa/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/fa/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/fi/LC_MESSAGES/django.mo
django/contrib/admin/locale/fi/LC_MESSAGES/django.po
django/contrib/admin/locale/fi/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/fi/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/fr/LC_MESSAGES/django.mo
django/contrib/admin/locale/fr/LC_MESSAGES/django.po
django/contrib/admin/locale/fr/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/fr/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/fy/LC_MESSAGES/django.mo
django/contrib/admin/locale/fy/LC_MESSAGES/django.po
django/contrib/admin/locale/fy/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/fy/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/ga/LC_MESSAGES/django.mo
django/contrib/admin/locale/ga/LC_MESSAGES/django.po
django/contrib/admin/locale/ga/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/ga/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/gd/LC_MESSAGES/django.mo
django/contrib/admin/locale/gd/LC_MESSAGES/django.po
django/contrib/admin/locale/gd/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/gd/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/gl/LC_MESSAGES/django.mo
django/contrib/admin/locale/gl/LC_MESSAGES/django.po
django/contrib/admin/locale/gl/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/gl/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/he/LC_MESSAGES/django.mo
django/contrib/admin/locale/he/LC_MESSAGES/django.po
django/contrib/admin/locale/he/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/he/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/hi/LC_MESSAGES/django.mo
django/contrib/admin/locale/hi/LC_MESSAGES/django.po
django/contrib/admin/locale/hi/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/hi/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/hr/LC_MESSAGES/django.mo
django/contrib/admin/locale/hr/LC_MESSAGES/django.po
django/contrib/admin/locale/hr/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/hr/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/hsb/LC_MESSAGES/django.mo
django/contrib/admin/locale/hsb/LC_MESSAGES/django.po
django/contrib/admin/locale/hsb/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/hsb/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/hu/LC_MESSAGES/django.mo
django/contrib/admin/locale/hu/LC_MESSAGES/django.po
django/contrib/admin/locale/hu/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/hu/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/ia/LC_MESSAGES/django.mo
django/contrib/admin/locale/ia/LC_MESSAGES/django.po
django/contrib/admin/locale/ia/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/ia/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/id/LC_MESSAGES/django.mo
django/contrib/admin/locale/id/LC_MESSAGES/django.po
django/contrib/admin/locale/id/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/id/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/io/LC_MESSAGES/django.mo
django/contrib/admin/locale/io/LC_MESSAGES/django.po
django/contrib/admin/locale/io/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/io/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/is/LC_MESSAGES/django.mo
django/contrib/admin/locale/is/LC_MESSAGES/django.po
django/contrib/admin/locale/is/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/is/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/it/LC_MESSAGES/django.mo
django/contrib/admin/locale/it/LC_MESSAGES/django.po
django/contrib/admin/locale/it/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/it/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/ja/LC_MESSAGES/django.mo
django/contrib/admin/locale/ja/LC_MESSAGES/django.po
django/contrib/admin/locale/ja/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/ja/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/ka/LC_MESSAGES/django.mo
django/contrib/admin/locale/ka/LC_MESSAGES/django.po
django/contrib/admin/locale/ka/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/ka/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/kk/LC_MESSAGES/django.mo
django/contrib/admin/locale/kk/LC_MESSAGES/django.po
django/contrib/admin/locale/kk/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/kk/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/km/LC_MESSAGES/django.mo
django/contrib/admin/locale/km/LC_MESSAGES/django.po
django/contrib/admin/locale/km/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/km/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/kn/LC_MESSAGES/django.mo
django/contrib/admin/locale/kn/LC_MESSAGES/django.po
django/contrib/admin/locale/kn/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/kn/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/ko/LC_MESSAGES/django.mo
django/contrib/admin/locale/ko/LC_MESSAGES/django.po
django/contrib/admin/locale/ko/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/ko/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/lb/LC_MESSAGES/django.mo
django/contrib/admin/locale/lb/LC_MESSAGES/django.po
django/contrib/admin/locale/lb/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/lb/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/lt/LC_MESSAGES/django.mo
django/contrib/admin/locale/lt/LC_MESSAGES/django.po
django/contrib/admin/locale/lt/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/lt/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/lv/LC_MESSAGES/django.mo
django/contrib/admin/locale/lv/LC_MESSAGES/django.po
django/contrib/admin/locale/lv/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/lv/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/mk/LC_MESSAGES/django.mo
django/contrib/admin/locale/mk/LC_MESSAGES/django.po
django/contrib/admin/locale/mk/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/mk/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/ml/LC_MESSAGES/django.mo
django/contrib/admin/locale/ml/LC_MESSAGES/django.po
django/contrib/admin/locale/ml/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/ml/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/mn/LC_MESSAGES/django.mo
django/contrib/admin/locale/mn/LC_MESSAGES/django.po
django/contrib/admin/locale/mn/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/mn/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/mr/LC_MESSAGES/django.mo
django/contrib/admin/locale/mr/LC_MESSAGES/django.po
django/contrib/admin/locale/mr/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/mr/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/my/LC_MESSAGES/django.mo
django/contrib/admin/locale/my/LC_MESSAGES/django.po
django/contrib/admin/locale/my/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/my/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/nb/LC_MESSAGES/django.mo
django/contrib/admin/locale/nb/LC_MESSAGES/django.po
django/contrib/admin/locale/nb/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/nb/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/ne/LC_MESSAGES/django.mo
django/contrib/admin/locale/ne/LC_MESSAGES/django.po
django/contrib/admin/locale/ne/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/ne/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/nl/LC_MESSAGES/django.mo
django/contrib/admin/locale/nl/LC_MESSAGES/django.po
django/contrib/admin/locale/nl/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/nl/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/nn/LC_MESSAGES/django.mo
django/contrib/admin/locale/nn/LC_MESSAGES/django.po
django/contrib/admin/locale/nn/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/nn/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/os/LC_MESSAGES/django.mo
django/contrib/admin/locale/os/LC_MESSAGES/django.po
django/contrib/admin/locale/os/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/os/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/pa/LC_MESSAGES/django.mo
django/contrib/admin/locale/pa/LC_MESSAGES/django.po
django/contrib/admin/locale/pa/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/pa/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/pl/LC_MESSAGES/django.mo
django/contrib/admin/locale/pl/LC_MESSAGES/django.po
django/contrib/admin/locale/pl/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/pl/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/pt/LC_MESSAGES/django.mo
django/contrib/admin/locale/pt/LC_MESSAGES/django.po
django/contrib/admin/locale/pt/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/pt/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/pt_BR/LC_MESSAGES/django.mo
django/contrib/admin/locale/pt_BR/LC_MESSAGES/django.po
django/contrib/admin/locale/pt_BR/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/pt_BR/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/ro/LC_MESSAGES/django.mo
django/contrib/admin/locale/ro/LC_MESSAGES/django.po
django/contrib/admin/locale/ro/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/ro/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/ru/LC_MESSAGES/django.mo
django/contrib/admin/locale/ru/LC_MESSAGES/django.po
django/contrib/admin/locale/ru/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/ru/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/sk/LC_MESSAGES/django.mo
django/contrib/admin/locale/sk/LC_MESSAGES/django.po
django/contrib/admin/locale/sk/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/sk/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/sl/LC_MESSAGES/django.mo
django/contrib/admin/locale/sl/LC_MESSAGES/django.po
django/contrib/admin/locale/sl/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/sl/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/sq/LC_MESSAGES/django.mo
django/contrib/admin/locale/sq/LC_MESSAGES/django.po
django/contrib/admin/locale/sq/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/sq/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/sr/LC_MESSAGES/django.mo
django/contrib/admin/locale/sr/LC_MESSAGES/django.po
django/contrib/admin/locale/sr/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/sr/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/sr_Latn/LC_MESSAGES/django.mo
django/contrib/admin/locale/sr_Latn/LC_MESSAGES/django.po
django/contrib/admin/locale/sr_Latn/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/sr_Latn/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/sv/LC_MESSAGES/django.mo
django/contrib/admin/locale/sv/LC_MESSAGES/django.po
django/contrib/admin/locale/sv/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/sv/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/sw/LC_MESSAGES/django.mo
django/contrib/admin/locale/sw/LC_MESSAGES/django.po
django/contrib/admin/locale/sw/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/sw/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/ta/LC_MESSAGES/django.mo
django/contrib/admin/locale/ta/LC_MESSAGES/django.po
django/contrib/admin/locale/ta/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/ta/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/te/LC_MESSAGES/django.mo
django/contrib/admin/locale/te/LC_MESSAGES/django.po
django/contrib/admin/locale/te/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/te/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/th/LC_MESSAGES/django.mo
django/contrib/admin/locale/th/LC_MESSAGES/django.po
django/contrib/admin/locale/th/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/th/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/tr/LC_MESSAGES/django.mo
django/contrib/admin/locale/tr/LC_MESSAGES/django.po
django/contrib/admin/locale/tr/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/tr/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/tt/LC_MESSAGES/django.mo
django/contrib/admin/locale/tt/LC_MESSAGES/django.po
django/contrib/admin/locale/tt/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/tt/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/udm/LC_MESSAGES/django.mo
django/contrib/admin/locale/udm/LC_MESSAGES/django.po
django/contrib/admin/locale/udm/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/udm/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/uk/LC_MESSAGES/django.mo
django/contrib/admin/locale/uk/LC_MESSAGES/django.po
django/contrib/admin/locale/uk/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/uk/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/ur/LC_MESSAGES/django.mo
django/contrib/admin/locale/ur/LC_MESSAGES/django.po
django/contrib/admin/locale/ur/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/ur/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/vi/LC_MESSAGES/django.mo
django/contrib/admin/locale/vi/LC_MESSAGES/django.po
django/contrib/admin/locale/vi/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/vi/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/zh_Hans/LC_MESSAGES/django.mo
django/contrib/admin/locale/zh_Hans/LC_MESSAGES/django.po
django/contrib/admin/locale/zh_Hans/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/zh_Hans/LC_MESSAGES/djangojs.po
django/contrib/admin/locale/zh_Hant/LC_MESSAGES/django.mo
django/contrib/admin/locale/zh_Hant/LC_MESSAGES/django.po
django/contrib/admin/locale/zh_Hant/LC_MESSAGES/djangojs.mo
django/contrib/admin/locale/zh_Hant/LC_MESSAGES/djangojs.po
django/contrib/admin/migrations/0001_initial.py
django/contrib/admin/migrations/0002_logentry_remove_auto_add.py
django/contrib/admin/migrations/__init__.py
django/contrib/admin/static/admin/css/base.css
django/contrib/admin/static/admin/css/changelists.css
django/contrib/admin/static/admin/css/dashboard.css
django/contrib/admin/static/admin/css/fonts.css
django/contrib/admin/static/admin/css/forms.css
django/contrib/admin/static/admin/css/login.css
django/contrib/admin/static/admin/css/rtl.css
django/contrib/admin/static/admin/css/widgets.css
django/contrib/admin/static/admin/fonts/LICENSE.txt
django/contrib/admin/static/admin/fonts/README.txt
django/contrib/admin/static/admin/fonts/Roboto-Bold-webfont.woff
django/contrib/admin/static/admin/fonts/Roboto-Light-webfont.woff
django/contrib/admin/static/admin/fonts/Roboto-Regular-webfont.woff
django/contrib/admin/static/admin/img/LICENSE
django/contrib/admin/static/admin/img/README.txt
django/contrib/admin/static/admin/img/calendar-icons.svg
django/contrib/admin/static/admin/img/icon-addlink.svg
django/contrib/admin/static/admin/img/icon-alert.svg
django/contrib/admin/static/admin/img/icon-calendar.svg
django/contrib/admin/static/admin/img/icon-changelink.svg
django/contrib/admin/static/admin/img/icon-clock.svg
django/contrib/admin/static/admin/img/icon-deletelink.svg
django/contrib/admin/static/admin/img/icon-no.svg
django/contrib/admin/static/admin/img/icon-unknown-alt.svg
django/contrib/admin/static/admin/img/icon-unknown.svg
django/contrib/admin/static/admin/img/icon-yes.svg
django/contrib/admin/static/admin/img/inline-delete.svg
django/contrib/admin/static/admin/img/search.svg
django/contrib/admin/static/admin/img/selector-icons.svg
django/contrib/admin/static/admin/img/sorting-icons.svg
django/contrib/admin/static/admin/img/tooltag-add.svg
django/contrib/admin/static/admin/img/tooltag-arrowright.svg
django/contrib/admin/static/admin/img/gis/move_vertex_off.svg
django/contrib/admin/static/admin/img/gis/move_vertex_on.svg
django/contrib/admin/static/admin/js/SelectBox.js
django/contrib/admin/static/admin/js/SelectFilter2.js
django/contrib/admin/static/admin/js/actions.js
django/contrib/admin/static/admin/js/actions.min.js
django/contrib/admin/static/admin/js/calendar.js
django/contrib/admin/static/admin/js/cancel.js
django/contrib/admin/static/admin/js/change_form.js
django/contrib/admin/static/admin/js/collapse.js
django/contrib/admin/static/admin/js/collapse.min.js
django/contrib/admin/static/admin/js/core.js
django/contrib/admin/static/admin/js/inlines.js
django/contrib/admin/static/admin/js/inlines.min.js
django/contrib/admin/static/admin/js/jquery.init.js
django/contrib/admin/static/admin/js/popup_response.js
django/contrib/admin/static/admin/js/prepopulate.js
django/contrib/admin/static/admin/js/prepopulate.min.js
django/contrib/admin/static/admin/js/prepopulate_init.js
django/contrib/admin/static/admin/js/timeparse.js
django/contrib/admin/static/admin/js/urlify.js
django/contrib/admin/static/admin/js/admin/DateTimeShortcuts.js
django/contrib/admin/static/admin/js/admin/RelatedObjectLookups.js
django/contrib/admin/static/admin/js/vendor/jquery/LICENSE-JQUERY.txt
django/contrib/admin/static/admin/js/vendor/jquery/jquery.js
django/contrib/admin/static/admin/js/vendor/jquery/jquery.min.js
django/contrib/admin/static/admin/js/vendor/xregexp/LICENSE-XREGEXP.txt
django/contrib/admin/static/admin/js/vendor/xregexp/xregexp.js
django/contrib/admin/static/admin/js/vendor/xregexp/xregexp.min.js
django/contrib/admin/templates/admin/404.html
django/contrib/admin/templates/admin/500.html
django/contrib/admin/templates/admin/actions.html
django/contrib/admin/templates/admin/app_index.html
django/contrib/admin/templates/admin/base.html
django/contrib/admin/templates/admin/base_site.html
django/contrib/admin/templates/admin/change_form.html
django/contrib/admin/templates/admin/change_list.html
django/contrib/admin/templates/admin/change_list_results.html
django/contrib/admin/templates/admin/date_hierarchy.html
django/contrib/admin/templates/admin/delete_confirmation.html
django/contrib/admin/templates/admin/delete_selected_confirmation.html
django/contrib/admin/templates/admin/filter.html
django/contrib/admin/templates/admin/index.html
django/contrib/admin/templates/admin/invalid_setup.html
django/contrib/admin/templates/admin/login.html
django/contrib/admin/templates/admin/object_history.html
django/contrib/admin/templates/admin/pagination.html
django/contrib/admin/templates/admin/popup_response.html
django/contrib/admin/templates/admin/prepopulated_fields_js.html
django/contrib/admin/templates/admin/related_widget_wrapper.html
django/contrib/admin/templates/admin/search_form.html
django/contrib/admin/templates/admin/submit_line.html
django/contrib/admin/templates/admin/auth/user/add_form.html
django/contrib/admin/templates/admin/auth/user/change_password.html
django/contrib/admin/templates/admin/edit_inline/stacked.html
django/contrib/admin/templates/admin/edit_inline/tabular.html
django/contrib/admin/templates/admin/includes/fieldset.html
django/contrib/admin/templates/admin/includes/object_delete_summary.html
django/contrib/admin/templates/admin/widgets/clearable_file_input.html
django/contrib/admin/templates/admin/widgets/foreign_key_raw_id.html
django/contrib/admin/templates/admin/widgets/many_to_many_raw_id.html
django/contrib/admin/templates/admin/widgets/radio.html
django/contrib/admin/templates/admin/widgets/related_widget_wrapper.html
django/contrib/admin/templates/admin/widgets/split_datetime.html
django/contrib/admin/templates/admin/widgets/url.html
django/contrib/admin/templates/registration/logged_out.html
django/contrib/admin/templates/registration/password_change_done.html
django/contrib/admin/templates/registration/password_change_form.html
django/contrib/admin/templates/registration/password_reset_complete.html
django/contrib/admin/templates/registration/password_reset_confirm.html
django/contrib/admin/templates/registration/password_reset_done.html
django/contrib/admin/templates/registration/password_reset_email.html
django/contrib/admin/templates/registration/password_reset_form.html
django/contrib/admin/templatetags/__init__.py
django/contrib/admin/templatetags/admin_list.py
django/contrib/admin/templatetags/admin_modify.py
django/contrib/admin/templatetags/admin_static.py
django/contrib/admin/templatetags/admin_urls.py
django/contrib/admin/templatetags/log.py
django/contrib/admin/views/__init__.py
django/contrib/admin/views/decorators.py
django/contrib/admin/views/main.py
django/contrib/admindocs/__init__.py
django/contrib/admindocs/apps.py
django/contrib/admindocs/middleware.py
django/contrib/admindocs/urls.py
django/contrib/admindocs/utils.py
django/contrib/admindocs/views.py
django/contrib/admindocs/locale/af/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/af/LC_MESSAGES/django.po
django/contrib/admindocs/locale/ar/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/ar/LC_MESSAGES/django.po
django/contrib/admindocs/locale/ast/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/ast/LC_MESSAGES/django.po
django/contrib/admindocs/locale/az/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/az/LC_MESSAGES/django.po
django/contrib/admindocs/locale/be/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/be/LC_MESSAGES/django.po
django/contrib/admindocs/locale/bg/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/bg/LC_MESSAGES/django.po
django/contrib/admindocs/locale/bn/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/bn/LC_MESSAGES/django.po
django/contrib/admindocs/locale/br/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/br/LC_MESSAGES/django.po
django/contrib/admindocs/locale/bs/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/bs/LC_MESSAGES/django.po
django/contrib/admindocs/locale/ca/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/ca/LC_MESSAGES/django.po
django/contrib/admindocs/locale/cs/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/cs/LC_MESSAGES/django.po
django/contrib/admindocs/locale/cy/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/cy/LC_MESSAGES/django.po
django/contrib/admindocs/locale/da/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/da/LC_MESSAGES/django.po
django/contrib/admindocs/locale/de/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/de/LC_MESSAGES/django.po
django/contrib/admindocs/locale/dsb/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/dsb/LC_MESSAGES/django.po
django/contrib/admindocs/locale/el/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/el/LC_MESSAGES/django.po
django/contrib/admindocs/locale/en/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/en/LC_MESSAGES/django.po
django/contrib/admindocs/locale/en_AU/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/en_AU/LC_MESSAGES/django.po
django/contrib/admindocs/locale/en_GB/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/en_GB/LC_MESSAGES/django.po
django/contrib/admindocs/locale/eo/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/eo/LC_MESSAGES/django.po
django/contrib/admindocs/locale/es/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/es/LC_MESSAGES/django.po
django/contrib/admindocs/locale/es_AR/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/es_AR/LC_MESSAGES/django.po
django/contrib/admindocs/locale/es_CO/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/es_CO/LC_MESSAGES/django.po
django/contrib/admindocs/locale/es_MX/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/es_MX/LC_MESSAGES/django.po
django/contrib/admindocs/locale/es_VE/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/es_VE/LC_MESSAGES/django.po
django/contrib/admindocs/locale/et/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/et/LC_MESSAGES/django.po
django/contrib/admindocs/locale/eu/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/eu/LC_MESSAGES/django.po
django/contrib/admindocs/locale/fa/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/fa/LC_MESSAGES/django.po
django/contrib/admindocs/locale/fi/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/fi/LC_MESSAGES/django.po
django/contrib/admindocs/locale/fr/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/fr/LC_MESSAGES/django.po
django/contrib/admindocs/locale/fy/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/fy/LC_MESSAGES/django.po
django/contrib/admindocs/locale/ga/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/ga/LC_MESSAGES/django.po
django/contrib/admindocs/locale/gd/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/gd/LC_MESSAGES/django.po
django/contrib/admindocs/locale/gl/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/gl/LC_MESSAGES/django.po
django/contrib/admindocs/locale/he/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/he/LC_MESSAGES/django.po
django/contrib/admindocs/locale/hi/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/hi/LC_MESSAGES/django.po
django/contrib/admindocs/locale/hr/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/hr/LC_MESSAGES/django.po
django/contrib/admindocs/locale/hsb/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/hsb/LC_MESSAGES/django.po
django/contrib/admindocs/locale/hu/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/hu/LC_MESSAGES/django.po
django/contrib/admindocs/locale/ia/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/ia/LC_MESSAGES/django.po
django/contrib/admindocs/locale/id/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/id/LC_MESSAGES/django.po
django/contrib/admindocs/locale/io/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/io/LC_MESSAGES/django.po
django/contrib/admindocs/locale/is/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/is/LC_MESSAGES/django.po
django/contrib/admindocs/locale/it/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/it/LC_MESSAGES/django.po
django/contrib/admindocs/locale/ja/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/ja/LC_MESSAGES/django.po
django/contrib/admindocs/locale/ka/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/ka/LC_MESSAGES/django.po
django/contrib/admindocs/locale/kk/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/kk/LC_MESSAGES/django.po
django/contrib/admindocs/locale/km/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/km/LC_MESSAGES/django.po
django/contrib/admindocs/locale/kn/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/kn/LC_MESSAGES/django.po
django/contrib/admindocs/locale/ko/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/ko/LC_MESSAGES/django.po
django/contrib/admindocs/locale/lb/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/lb/LC_MESSAGES/django.po
django/contrib/admindocs/locale/lt/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/lt/LC_MESSAGES/django.po
django/contrib/admindocs/locale/lv/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/lv/LC_MESSAGES/django.po
django/contrib/admindocs/locale/mk/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/mk/LC_MESSAGES/django.po
django/contrib/admindocs/locale/ml/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/ml/LC_MESSAGES/django.po
django/contrib/admindocs/locale/mn/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/mn/LC_MESSAGES/django.po
django/contrib/admindocs/locale/mr/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/mr/LC_MESSAGES/django.po
django/contrib/admindocs/locale/my/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/my/LC_MESSAGES/django.po
django/contrib/admindocs/locale/nb/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/nb/LC_MESSAGES/django.po
django/contrib/admindocs/locale/ne/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/ne/LC_MESSAGES/django.po
django/contrib/admindocs/locale/nl/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/nl/LC_MESSAGES/django.po
django/contrib/admindocs/locale/nn/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/nn/LC_MESSAGES/django.po
django/contrib/admindocs/locale/os/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/os/LC_MESSAGES/django.po
django/contrib/admindocs/locale/pa/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/pa/LC_MESSAGES/django.po
django/contrib/admindocs/locale/pl/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/pl/LC_MESSAGES/django.po
django/contrib/admindocs/locale/pt/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/pt/LC_MESSAGES/django.po
django/contrib/admindocs/locale/pt_BR/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/pt_BR/LC_MESSAGES/django.po
django/contrib/admindocs/locale/ro/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/ro/LC_MESSAGES/django.po
django/contrib/admindocs/locale/ru/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/ru/LC_MESSAGES/django.po
django/contrib/admindocs/locale/sk/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/sk/LC_MESSAGES/django.po
django/contrib/admindocs/locale/sl/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/sl/LC_MESSAGES/django.po
django/contrib/admindocs/locale/sq/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/sq/LC_MESSAGES/django.po
django/contrib/admindocs/locale/sr/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/sr/LC_MESSAGES/django.po
django/contrib/admindocs/locale/sr_Latn/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/sr_Latn/LC_MESSAGES/django.po
django/contrib/admindocs/locale/sv/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/sv/LC_MESSAGES/django.po
django/contrib/admindocs/locale/sw/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/sw/LC_MESSAGES/django.po
django/contrib/admindocs/locale/ta/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/ta/LC_MESSAGES/django.po
django/contrib/admindocs/locale/te/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/te/LC_MESSAGES/django.po
django/contrib/admindocs/locale/th/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/th/LC_MESSAGES/django.po
django/contrib/admindocs/locale/tr/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/tr/LC_MESSAGES/django.po
django/contrib/admindocs/locale/tt/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/tt/LC_MESSAGES/django.po
django/contrib/admindocs/locale/udm/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/udm/LC_MESSAGES/django.po
django/contrib/admindocs/locale/uk/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/uk/LC_MESSAGES/django.po
django/contrib/admindocs/locale/ur/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/ur/LC_MESSAGES/django.po
django/contrib/admindocs/locale/vi/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/vi/LC_MESSAGES/django.po
django/contrib/admindocs/locale/zh_Hans/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/zh_Hans/LC_MESSAGES/django.po
django/contrib/admindocs/locale/zh_Hant/LC_MESSAGES/django.mo
django/contrib/admindocs/locale/zh_Hant/LC_MESSAGES/django.po
django/contrib/admindocs/templates/admin_doc/bookmarklets.html
django/contrib/admindocs/templates/admin_doc/index.html
django/contrib/admindocs/templates/admin_doc/missing_docutils.html
django/contrib/admindocs/templates/admin_doc/model_detail.html
django/contrib/admindocs/templates/admin_doc/model_index.html
django/contrib/admindocs/templates/admin_doc/template_detail.html
django/contrib/admindocs/templates/admin_doc/template_filter_index.html
django/contrib/admindocs/templates/admin_doc/template_tag_index.html
django/contrib/admindocs/templates/admin_doc/view_detail.html
django/contrib/admindocs/templates/admin_doc/view_index.html
django/contrib/auth/__init__.py
django/contrib/auth/admin.py
django/contrib/auth/apps.py
django/contrib/auth/backends.py
django/contrib/auth/base_user.py
django/contrib/auth/checks.py
django/contrib/auth/common-passwords.txt.gz
django/contrib/auth/context_processors.py
django/contrib/auth/decorators.py
django/contrib/auth/forms.py
django/contrib/auth/hashers.py
django/contrib/auth/middleware.py
django/contrib/auth/mixins.py
django/contrib/auth/models.py
django/contrib/auth/password_validation.py
django/contrib/auth/signals.py
django/contrib/auth/tokens.py
django/contrib/auth/urls.py
django/contrib/auth/validators.py
django/contrib/auth/views.py
django/contrib/auth/handlers/__init__.py
django/contrib/auth/handlers/modwsgi.py
django/contrib/auth/locale/af/LC_MESSAGES/django.mo
django/contrib/auth/locale/af/LC_MESSAGES/django.po
django/contrib/auth/locale/ar/LC_MESSAGES/django.mo
django/contrib/auth/locale/ar/LC_MESSAGES/django.po
django/contrib/auth/locale/ast/LC_MESSAGES/django.mo
django/contrib/auth/locale/ast/LC_MESSAGES/django.po
django/contrib/auth/locale/az/LC_MESSAGES/django.mo
django/contrib/auth/locale/az/LC_MESSAGES/django.po
django/contrib/auth/locale/be/LC_MESSAGES/django.mo
django/contrib/auth/locale/be/LC_MESSAGES/django.po
django/contrib/auth/locale/bg/LC_MESSAGES/django.mo
django/contrib/auth/locale/bg/LC_MESSAGES/django.po
django/contrib/auth/locale/bn/LC_MESSAGES/django.mo
django/contrib/auth/locale/bn/LC_MESSAGES/django.po
django/contrib/auth/locale/br/LC_MESSAGES/django.mo
django/contrib/auth/locale/br/LC_MESSAGES/django.po
django/contrib/auth/locale/bs/LC_MESSAGES/django.mo
django/contrib/auth/locale/bs/LC_MESSAGES/django.po
django/contrib/auth/locale/ca/LC_MESSAGES/django.mo
django/contrib/auth/locale/ca/LC_MESSAGES/django.po
django/contrib/auth/locale/cs/LC_MESSAGES/django.mo
django/contrib/auth/locale/cs/LC_MESSAGES/django.po
django/contrib/auth/locale/cy/LC_MESSAGES/django.mo
django/contrib/auth/locale/cy/LC_MESSAGES/django.po
django/contrib/auth/locale/da/LC_MESSAGES/django.mo
django/contrib/auth/locale/da/LC_MESSAGES/django.po
django/contrib/auth/locale/de/LC_MESSAGES/django.mo
django/contrib/auth/locale/de/LC_MESSAGES/django.po
django/contrib/auth/locale/dsb/LC_MESSAGES/django.mo
django/contrib/auth/locale/dsb/LC_MESSAGES/django.po
django/contrib/auth/locale/el/LC_MESSAGES/django.mo
django/contrib/auth/locale/el/LC_MESSAGES/django.po
django/contrib/auth/locale/en/LC_MESSAGES/django.mo
django/contrib/auth/locale/en/LC_MESSAGES/django.po
django/contrib/auth/locale/en_AU/LC_MESSAGES/django.mo
django/contrib/auth/locale/en_AU/LC_MESSAGES/django.po
django/contrib/auth/locale/en_GB/LC_MESSAGES/django.mo
django/contrib/auth/locale/en_GB/LC_MESSAGES/django.po
django/contrib/auth/locale/eo/LC_MESSAGES/django.mo
django/contrib/auth/locale/eo/LC_MESSAGES/django.po
django/contrib/auth/locale/es/LC_MESSAGES/django.mo
django/contrib/auth/locale/es/LC_MESSAGES/django.po
django/contrib/auth/locale/es_AR/LC_MESSAGES/django.mo
django/contrib/auth/locale/es_AR/LC_MESSAGES/django.po
django/contrib/auth/locale/es_CO/LC_MESSAGES/django.mo
django/contrib/auth/locale/es_CO/LC_MESSAGES/django.po
django/contrib/auth/locale/es_MX/LC_MESSAGES/django.mo
django/contrib/auth/locale/es_MX/LC_MESSAGES/django.po
django/contrib/auth/locale/es_VE/LC_MESSAGES/django.mo
django/contrib/auth/locale/es_VE/LC_MESSAGES/django.po
django/contrib/auth/locale/et/LC_MESSAGES/django.mo
django/contrib/auth/locale/et/LC_MESSAGES/django.po
django/contrib/auth/locale/eu/LC_MESSAGES/django.mo
django/contrib/auth/locale/eu/LC_MESSAGES/django.po
django/contrib/auth/locale/fa/LC_MESSAGES/django.mo
django/contrib/auth/locale/fa/LC_MESSAGES/django.po
django/contrib/auth/locale/fi/LC_MESSAGES/django.mo
django/contrib/auth/locale/fi/LC_MESSAGES/django.po
django/contrib/auth/locale/fr/LC_MESSAGES/django.mo
django/contrib/auth/locale/fr/LC_MESSAGES/django.po
django/contrib/auth/locale/fy/LC_MESSAGES/django.mo
django/contrib/auth/locale/fy/LC_MESSAGES/django.po
django/contrib/auth/locale/ga/LC_MESSAGES/django.mo
django/contrib/auth/locale/ga/LC_MESSAGES/django.po
django/contrib/auth/locale/gd/LC_MESSAGES/django.mo
django/contrib/auth/locale/gd/LC_MESSAGES/django.po
django/contrib/auth/locale/gl/LC_MESSAGES/django.mo
django/contrib/auth/locale/gl/LC_MESSAGES/django.po
django/contrib/auth/locale/he/LC_MESSAGES/django.mo
django/contrib/auth/locale/he/LC_MESSAGES/django.po
django/contrib/auth/locale/hi/LC_MESSAGES/django.mo
django/contrib/auth/locale/hi/LC_MESSAGES/django.po
django/contrib/auth/locale/hr/LC_MESSAGES/django.mo
django/contrib/auth/locale/hr/LC_MESSAGES/django.po
django/contrib/auth/locale/hsb/LC_MESSAGES/django.mo
django/contrib/auth/locale/hsb/LC_MESSAGES/django.po
django/contrib/auth/locale/hu/LC_MESSAGES/django.mo
django/contrib/auth/locale/hu/LC_MESSAGES/django.po
django/contrib/auth/locale/ia/LC_MESSAGES/django.mo
django/contrib/auth/locale/ia/LC_MESSAGES/django.po
django/contrib/auth/locale/id/LC_MESSAGES/django.mo
django/contrib/auth/locale/id/LC_MESSAGES/django.po
django/contrib/auth/locale/io/LC_MESSAGES/django.mo
django/contrib/auth/locale/io/LC_MESSAGES/django.po
django/contrib/auth/locale/is/LC_MESSAGES/django.mo
django/contrib/auth/locale/is/LC_MESSAGES/django.po
django/contrib/auth/locale/it/LC_MESSAGES/django.mo
django/contrib/auth/locale/it/LC_MESSAGES/django.po
django/contrib/auth/locale/ja/LC_MESSAGES/django.mo
django/contrib/auth/locale/ja/LC_MESSAGES/django.po
django/contrib/auth/locale/ka/LC_MESSAGES/django.mo
django/contrib/auth/locale/ka/LC_MESSAGES/django.po
django/contrib/auth/locale/kk/LC_MESSAGES/django.mo
django/contrib/auth/locale/kk/LC_MESSAGES/django.po
django/contrib/auth/locale/km/LC_MESSAGES/django.mo
django/contrib/auth/locale/km/LC_MESSAGES/django.po
django/contrib/auth/locale/kn/LC_MESSAGES/django.mo
django/contrib/auth/locale/kn/LC_MESSAGES/django.po
django/contrib/auth/locale/ko/LC_MESSAGES/django.mo
django/contrib/auth/locale/ko/LC_MESSAGES/django.po
django/contrib/auth/locale/lb/LC_MESSAGES/django.mo
django/contrib/auth/locale/lb/LC_MESSAGES/django.po
django/contrib/auth/locale/lt/LC_MESSAGES/django.mo
django/contrib/auth/locale/lt/LC_MESSAGES/django.po
django/contrib/auth/locale/lv/LC_MESSAGES/django.mo
django/contrib/auth/locale/lv/LC_MESSAGES/django.po
django/contrib/auth/locale/mk/LC_MESSAGES/django.mo
django/contrib/auth/locale/mk/LC_MESSAGES/django.po
django/contrib/auth/locale/ml/LC_MESSAGES/django.mo
django/contrib/auth/locale/ml/LC_MESSAGES/django.po
django/contrib/auth/locale/mn/LC_MESSAGES/django.mo
django/contrib/auth/locale/mn/LC_MESSAGES/django.po
django/contrib/auth/locale/mr/LC_MESSAGES/django.mo
django/contrib/auth/locale/mr/LC_MESSAGES/django.po
django/contrib/auth/locale/my/LC_MESSAGES/django.mo
django/contrib/auth/locale/my/LC_MESSAGES/django.po
django/contrib/auth/locale/nb/LC_MESSAGES/django.mo
django/contrib/auth/locale/nb/LC_MESSAGES/django.po
django/contrib/auth/locale/ne/LC_MESSAGES/django.mo
django/contrib/auth/locale/ne/LC_MESSAGES/django.po
django/contrib/auth/locale/nl/LC_MESSAGES/django.mo
django/contrib/auth/locale/nl/LC_MESSAGES/django.po
django/contrib/auth/locale/nn/LC_MESSAGES/django.mo
django/contrib/auth/locale/nn/LC_MESSAGES/django.po
django/contrib/auth/locale/os/LC_MESSAGES/django.mo
django/contrib/auth/locale/os/LC_MESSAGES/django.po
django/contrib/auth/locale/pa/LC_MESSAGES/django.mo
django/contrib/auth/locale/pa/LC_MESSAGES/django.po
django/contrib/auth/locale/pl/LC_MESSAGES/django.mo
django/contrib/auth/locale/pl/LC_MESSAGES/django.po
django/contrib/auth/locale/pt/LC_MESSAGES/django.mo
django/contrib/auth/locale/pt/LC_MESSAGES/django.po
django/contrib/auth/locale/pt_BR/LC_MESSAGES/django.mo
django/contrib/auth/locale/pt_BR/LC_MESSAGES/django.po
django/contrib/auth/locale/ro/LC_MESSAGES/django.mo
django/contrib/auth/locale/ro/LC_MESSAGES/django.po
django/contrib/auth/locale/ru/LC_MESSAGES/django.mo
django/contrib/auth/locale/ru/LC_MESSAGES/django.po
django/contrib/auth/locale/sk/LC_MESSAGES/django.mo
django/contrib/auth/locale/sk/LC_MESSAGES/django.po
django/contrib/auth/locale/sl/LC_MESSAGES/django.mo
django/contrib/auth/locale/sl/LC_MESSAGES/django.po
django/contrib/auth/locale/sq/LC_MESSAGES/django.mo
django/contrib/auth/locale/sq/LC_MESSAGES/django.po
django/contrib/auth/locale/sr/LC_MESSAGES/django.mo
django/contrib/auth/locale/sr/LC_MESSAGES/django.po
django/contrib/auth/locale/sr_Latn/LC_MESSAGES/django.mo
django/contrib/auth/locale/sr_Latn/LC_MESSAGES/django.po
django/contrib/auth/locale/sv/LC_MESSAGES/django.mo
django/contrib/auth/locale/sv/LC_MESSAGES/django.po
django/contrib/auth/locale/sw/LC_MESSAGES/django.mo
django/contrib/auth/locale/sw/LC_MESSAGES/django.po
django/contrib/auth/locale/ta/LC_MESSAGES/django.mo
django/contrib/auth/locale/ta/LC_MESSAGES/django.po
django/contrib/auth/locale/te/LC_MESSAGES/django.mo
django/contrib/auth/locale/te/LC_MESSAGES/django.po
django/contrib/auth/locale/th/LC_MESSAGES/django.mo
django/contrib/auth/locale/th/LC_MESSAGES/django.po
django/contrib/auth/locale/tr/LC_MESSAGES/django.mo
django/contrib/auth/locale/tr/LC_MESSAGES/django.po
django/contrib/auth/locale/tt/LC_MESSAGES/django.mo
django/contrib/auth/locale/tt/LC_MESSAGES/django.po
django/contrib/auth/locale/udm/LC_MESSAGES/django.mo
django/contrib/auth/locale/udm/LC_MESSAGES/django.po
django/contrib/auth/locale/uk/LC_MESSAGES/django.mo
django/contrib/auth/locale/uk/LC_MESSAGES/django.po
django/contrib/auth/locale/ur/LC_MESSAGES/django.mo
django/contrib/auth/locale/ur/LC_MESSAGES/django.po
django/contrib/auth/locale/vi/LC_MESSAGES/django.mo
django/contrib/auth/locale/vi/LC_MESSAGES/django.po
django/contrib/auth/locale/zh_Hans/LC_MESSAGES/django.mo
django/contrib/auth/locale/zh_Hans/LC_MESSAGES/django.po
django/contrib/auth/locale/zh_Hant/LC_MESSAGES/django.mo
django/contrib/auth/locale/zh_Hant/LC_MESSAGES/django.po
django/contrib/auth/management/__init__.py
django/contrib/auth/management/commands/__init__.py
django/contrib/auth/management/commands/changepassword.py
django/contrib/auth/management/commands/createsuperuser.py
django/contrib/auth/migrations/0001_initial.py
django/contrib/auth/migrations/0002_alter_permission_name_max_length.py
django/contrib/auth/migrations/0003_alter_user_email_max_length.py
django/contrib/auth/migrations/0004_alter_user_username_opts.py
django/contrib/auth/migrations/0005_alter_user_last_login_null.py
django/contrib/auth/migrations/0006_require_contenttypes_0002.py
django/contrib/auth/migrations/0007_alter_validators_add_error_messages.py
django/contrib/auth/migrations/0008_alter_user_username_max_length.py
django/contrib/auth/migrations/__init__.py
django/contrib/auth/templates/auth/widgets/read_only_password_hash.html
django/contrib/auth/templates/registration/password_reset_subject.txt
django/contrib/auth/tests/__init__.py
django/contrib/auth/tests/utils.py
django/contrib/contenttypes/__init__.py
django/contrib/contenttypes/admin.py
django/contrib/contenttypes/apps.py
django/contrib/contenttypes/checks.py
django/contrib/contenttypes/fields.py
django/contrib/contenttypes/forms.py
django/contrib/contenttypes/models.py
django/contrib/contenttypes/views.py
django/contrib/contenttypes/locale/af/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/af/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/ar/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/ar/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/ast/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/ast/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/az/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/az/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/be/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/be/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/bg/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/bg/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/bn/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/bn/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/br/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/br/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/bs/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/bs/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/ca/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/ca/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/cs/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/cs/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/cy/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/cy/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/da/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/da/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/de/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/de/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/dsb/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/dsb/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/el/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/el/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/en/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/en/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/en_AU/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/en_AU/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/en_GB/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/en_GB/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/eo/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/eo/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/es/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/es/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/es_AR/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/es_AR/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/es_CO/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/es_CO/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/es_MX/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/es_MX/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/es_VE/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/es_VE/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/et/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/et/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/eu/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/eu/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/fa/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/fa/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/fi/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/fi/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/fr/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/fr/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/fy/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/fy/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/ga/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/ga/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/gd/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/gd/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/gl/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/gl/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/he/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/he/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/hi/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/hi/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/hr/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/hr/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/hsb/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/hsb/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/hu/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/hu/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/ia/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/ia/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/id/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/id/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/io/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/io/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/is/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/is/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/it/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/it/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/ja/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/ja/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/ka/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/ka/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/kk/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/kk/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/km/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/km/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/kn/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/kn/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/ko/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/ko/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/lb/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/lb/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/lt/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/lt/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/lv/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/lv/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/mk/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/mk/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/ml/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/ml/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/mn/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/mn/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/mr/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/mr/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/my/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/my/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/nb/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/nb/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/ne/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/ne/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/nl/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/nl/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/nn/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/nn/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/os/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/os/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/pa/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/pa/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/pl/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/pl/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/pt/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/pt/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/pt_BR/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/pt_BR/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/ro/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/ro/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/ru/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/ru/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/sk/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/sk/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/sl/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/sl/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/sq/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/sq/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/sr/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/sr/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/sr_Latn/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/sr_Latn/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/sv/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/sv/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/sw/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/sw/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/ta/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/ta/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/te/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/te/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/th/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/th/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/tr/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/tr/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/tt/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/tt/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/udm/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/udm/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/uk/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/uk/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/ur/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/ur/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/vi/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/vi/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/zh_Hans/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/zh_Hans/LC_MESSAGES/django.po
django/contrib/contenttypes/locale/zh_Hant/LC_MESSAGES/django.mo
django/contrib/contenttypes/locale/zh_Hant/LC_MESSAGES/django.po
django/contrib/contenttypes/management/__init__.py
django/contrib/contenttypes/management/commands/__init__.py
django/contrib/contenttypes/management/commands/remove_stale_contenttypes.py
django/contrib/contenttypes/migrations/0001_initial.py
django/contrib/contenttypes/migrations/0002_remove_content_type_name.py
django/contrib/contenttypes/migrations/__init__.py
django/contrib/flatpages/__init__.py
django/contrib/flatpages/admin.py
django/contrib/flatpages/apps.py
django/contrib/flatpages/forms.py
django/contrib/flatpages/middleware.py
django/contrib/flatpages/models.py
django/contrib/flatpages/sitemaps.py
django/contrib/flatpages/urls.py
django/contrib/flatpages/views.py
django/contrib/flatpages/locale/af/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/af/LC_MESSAGES/django.po
django/contrib/flatpages/locale/ar/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/ar/LC_MESSAGES/django.po
django/contrib/flatpages/locale/ast/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/ast/LC_MESSAGES/django.po
django/contrib/flatpages/locale/az/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/az/LC_MESSAGES/django.po
django/contrib/flatpages/locale/be/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/be/LC_MESSAGES/django.po
django/contrib/flatpages/locale/bg/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/bg/LC_MESSAGES/django.po
django/contrib/flatpages/locale/bn/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/bn/LC_MESSAGES/django.po
django/contrib/flatpages/locale/br/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/br/LC_MESSAGES/django.po
django/contrib/flatpages/locale/bs/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/bs/LC_MESSAGES/django.po
django/contrib/flatpages/locale/ca/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/ca/LC_MESSAGES/django.po
django/contrib/flatpages/locale/cs/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/cs/LC_MESSAGES/django.po
django/contrib/flatpages/locale/cy/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/cy/LC_MESSAGES/django.po
django/contrib/flatpages/locale/da/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/da/LC_MESSAGES/django.po
django/contrib/flatpages/locale/de/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/de/LC_MESSAGES/django.po
django/contrib/flatpages/locale/dsb/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/dsb/LC_MESSAGES/django.po
django/contrib/flatpages/locale/el/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/el/LC_MESSAGES/django.po
django/contrib/flatpages/locale/en/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/en/LC_MESSAGES/django.po
django/contrib/flatpages/locale/en_AU/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/en_AU/LC_MESSAGES/django.po
django/contrib/flatpages/locale/en_GB/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/en_GB/LC_MESSAGES/django.po
django/contrib/flatpages/locale/eo/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/eo/LC_MESSAGES/django.po
django/contrib/flatpages/locale/es/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/es/LC_MESSAGES/django.po
django/contrib/flatpages/locale/es_AR/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/es_AR/LC_MESSAGES/django.po
django/contrib/flatpages/locale/es_CO/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/es_CO/LC_MESSAGES/django.po
django/contrib/flatpages/locale/es_MX/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/es_MX/LC_MESSAGES/django.po
django/contrib/flatpages/locale/es_VE/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/es_VE/LC_MESSAGES/django.po
django/contrib/flatpages/locale/et/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/et/LC_MESSAGES/django.po
django/contrib/flatpages/locale/eu/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/eu/LC_MESSAGES/django.po
django/contrib/flatpages/locale/fa/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/fa/LC_MESSAGES/django.po
django/contrib/flatpages/locale/fi/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/fi/LC_MESSAGES/django.po
django/contrib/flatpages/locale/fr/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/fr/LC_MESSAGES/django.po
django/contrib/flatpages/locale/fy/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/fy/LC_MESSAGES/django.po
django/contrib/flatpages/locale/ga/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/ga/LC_MESSAGES/django.po
django/contrib/flatpages/locale/gd/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/gd/LC_MESSAGES/django.po
django/contrib/flatpages/locale/gl/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/gl/LC_MESSAGES/django.po
django/contrib/flatpages/locale/he/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/he/LC_MESSAGES/django.po
django/contrib/flatpages/locale/hi/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/hi/LC_MESSAGES/django.po
django/contrib/flatpages/locale/hr/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/hr/LC_MESSAGES/django.po
django/contrib/flatpages/locale/hsb/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/hsb/LC_MESSAGES/django.po
django/contrib/flatpages/locale/hu/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/hu/LC_MESSAGES/django.po
django/contrib/flatpages/locale/ia/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/ia/LC_MESSAGES/django.po
django/contrib/flatpages/locale/id/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/id/LC_MESSAGES/django.po
django/contrib/flatpages/locale/io/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/io/LC_MESSAGES/django.po
django/contrib/flatpages/locale/is/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/is/LC_MESSAGES/django.po
django/contrib/flatpages/locale/it/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/it/LC_MESSAGES/django.po
django/contrib/flatpages/locale/ja/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/ja/LC_MESSAGES/django.po
django/contrib/flatpages/locale/ka/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/ka/LC_MESSAGES/django.po
django/contrib/flatpages/locale/kk/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/kk/LC_MESSAGES/django.po
django/contrib/flatpages/locale/km/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/km/LC_MESSAGES/django.po
django/contrib/flatpages/locale/kn/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/kn/LC_MESSAGES/django.po
django/contrib/flatpages/locale/ko/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/ko/LC_MESSAGES/django.po
django/contrib/flatpages/locale/lb/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/lb/LC_MESSAGES/django.po
django/contrib/flatpages/locale/lt/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/lt/LC_MESSAGES/django.po
django/contrib/flatpages/locale/lv/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/lv/LC_MESSAGES/django.po
django/contrib/flatpages/locale/mk/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/mk/LC_MESSAGES/django.po
django/contrib/flatpages/locale/ml/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/ml/LC_MESSAGES/django.po
django/contrib/flatpages/locale/mn/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/mn/LC_MESSAGES/django.po
django/contrib/flatpages/locale/mr/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/mr/LC_MESSAGES/django.po
django/contrib/flatpages/locale/my/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/my/LC_MESSAGES/django.po
django/contrib/flatpages/locale/nb/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/nb/LC_MESSAGES/django.po
django/contrib/flatpages/locale/ne/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/ne/LC_MESSAGES/django.po
django/contrib/flatpages/locale/nl/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/nl/LC_MESSAGES/django.po
django/contrib/flatpages/locale/nn/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/nn/LC_MESSAGES/django.po
django/contrib/flatpages/locale/os/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/os/LC_MESSAGES/django.po
django/contrib/flatpages/locale/pa/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/pa/LC_MESSAGES/django.po
django/contrib/flatpages/locale/pl/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/pl/LC_MESSAGES/django.po
django/contrib/flatpages/locale/pt/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/pt/LC_MESSAGES/django.po
django/contrib/flatpages/locale/pt_BR/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/pt_BR/LC_MESSAGES/django.po
django/contrib/flatpages/locale/ro/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/ro/LC_MESSAGES/django.po
django/contrib/flatpages/locale/ru/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/ru/LC_MESSAGES/django.po
django/contrib/flatpages/locale/sk/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/sk/LC_MESSAGES/django.po
django/contrib/flatpages/locale/sl/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/sl/LC_MESSAGES/django.po
django/contrib/flatpages/locale/sq/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/sq/LC_MESSAGES/django.po
django/contrib/flatpages/locale/sr/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/sr/LC_MESSAGES/django.po
django/contrib/flatpages/locale/sr_Latn/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/sr_Latn/LC_MESSAGES/django.po
django/contrib/flatpages/locale/sv/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/sv/LC_MESSAGES/django.po
django/contrib/flatpages/locale/sw/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/sw/LC_MESSAGES/django.po
django/contrib/flatpages/locale/ta/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/ta/LC_MESSAGES/django.po
django/contrib/flatpages/locale/te/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/te/LC_MESSAGES/django.po
django/contrib/flatpages/locale/th/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/th/LC_MESSAGES/django.po
django/contrib/flatpages/locale/tr/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/tr/LC_MESSAGES/django.po
django/contrib/flatpages/locale/tt/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/tt/LC_MESSAGES/django.po
django/contrib/flatpages/locale/udm/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/udm/LC_MESSAGES/django.po
django/contrib/flatpages/locale/uk/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/uk/LC_MESSAGES/django.po
django/contrib/flatpages/locale/ur/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/ur/LC_MESSAGES/django.po
django/contrib/flatpages/locale/vi/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/vi/LC_MESSAGES/django.po
django/contrib/flatpages/locale/zh_Hans/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/zh_Hans/LC_MESSAGES/django.po
django/contrib/flatpages/locale/zh_Hant/LC_MESSAGES/django.mo
django/contrib/flatpages/locale/zh_Hant/LC_MESSAGES/django.po
django/contrib/flatpages/migrations/0001_initial.py
django/contrib/flatpages/migrations/__init__.py
django/contrib/flatpages/templatetags/__init__.py
django/contrib/flatpages/templatetags/flatpages.py
django/contrib/gis/__init__.py
django/contrib/gis/apps.py
django/contrib/gis/feeds.py
django/contrib/gis/measure.py
django/contrib/gis/ptr.py
django/contrib/gis/shortcuts.py
django/contrib/gis/views.py
django/contrib/gis/admin/__init__.py
django/contrib/gis/admin/options.py
django/contrib/gis/admin/widgets.py
django/contrib/gis/db/__init__.py
django/contrib/gis/db/backends/__init__.py
django/contrib/gis/db/backends/utils.py
django/contrib/gis/db/backends/base/__init__.py
django/contrib/gis/db/backends/base/adapter.py
django/contrib/gis/db/backends/base/features.py
django/contrib/gis/db/backends/base/models.py
django/contrib/gis/db/backends/base/operations.py
django/contrib/gis/db/backends/mysql/__init__.py
django/contrib/gis/db/backends/mysql/base.py
django/contrib/gis/db/backends/mysql/features.py
django/contrib/gis/db/backends/mysql/introspection.py
django/contrib/gis/db/backends/mysql/operations.py
django/contrib/gis/db/backends/mysql/schema.py
django/contrib/gis/db/backends/oracle/__init__.py
django/contrib/gis/db/backends/oracle/adapter.py
django/contrib/gis/db/backends/oracle/base.py
django/contrib/gis/db/backends/oracle/features.py
django/contrib/gis/db/backends/oracle/introspection.py
django/contrib/gis/db/backends/oracle/models.py
django/contrib/gis/db/backends/oracle/operations.py
django/contrib/gis/db/backends/oracle/schema.py
django/contrib/gis/db/backends/postgis/__init__.py
django/contrib/gis/db/backends/postgis/adapter.py
django/contrib/gis/db/backends/postgis/base.py
django/contrib/gis/db/backends/postgis/const.py
django/contrib/gis/db/backends/postgis/features.py
django/contrib/gis/db/backends/postgis/introspection.py
django/contrib/gis/db/backends/postgis/models.py
django/contrib/gis/db/backends/postgis/operations.py
django/contrib/gis/db/backends/postgis/pgraster.py
django/contrib/gis/db/backends/postgis/schema.py
django/contrib/gis/db/backends/spatialite/__init__.py
django/contrib/gis/db/backends/spatialite/adapter.py
django/contrib/gis/db/backends/spatialite/base.py
django/contrib/gis/db/backends/spatialite/client.py
django/contrib/gis/db/backends/spatialite/features.py
django/contrib/gis/db/backends/spatialite/introspection.py
django/contrib/gis/db/backends/spatialite/models.py
django/contrib/gis/db/backends/spatialite/operations.py
django/contrib/gis/db/backends/spatialite/schema.py
django/contrib/gis/db/models/__init__.py
django/contrib/gis/db/models/aggregates.py
django/contrib/gis/db/models/fields.py
django/contrib/gis/db/models/functions.py
django/contrib/gis/db/models/lookups.py
django/contrib/gis/db/models/manager.py
django/contrib/gis/db/models/proxy.py
django/contrib/gis/db/models/query.py
django/contrib/gis/db/models/sql/__init__.py
django/contrib/gis/db/models/sql/conversion.py
django/contrib/gis/forms/__init__.py
django/contrib/gis/forms/fields.py
django/contrib/gis/forms/widgets.py
django/contrib/gis/gdal/LICENSE
django/contrib/gis/gdal/__init__.py
django/contrib/gis/gdal/base.py
django/contrib/gis/gdal/datasource.py
django/contrib/gis/gdal/driver.py
django/contrib/gis/gdal/envelope.py
django/contrib/gis/gdal/error.py
django/contrib/gis/gdal/feature.py
django/contrib/gis/gdal/field.py
django/contrib/gis/gdal/geometries.py
django/contrib/gis/gdal/geomtype.py
django/contrib/gis/gdal/layer.py
django/contrib/gis/gdal/libgdal.py
django/contrib/gis/gdal/srs.py
django/contrib/gis/gdal/prototypes/__init__.py
django/contrib/gis/gdal/prototypes/ds.py
django/contrib/gis/gdal/prototypes/errcheck.py
django/contrib/gis/gdal/prototypes/generation.py
django/contrib/gis/gdal/prototypes/geom.py
django/contrib/gis/gdal/prototypes/raster.py
django/contrib/gis/gdal/prototypes/srs.py
django/contrib/gis/gdal/raster/__init__.py
django/contrib/gis/gdal/raster/band.py
django/contrib/gis/gdal/raster/const.py
django/contrib/gis/gdal/raster/source.py
django/contrib/gis/geoip/__init__.py
django/contrib/gis/geoip/base.py
django/contrib/gis/geoip/libgeoip.py
django/contrib/gis/geoip/prototypes.py
django/contrib/gis/geoip2/__init__.py
django/contrib/gis/geoip2/base.py
django/contrib/gis/geoip2/resources.py
django/contrib/gis/geometry/__init__.py
django/contrib/gis/geometry/regex.py
django/contrib/gis/geometry/backend/__init__.py
django/contrib/gis/geometry/backend/geos.py
django/contrib/gis/geos/LICENSE
django/contrib/gis/geos/__init__.py
django/contrib/gis/geos/base.py
django/contrib/gis/geos/collections.py
django/contrib/gis/geos/coordseq.py
django/contrib/gis/geos/error.py
django/contrib/gis/geos/factory.py
django/contrib/gis/geos/geometry.py
django/contrib/gis/geos/io.py
django/contrib/gis/geos/libgeos.py
django/contrib/gis/geos/linestring.py
django/contrib/gis/geos/mutable_list.py
django/contrib/gis/geos/point.py
django/contrib/gis/geos/polygon.py
django/contrib/gis/geos/prepared.py
django/contrib/gis/geos/prototypes/__init__.py
django/contrib/gis/geos/prototypes/coordseq.py
django/contrib/gis/geos/prototypes/errcheck.py
django/contrib/gis/geos/prototypes/geom.py
django/contrib/gis/geos/prototypes/io.py
django/contrib/gis/geos/prototypes/misc.py
django/contrib/gis/geos/prototypes/predicates.py
django/contrib/gis/geos/prototypes/prepared.py
django/contrib/gis/geos/prototypes/threadsafe.py
django/contrib/gis/geos/prototypes/topology.py
django/contrib/gis/locale/af/LC_MESSAGES/django.mo
django/contrib/gis/locale/af/LC_MESSAGES/django.po
django/contrib/gis/locale/ar/LC_MESSAGES/django.mo
django/contrib/gis/locale/ar/LC_MESSAGES/django.po
django/contrib/gis/locale/ast/LC_MESSAGES/django.mo
django/contrib/gis/locale/ast/LC_MESSAGES/django.po
django/contrib/gis/locale/az/LC_MESSAGES/django.mo
django/contrib/gis/locale/az/LC_MESSAGES/django.po
django/contrib/gis/locale/be/LC_MESSAGES/django.mo
django/contrib/gis/locale/be/LC_MESSAGES/django.po
django/contrib/gis/locale/bg/LC_MESSAGES/django.mo
django/contrib/gis/locale/bg/LC_MESSAGES/django.po
django/contrib/gis/locale/bn/LC_MESSAGES/django.mo
django/contrib/gis/locale/bn/LC_MESSAGES/django.po
django/contrib/gis/locale/br/LC_MESSAGES/django.mo
django/contrib/gis/locale/br/LC_MESSAGES/django.po
django/contrib/gis/locale/bs/LC_MESSAGES/django.mo
django/contrib/gis/locale/bs/LC_MESSAGES/django.po
django/contrib/gis/locale/ca/LC_MESSAGES/django.mo
django/contrib/gis/locale/ca/LC_MESSAGES/django.po
django/contrib/gis/locale/cs/LC_MESSAGES/django.mo
django/contrib/gis/locale/cs/LC_MESSAGES/django.po
django/contrib/gis/locale/cy/LC_MESSAGES/django.mo
django/contrib/gis/locale/cy/LC_MESSAGES/django.po
django/contrib/gis/locale/da/LC_MESSAGES/django.mo
django/contrib/gis/locale/da/LC_MESSAGES/django.po
django/contrib/gis/locale/de/LC_MESSAGES/django.mo
django/contrib/gis/locale/de/LC_MESSAGES/django.po
django/contrib/gis/locale/dsb/LC_MESSAGES/django.mo
django/contrib/gis/locale/dsb/LC_MESSAGES/django.po
django/contrib/gis/locale/el/LC_MESSAGES/django.mo
django/contrib/gis/locale/el/LC_MESSAGES/django.po
django/contrib/gis/locale/en/LC_MESSAGES/django.mo
django/contrib/gis/locale/en/LC_MESSAGES/django.po
django/contrib/gis/locale/en_AU/LC_MESSAGES/django.mo
django/contrib/gis/locale/en_AU/LC_MESSAGES/django.po
django/contrib/gis/locale/en_GB/LC_MESSAGES/django.mo
django/contrib/gis/locale/en_GB/LC_MESSAGES/django.po
django/contrib/gis/locale/eo/LC_MESSAGES/django.mo
django/contrib/gis/locale/eo/LC_MESSAGES/django.po
django/contrib/gis/locale/es/LC_MESSAGES/django.mo
django/contrib/gis/locale/es/LC_MESSAGES/django.po
django/contrib/gis/locale/es_AR/LC_MESSAGES/django.mo
django/contrib/gis/locale/es_AR/LC_MESSAGES/django.po
django/contrib/gis/locale/es_CO/LC_MESSAGES/django.mo
django/contrib/gis/locale/es_CO/LC_MESSAGES/django.po
django/contrib/gis/locale/es_MX/LC_MESSAGES/django.mo
django/contrib/gis/locale/es_MX/LC_MESSAGES/django.po
django/contrib/gis/locale/es_VE/LC_MESSAGES/django.mo
django/contrib/gis/locale/es_VE/LC_MESSAGES/django.po
django/contrib/gis/locale/et/LC_MESSAGES/django.mo
django/contrib/gis/locale/et/LC_MESSAGES/django.po
django/contrib/gis/locale/eu/LC_MESSAGES/django.mo
django/contrib/gis/locale/eu/LC_MESSAGES/django.po
django/contrib/gis/locale/fa/LC_MESSAGES/django.mo
django/contrib/gis/locale/fa/LC_MESSAGES/django.po
django/contrib/gis/locale/fi/LC_MESSAGES/django.mo
django/contrib/gis/locale/fi/LC_MESSAGES/django.po
django/contrib/gis/locale/fr/LC_MESSAGES/django.mo
django/contrib/gis/locale/fr/LC_MESSAGES/django.po
django/contrib/gis/locale/fy/LC_MESSAGES/django.mo
django/contrib/gis/locale/fy/LC_MESSAGES/django.po
django/contrib/gis/locale/ga/LC_MESSAGES/django.mo
django/contrib/gis/locale/ga/LC_MESSAGES/django.po
django/contrib/gis/locale/gd/LC_MESSAGES/django.mo
django/contrib/gis/locale/gd/LC_MESSAGES/django.po
django/contrib/gis/locale/gl/LC_MESSAGES/django.mo
django/contrib/gis/locale/gl/LC_MESSAGES/django.po
django/contrib/gis/locale/he/LC_MESSAGES/django.mo
django/contrib/gis/locale/he/LC_MESSAGES/django.po
django/contrib/gis/locale/hi/LC_MESSAGES/django.mo
django/contrib/gis/locale/hi/LC_MESSAGES/django.po
django/contrib/gis/locale/hr/LC_MESSAGES/django.mo
django/contrib/gis/locale/hr/LC_MESSAGES/django.po
django/contrib/gis/locale/hsb/LC_MESSAGES/django.mo
django/contrib/gis/locale/hsb/LC_MESSAGES/django.po
django/contrib/gis/locale/hu/LC_MESSAGES/django.mo
django/contrib/gis/locale/hu/LC_MESSAGES/django.po
django/contrib/gis/locale/ia/LC_MESSAGES/django.mo
django/contrib/gis/locale/ia/LC_MESSAGES/django.po
django/contrib/gis/locale/id/LC_MESSAGES/django.mo
django/contrib/gis/locale/id/LC_MESSAGES/django.po
django/contrib/gis/locale/io/LC_MESSAGES/django.mo
django/contrib/gis/locale/io/LC_MESSAGES/django.po
django/contrib/gis/locale/is/LC_MESSAGES/django.mo
django/contrib/gis/locale/is/LC_MESSAGES/django.po
django/contrib/gis/locale/it/LC_MESSAGES/django.mo
django/contrib/gis/locale/it/LC_MESSAGES/django.po
django/contrib/gis/locale/ja/LC_MESSAGES/django.mo
django/contrib/gis/locale/ja/LC_MESSAGES/django.po
django/contrib/gis/locale/ka/LC_MESSAGES/django.mo
django/contrib/gis/locale/ka/LC_MESSAGES/django.po
django/contrib/gis/locale/kk/LC_MESSAGES/django.mo
django/contrib/gis/locale/kk/LC_MESSAGES/django.po
django/contrib/gis/locale/km/LC_MESSAGES/django.mo
django/contrib/gis/locale/km/LC_MESSAGES/django.po
django/contrib/gis/locale/kn/LC_MESSAGES/django.mo
django/contrib/gis/locale/kn/LC_MESSAGES/django.po
django/contrib/gis/locale/ko/LC_MESSAGES/django.mo
django/contrib/gis/locale/ko/LC_MESSAGES/django.po
django/contrib/gis/locale/lb/LC_MESSAGES/django.mo
django/contrib/gis/locale/lb/LC_MESSAGES/django.po
django/contrib/gis/locale/lt/LC_MESSAGES/django.mo
django/contrib/gis/locale/lt/LC_MESSAGES/django.po
django/contrib/gis/locale/lv/LC_MESSAGES/django.mo
django/contrib/gis/locale/lv/LC_MESSAGES/django.po
django/contrib/gis/locale/mk/LC_MESSAGES/django.mo
django/contrib/gis/locale/mk/LC_MESSAGES/django.po
django/contrib/gis/locale/ml/LC_MESSAGES/django.mo
django/contrib/gis/locale/ml/LC_MESSAGES/django.po
django/contrib/gis/locale/mn/LC_MESSAGES/django.mo
django/contrib/gis/locale/mn/LC_MESSAGES/django.po
django/contrib/gis/locale/mr/LC_MESSAGES/django.mo
django/contrib/gis/locale/mr/LC_MESSAGES/django.po
django/contrib/gis/locale/my/LC_MESSAGES/django.mo
django/contrib/gis/locale/my/LC_MESSAGES/django.po
django/contrib/gis/locale/nb/LC_MESSAGES/django.mo
django/contrib/gis/locale/nb/LC_MESSAGES/django.po
django/contrib/gis/locale/ne/LC_MESSAGES/django.mo
django/contrib/gis/locale/ne/LC_MESSAGES/django.po
django/contrib/gis/locale/nl/LC_MESSAGES/django.mo
django/contrib/gis/locale/nl/LC_MESSAGES/django.po
django/contrib/gis/locale/nn/LC_MESSAGES/django.mo
django/contrib/gis/locale/nn/LC_MESSAGES/django.po
django/contrib/gis/locale/os/LC_MESSAGES/django.mo
django/contrib/gis/locale/os/LC_MESSAGES/django.po
django/contrib/gis/locale/pa/LC_MESSAGES/django.mo
django/contrib/gis/locale/pa/LC_MESSAGES/django.po
django/contrib/gis/locale/pl/LC_MESSAGES/django.mo
django/contrib/gis/locale/pl/LC_MESSAGES/django.po
django/contrib/gis/locale/pt/LC_MESSAGES/django.mo
django/contrib/gis/locale/pt/LC_MESSAGES/django.po
django/contrib/gis/locale/pt_BR/LC_MESSAGES/django.mo
django/contrib/gis/locale/pt_BR/LC_MESSAGES/django.po
django/contrib/gis/locale/ro/LC_MESSAGES/django.mo
django/contrib/gis/locale/ro/LC_MESSAGES/django.po
django/contrib/gis/locale/ru/LC_MESSAGES/django.mo
django/contrib/gis/locale/ru/LC_MESSAGES/django.po
django/contrib/gis/locale/sk/LC_MESSAGES/django.mo
django/contrib/gis/locale/sk/LC_MESSAGES/django.po
django/contrib/gis/locale/sl/LC_MESSAGES/django.mo
django/contrib/gis/locale/sl/LC_MESSAGES/django.po
django/contrib/gis/locale/sq/LC_MESSAGES/django.mo
django/contrib/gis/locale/sq/LC_MESSAGES/django.po
django/contrib/gis/locale/sr/LC_MESSAGES/django.mo
django/contrib/gis/locale/sr/LC_MESSAGES/django.po
django/contrib/gis/locale/sr_Latn/LC_MESSAGES/django.mo
django/contrib/gis/locale/sr_Latn/LC_MESSAGES/django.po
django/contrib/gis/locale/sv/LC_MESSAGES/django.mo
django/contrib/gis/locale/sv/LC_MESSAGES/django.po
django/contrib/gis/locale/sw/LC_MESSAGES/django.mo
django/contrib/gis/locale/sw/LC_MESSAGES/django.po
django/contrib/gis/locale/ta/LC_MESSAGES/django.mo
django/contrib/gis/locale/ta/LC_MESSAGES/django.po
django/contrib/gis/locale/te/LC_MESSAGES/django.mo
django/contrib/gis/locale/te/LC_MESSAGES/django.po
django/contrib/gis/locale/th/LC_MESSAGES/django.mo
django/contrib/gis/locale/th/LC_MESSAGES/django.po
django/contrib/gis/locale/tr/LC_MESSAGES/django.mo
django/contrib/gis/locale/tr/LC_MESSAGES/django.po
django/contrib/gis/locale/tt/LC_MESSAGES/django.mo
django/contrib/gis/locale/tt/LC_MESSAGES/django.po
django/contrib/gis/locale/udm/LC_MESSAGES/django.mo
django/contrib/gis/locale/udm/LC_MESSAGES/django.po
django/contrib/gis/locale/uk/LC_MESSAGES/django.mo
django/contrib/gis/locale/uk/LC_MESSAGES/django.po
django/contrib/gis/locale/ur/LC_MESSAGES/django.mo
django/contrib/gis/locale/ur/LC_MESSAGES/django.po
django/contrib/gis/locale/vi/LC_MESSAGES/django.mo
django/contrib/gis/locale/vi/LC_MESSAGES/django.po
django/contrib/gis/locale/zh_Hans/LC_MESSAGES/django.mo
django/contrib/gis/locale/zh_Hans/LC_MESSAGES/django.po
django/contrib/gis/locale/zh_Hant/LC_MESSAGES/django.mo
django/contrib/gis/locale/zh_Hant/LC_MESSAGES/django.po
django/contrib/gis/management/__init__.py
django/contrib/gis/management/commands/__init__.py
django/contrib/gis/management/commands/inspectdb.py
django/contrib/gis/management/commands/ogrinspect.py
django/contrib/gis/serializers/__init__.py
django/contrib/gis/serializers/geojson.py
django/contrib/gis/sitemaps/__init__.py
django/contrib/gis/sitemaps/kml.py
django/contrib/gis/sitemaps/views.py
django/contrib/gis/static/gis/css/ol3.css
django/contrib/gis/static/gis/img/draw_line_off.svg
django/contrib/gis/static/gis/img/draw_line_on.svg
django/contrib/gis/static/gis/img/draw_point_off.svg
django/contrib/gis/static/gis/img/draw_point_on.svg
django/contrib/gis/static/gis/img/draw_polygon_off.svg
django/contrib/gis/static/gis/img/draw_polygon_on.svg
django/contrib/gis/static/gis/js/OLMapWidget.js
django/contrib/gis/templates/gis/openlayers-osm.html
django/contrib/gis/templates/gis/openlayers.html
django/contrib/gis/templates/gis/admin/openlayers.html
django/contrib/gis/templates/gis/admin/openlayers.js
django/contrib/gis/templates/gis/admin/osm.html
django/contrib/gis/templates/gis/admin/osm.js
django/contrib/gis/templates/gis/kml/base.kml
django/contrib/gis/templates/gis/kml/placemarks.kml
django/contrib/gis/utils/__init__.py
django/contrib/gis/utils/layermapping.py
django/contrib/gis/utils/ogrinfo.py
django/contrib/gis/utils/ogrinspect.py
django/contrib/gis/utils/srs.py
django/contrib/gis/utils/wkt.py
django/contrib/humanize/__init__.py
django/contrib/humanize/apps.py
django/contrib/humanize/locale/af/LC_MESSAGES/django.mo
django/contrib/humanize/locale/af/LC_MESSAGES/django.po
django/contrib/humanize/locale/ar/LC_MESSAGES/django.mo
django/contrib/humanize/locale/ar/LC_MESSAGES/django.po
django/contrib/humanize/locale/ast/LC_MESSAGES/django.mo
django/contrib/humanize/locale/ast/LC_MESSAGES/django.po
django/contrib/humanize/locale/az/LC_MESSAGES/django.mo
django/contrib/humanize/locale/az/LC_MESSAGES/django.po
django/contrib/humanize/locale/be/LC_MESSAGES/django.mo
django/contrib/humanize/locale/be/LC_MESSAGES/django.po
django/contrib/humanize/locale/bg/LC_MESSAGES/django.mo
django/contrib/humanize/locale/bg/LC_MESSAGES/django.po
django/contrib/humanize/locale/bn/LC_MESSAGES/django.mo
django/contrib/humanize/locale/bn/LC_MESSAGES/django.po
django/contrib/humanize/locale/br/LC_MESSAGES/django.mo
django/contrib/humanize/locale/br/LC_MESSAGES/django.po
django/contrib/humanize/locale/bs/LC_MESSAGES/django.mo
django/contrib/humanize/locale/bs/LC_MESSAGES/django.po
django/contrib/humanize/locale/ca/LC_MESSAGES/django.mo
django/contrib/humanize/locale/ca/LC_MESSAGES/django.po
django/contrib/humanize/locale/cs/LC_MESSAGES/django.mo
django/contrib/humanize/locale/cs/LC_MESSAGES/django.po
django/contrib/humanize/locale/cy/LC_MESSAGES/django.mo
django/contrib/humanize/locale/cy/LC_MESSAGES/django.po
django/contrib/humanize/locale/da/LC_MESSAGES/django.mo
django/contrib/humanize/locale/da/LC_MESSAGES/django.po
django/contrib/humanize/locale/de/LC_MESSAGES/django.mo
django/contrib/humanize/locale/de/LC_MESSAGES/django.po
django/contrib/humanize/locale/dsb/LC_MESSAGES/django.mo
django/contrib/humanize/locale/dsb/LC_MESSAGES/django.po
django/contrib/humanize/locale/el/LC_MESSAGES/django.mo
django/contrib/humanize/locale/el/LC_MESSAGES/django.po
django/contrib/humanize/locale/en/LC_MESSAGES/django.mo
django/contrib/humanize/locale/en/LC_MESSAGES/django.po
django/contrib/humanize/locale/en_AU/LC_MESSAGES/django.mo
django/contrib/humanize/locale/en_AU/LC_MESSAGES/django.po
django/contrib/humanize/locale/en_GB/LC_MESSAGES/django.mo
django/contrib/humanize/locale/en_GB/LC_MESSAGES/django.po
django/contrib/humanize/locale/eo/LC_MESSAGES/django.mo
django/contrib/humanize/locale/eo/LC_MESSAGES/django.po
django/contrib/humanize/locale/es/LC_MESSAGES/django.mo
django/contrib/humanize/locale/es/LC_MESSAGES/django.po
django/contrib/humanize/locale/es_AR/LC_MESSAGES/django.mo
django/contrib/humanize/locale/es_AR/LC_MESSAGES/django.po
django/contrib/humanize/locale/es_CO/LC_MESSAGES/django.mo
django/contrib/humanize/locale/es_CO/LC_MESSAGES/django.po
django/contrib/humanize/locale/es_MX/LC_MESSAGES/django.mo
django/contrib/humanize/locale/es_MX/LC_MESSAGES/django.po
django/contrib/humanize/locale/es_VE/LC_MESSAGES/django.mo
django/contrib/humanize/locale/es_VE/LC_MESSAGES/django.po
django/contrib/humanize/locale/et/LC_MESSAGES/django.mo
django/contrib/humanize/locale/et/LC_MESSAGES/django.po
django/contrib/humanize/locale/eu/LC_MESSAGES/django.mo
django/contrib/humanize/locale/eu/LC_MESSAGES/django.po
django/contrib/humanize/locale/fa/LC_MESSAGES/django.mo
django/contrib/humanize/locale/fa/LC_MESSAGES/django.po
django/contrib/humanize/locale/fi/LC_MESSAGES/django.mo
django/contrib/humanize/locale/fi/LC_MESSAGES/django.po
django/contrib/humanize/locale/fr/LC_MESSAGES/django.mo
django/contrib/humanize/locale/fr/LC_MESSAGES/django.po
django/contrib/humanize/locale/fy/LC_MESSAGES/django.mo
django/contrib/humanize/locale/fy/LC_MESSAGES/django.po
django/contrib/humanize/locale/ga/LC_MESSAGES/django.mo
django/contrib/humanize/locale/ga/LC_MESSAGES/django.po
django/contrib/humanize/locale/gd/LC_MESSAGES/django.mo
django/contrib/humanize/locale/gd/LC_MESSAGES/django.po
django/contrib/humanize/locale/gl/LC_MESSAGES/django.mo
django/contrib/humanize/locale/gl/LC_MESSAGES/django.po
django/contrib/humanize/locale/he/LC_MESSAGES/django.mo
django/contrib/humanize/locale/he/LC_MESSAGES/django.po
django/contrib/humanize/locale/hi/LC_MESSAGES/django.mo
django/contrib/humanize/locale/hi/LC_MESSAGES/django.po
django/contrib/humanize/locale/hr/LC_MESSAGES/django.mo
django/contrib/humanize/locale/hr/LC_MESSAGES/django.po
django/contrib/humanize/locale/hsb/LC_MESSAGES/django.mo
django/contrib/humanize/locale/hsb/LC_MESSAGES/django.po
django/contrib/humanize/locale/hu/LC_MESSAGES/django.mo
django/contrib/humanize/locale/hu/LC_MESSAGES/django.po
django/contrib/humanize/locale/hy/LC_MESSAGES/django.mo
django/contrib/humanize/locale/hy/LC_MESSAGES/django.po
django/contrib/humanize/locale/ia/LC_MESSAGES/django.mo
django/contrib/humanize/locale/ia/LC_MESSAGES/django.po
django/contrib/humanize/locale/id/LC_MESSAGES/django.mo
django/contrib/humanize/locale/id/LC_MESSAGES/django.po
django/contrib/humanize/locale/io/LC_MESSAGES/django.mo
django/contrib/humanize/locale/io/LC_MESSAGES/django.po
django/contrib/humanize/locale/is/LC_MESSAGES/django.mo
django/contrib/humanize/locale/is/LC_MESSAGES/django.po
django/contrib/humanize/locale/it/LC_MESSAGES/django.mo
django/contrib/humanize/locale/it/LC_MESSAGES/django.po
django/contrib/humanize/locale/ja/LC_MESSAGES/django.mo
django/contrib/humanize/locale/ja/LC_MESSAGES/django.po
django/contrib/humanize/locale/ka/LC_MESSAGES/django.mo
django/contrib/humanize/locale/ka/LC_MESSAGES/django.po
django/contrib/humanize/locale/kk/LC_MESSAGES/django.mo
django/contrib/humanize/locale/kk/LC_MESSAGES/django.po
django/contrib/humanize/locale/km/LC_MESSAGES/django.mo
django/contrib/humanize/locale/km/LC_MESSAGES/django.po
django/contrib/humanize/locale/kn/LC_MESSAGES/django.mo
django/contrib/humanize/locale/kn/LC_MESSAGES/django.po
django/contrib/humanize/locale/ko/LC_MESSAGES/django.mo
django/contrib/humanize/locale/ko/LC_MESSAGES/django.po
django/contrib/humanize/locale/lb/LC_MESSAGES/django.mo
django/contrib/humanize/locale/lb/LC_MESSAGES/django.po
django/contrib/humanize/locale/lt/LC_MESSAGES/django.mo
django/contrib/humanize/locale/lt/LC_MESSAGES/django.po
django/contrib/humanize/locale/lv/LC_MESSAGES/django.mo
django/contrib/humanize/locale/lv/LC_MESSAGES/django.po
django/contrib/humanize/locale/mk/LC_MESSAGES/django.mo
django/contrib/humanize/locale/mk/LC_MESSAGES/django.po
django/contrib/humanize/locale/ml/LC_MESSAGES/django.mo
django/contrib/humanize/locale/ml/LC_MESSAGES/django.po
django/contrib/humanize/locale/mn/LC_MESSAGES/django.mo
django/contrib/humanize/locale/mn/LC_MESSAGES/django.po
django/contrib/humanize/locale/mr/LC_MESSAGES/django.mo
django/contrib/humanize/locale/mr/LC_MESSAGES/django.po
django/contrib/humanize/locale/my/LC_MESSAGES/django.mo
django/contrib/humanize/locale/my/LC_MESSAGES/django.po
django/contrib/humanize/locale/nb/LC_MESSAGES/django.mo
django/contrib/humanize/locale/nb/LC_MESSAGES/django.po
django/contrib/humanize/locale/ne/LC_MESSAGES/django.mo
django/contrib/humanize/locale/ne/LC_MESSAGES/django.po
django/contrib/humanize/locale/nl/LC_MESSAGES/django.mo
django/contrib/humanize/locale/nl/LC_MESSAGES/django.po
django/contrib/humanize/locale/nn/LC_MESSAGES/django.mo
django/contrib/humanize/locale/nn/LC_MESSAGES/django.po
django/contrib/humanize/locale/os/LC_MESSAGES/django.mo
django/contrib/humanize/locale/os/LC_MESSAGES/django.po
django/contrib/humanize/locale/pa/LC_MESSAGES/django.mo
django/contrib/humanize/locale/pa/LC_MESSAGES/django.po
django/contrib/humanize/locale/pl/LC_MESSAGES/django.mo
django/contrib/humanize/locale/pl/LC_MESSAGES/django.po
django/contrib/humanize/locale/pt/LC_MESSAGES/django.mo
django/contrib/humanize/locale/pt/LC_MESSAGES/django.po
django/contrib/humanize/locale/pt_BR/LC_MESSAGES/django.mo
django/contrib/humanize/locale/pt_BR/LC_MESSAGES/django.po
django/contrib/humanize/locale/ro/LC_MESSAGES/django.mo
django/contrib/humanize/locale/ro/LC_MESSAGES/django.po
django/contrib/humanize/locale/ru/LC_MESSAGES/django.mo
django/contrib/humanize/locale/ru/LC_MESSAGES/django.po
django/contrib/humanize/locale/sk/LC_MESSAGES/django.mo
django/contrib/humanize/locale/sk/LC_MESSAGES/django.po
django/contrib/humanize/locale/sl/LC_MESSAGES/django.mo
django/contrib/humanize/locale/sl/LC_MESSAGES/django.po
django/contrib/humanize/locale/sq/LC_MESSAGES/django.mo
django/contrib/humanize/locale/sq/LC_MESSAGES/django.po
django/contrib/humanize/locale/sr/LC_MESSAGES/django.mo
django/contrib/humanize/locale/sr/LC_MESSAGES/django.po
django/contrib/humanize/locale/sr_Latn/LC_MESSAGES/django.mo
django/contrib/humanize/locale/sr_Latn/LC_MESSAGES/django.po
django/contrib/humanize/locale/sv/LC_MESSAGES/django.mo
django/contrib/humanize/locale/sv/LC_MESSAGES/django.po
django/contrib/humanize/locale/sw/LC_MESSAGES/django.mo
django/contrib/humanize/locale/sw/LC_MESSAGES/django.po
django/contrib/humanize/locale/ta/LC_MESSAGES/django.mo
django/contrib/humanize/locale/ta/LC_MESSAGES/django.po
django/contrib/humanize/locale/te/LC_MESSAGES/django.mo
django/contrib/humanize/locale/te/LC_MESSAGES/django.po
django/contrib/humanize/locale/th/LC_MESSAGES/django.mo
django/contrib/humanize/locale/th/LC_MESSAGES/django.po
django/contrib/humanize/locale/tr/LC_MESSAGES/django.mo
django/contrib/humanize/locale/tr/LC_MESSAGES/django.po
django/contrib/humanize/locale/tt/LC_MESSAGES/django.mo
django/contrib/humanize/locale/tt/LC_MESSAGES/django.po
django/contrib/humanize/locale/udm/LC_MESSAGES/django.mo
django/contrib/humanize/locale/udm/LC_MESSAGES/django.po
django/contrib/humanize/locale/uk/LC_MESSAGES/django.mo
django/contrib/humanize/locale/uk/LC_MESSAGES/django.po
django/contrib/humanize/locale/ur/LC_MESSAGES/django.mo
django/contrib/humanize/locale/ur/LC_MESSAGES/django.po
django/contrib/humanize/locale/vi/LC_MESSAGES/django.mo
django/contrib/humanize/locale/vi/LC_MESSAGES/django.po
django/contrib/humanize/locale/zh_Hans/LC_MESSAGES/django.mo
django/contrib/humanize/locale/zh_Hans/LC_MESSAGES/django.po
django/contrib/humanize/locale/zh_Hant/LC_MESSAGES/django.mo
django/contrib/humanize/locale/zh_Hant/LC_MESSAGES/django.po
django/contrib/humanize/templatetags/__init__.py
django/contrib/humanize/templatetags/humanize.py
django/contrib/messages/__init__.py
django/contrib/messages/api.py
django/contrib/messages/apps.py
django/contrib/messages/constants.py
django/contrib/messages/context_processors.py
django/contrib/messages/middleware.py
django/contrib/messages/utils.py
django/contrib/messages/views.py
django/contrib/messages/storage/__init__.py
django/contrib/messages/storage/base.py
django/contrib/messages/storage/cookie.py
django/contrib/messages/storage/fallback.py
django/contrib/messages/storage/session.py
django/contrib/postgres/__init__.py
django/contrib/postgres/apps.py
django/contrib/postgres/functions.py
django/contrib/postgres/indexes.py
django/contrib/postgres/lookups.py
django/contrib/postgres/operations.py
django/contrib/postgres/search.py
django/contrib/postgres/signals.py
django/contrib/postgres/utils.py
django/contrib/postgres/validators.py
django/contrib/postgres/aggregates/__init__.py
django/contrib/postgres/aggregates/general.py
django/contrib/postgres/aggregates/statistics.py
django/contrib/postgres/fields/__init__.py
django/contrib/postgres/fields/array.py
django/contrib/postgres/fields/citext.py
django/contrib/postgres/fields/hstore.py
django/contrib/postgres/fields/jsonb.py
django/contrib/postgres/fields/ranges.py
django/contrib/postgres/fields/utils.py
django/contrib/postgres/forms/__init__.py
django/contrib/postgres/forms/array.py
django/contrib/postgres/forms/hstore.py
django/contrib/postgres/forms/jsonb.py
django/contrib/postgres/forms/ranges.py
django/contrib/postgres/jinja2/postgres/widgets/split_array.html
django/contrib/postgres/locale/ar/LC_MESSAGES/django.mo
django/contrib/postgres/locale/ar/LC_MESSAGES/django.po
django/contrib/postgres/locale/be/LC_MESSAGES/django.mo
django/contrib/postgres/locale/be/LC_MESSAGES/django.po
django/contrib/postgres/locale/bg/LC_MESSAGES/django.mo
django/contrib/postgres/locale/bg/LC_MESSAGES/django.po
django/contrib/postgres/locale/ca/LC_MESSAGES/django.mo
django/contrib/postgres/locale/ca/LC_MESSAGES/django.po
django/contrib/postgres/locale/cs/LC_MESSAGES/django.mo
django/contrib/postgres/locale/cs/LC_MESSAGES/django.po
django/contrib/postgres/locale/da/LC_MESSAGES/django.mo
django/contrib/postgres/locale/da/LC_MESSAGES/django.po
django/contrib/postgres/locale/de/LC_MESSAGES/django.mo
django/contrib/postgres/locale/de/LC_MESSAGES/django.po
django/contrib/postgres/locale/dsb/LC_MESSAGES/django.mo
django/contrib/postgres/locale/dsb/LC_MESSAGES/django.po
django/contrib/postgres/locale/el/LC_MESSAGES/django.mo
django/contrib/postgres/locale/el/LC_MESSAGES/django.po
django/contrib/postgres/locale/en/LC_MESSAGES/django.mo
django/contrib/postgres/locale/en/LC_MESSAGES/django.po
django/contrib/postgres/locale/eo/LC_MESSAGES/django.mo
django/contrib/postgres/locale/eo/LC_MESSAGES/django.po
django/contrib/postgres/locale/es/LC_MESSAGES/django.mo
django/contrib/postgres/locale/es/LC_MESSAGES/django.po
django/contrib/postgres/locale/es_AR/LC_MESSAGES/django.mo
django/contrib/postgres/locale/es_AR/LC_MESSAGES/django.po
django/contrib/postgres/locale/es_CO/LC_MESSAGES/django.mo
django/contrib/postgres/locale/es_CO/LC_MESSAGES/django.po
django/contrib/postgres/locale/es_MX/LC_MESSAGES/django.mo
django/contrib/postgres/locale/es_MX/LC_MESSAGES/django.po
django/contrib/postgres/locale/et/LC_MESSAGES/django.mo
django/contrib/postgres/locale/et/LC_MESSAGES/django.po
django/contrib/postgres/locale/eu/LC_MESSAGES/django.mo
django/contrib/postgres/locale/eu/LC_MESSAGES/django.po
django/contrib/postgres/locale/fa/LC_MESSAGES/django.mo
django/contrib/postgres/locale/fa/LC_MESSAGES/django.po
django/contrib/postgres/locale/fi/LC_MESSAGES/django.mo
django/contrib/postgres/locale/fi/LC_MESSAGES/django.po
django/contrib/postgres/locale/fr/LC_MESSAGES/django.mo
django/contrib/postgres/locale/fr/LC_MESSAGES/django.po
django/contrib/postgres/locale/gd/LC_MESSAGES/django.mo
django/contrib/postgres/locale/gd/LC_MESSAGES/django.po
django/contrib/postgres/locale/gl/LC_MESSAGES/django.mo
django/contrib/postgres/locale/gl/LC_MESSAGES/django.po
django/contrib/postgres/locale/he/LC_MESSAGES/django.mo
django/contrib/postgres/locale/he/LC_MESSAGES/django.po
django/contrib/postgres/locale/hr/LC_MESSAGES/django.mo
django/contrib/postgres/locale/hr/LC_MESSAGES/django.po
django/contrib/postgres/locale/hsb/LC_MESSAGES/django.mo
django/contrib/postgres/locale/hsb/LC_MESSAGES/django.po
django/contrib/postgres/locale/hu/LC_MESSAGES/django.mo
django/contrib/postgres/locale/hu/LC_MESSAGES/django.po
django/contrib/postgres/locale/ia/LC_MESSAGES/django.mo
django/contrib/postgres/locale/ia/LC_MESSAGES/django.po
django/contrib/postgres/locale/id/LC_MESSAGES/django.mo
django/contrib/postgres/locale/id/LC_MESSAGES/django.po
django/contrib/postgres/locale/is/LC_MESSAGES/django.mo
django/contrib/postgres/locale/is/LC_MESSAGES/django.po
django/contrib/postgres/locale/it/LC_MESSAGES/django.mo
django/contrib/postgres/locale/it/LC_MESSAGES/django.po
django/contrib/postgres/locale/ja/LC_MESSAGES/django.mo
django/contrib/postgres/locale/ja/LC_MESSAGES/django.po
django/contrib/postgres/locale/ka/LC_MESSAGES/django.mo
django/contrib/postgres/locale/ka/LC_MESSAGES/django.po
django/contrib/postgres/locale/kk/LC_MESSAGES/django.mo
django/contrib/postgres/locale/kk/LC_MESSAGES/django.po
django/contrib/postgres/locale/ko/LC_MESSAGES/django.mo
django/contrib/postgres/locale/ko/LC_MESSAGES/django.po
django/contrib/postgres/locale/lt/LC_MESSAGES/django.mo
django/contrib/postgres/locale/lt/LC_MESSAGES/django.po
django/contrib/postgres/locale/lv/LC_MESSAGES/django.mo
django/contrib/postgres/locale/lv/LC_MESSAGES/django.po
django/contrib/postgres/locale/mk/LC_MESSAGES/django.mo
django/contrib/postgres/locale/mk/LC_MESSAGES/django.po
django/contrib/postgres/locale/mn/LC_MESSAGES/django.mo
django/contrib/postgres/locale/mn/LC_MESSAGES/django.po
django/contrib/postgres/locale/nb/LC_MESSAGES/django.mo
django/contrib/postgres/locale/nb/LC_MESSAGES/django.po
django/contrib/postgres/locale/ne/LC_MESSAGES/django.mo
django/contrib/postgres/locale/ne/LC_MESSAGES/django.po
django/contrib/postgres/locale/nl/LC_MESSAGES/django.mo
django/contrib/postgres/locale/nl/LC_MESSAGES/django.po
django/contrib/postgres/locale/pl/LC_MESSAGES/django.mo
django/contrib/postgres/locale/pl/LC_MESSAGES/django.po
django/contrib/postgres/locale/pt/LC_MESSAGES/django.mo
django/contrib/postgres/locale/pt/LC_MESSAGES/django.po
django/contrib/postgres/locale/pt_BR/LC_MESSAGES/django.mo
django/contrib/postgres/locale/pt_BR/LC_MESSAGES/django.po
django/contrib/postgres/locale/ro/LC_MESSAGES/django.mo
django/contrib/postgres/locale/ro/LC_MESSAGES/django.po
django/contrib/postgres/locale/ru/LC_MESSAGES/django.mo
django/contrib/postgres/locale/ru/LC_MESSAGES/django.po
django/contrib/postgres/locale/sl/LC_MESSAGES/django.mo
django/contrib/postgres/locale/sl/LC_MESSAGES/django.po
django/contrib/postgres/locale/sq/LC_MESSAGES/django.mo
django/contrib/postgres/locale/sq/LC_MESSAGES/django.po
django/contrib/postgres/locale/sv/LC_MESSAGES/django.mo
django/contrib/postgres/locale/sv/LC_MESSAGES/django.po
django/contrib/postgres/locale/tr/LC_MESSAGES/django.mo
django/contrib/postgres/locale/tr/LC_MESSAGES/django.po
django/contrib/postgres/locale/uk/LC_MESSAGES/django.mo
django/contrib/postgres/locale/uk/LC_MESSAGES/django.po
django/contrib/postgres/locale/zh_Hans/LC_MESSAGES/django.mo
django/contrib/postgres/locale/zh_Hans/LC_MESSAGES/django.po
django/contrib/postgres/locale/zh_Hant/LC_MESSAGES/django.mo
django/contrib/postgres/locale/zh_Hant/LC_MESSAGES/django.po
django/contrib/postgres/templates/postgres/widgets/split_array.html
django/contrib/redirects/__init__.py
django/contrib/redirects/admin.py
django/contrib/redirects/apps.py
django/contrib/redirects/middleware.py
django/contrib/redirects/models.py
django/contrib/redirects/locale/af/LC_MESSAGES/django.mo
django/contrib/redirects/locale/af/LC_MESSAGES/django.po
django/contrib/redirects/locale/ar/LC_MESSAGES/django.mo
django/contrib/redirects/locale/ar/LC_MESSAGES/django.po
django/contrib/redirects/locale/ast/LC_MESSAGES/django.mo
django/contrib/redirects/locale/ast/LC_MESSAGES/django.po
django/contrib/redirects/locale/az/LC_MESSAGES/django.mo
django/contrib/redirects/locale/az/LC_MESSAGES/django.po
django/contrib/redirects/locale/be/LC_MESSAGES/django.mo
django/contrib/redirects/locale/be/LC_MESSAGES/django.po
django/contrib/redirects/locale/bg/LC_MESSAGES/django.mo
django/contrib/redirects/locale/bg/LC_MESSAGES/django.po
django/contrib/redirects/locale/bn/LC_MESSAGES/django.mo
django/contrib/redirects/locale/bn/LC_MESSAGES/django.po
django/contrib/redirects/locale/br/LC_MESSAGES/django.mo
django/contrib/redirects/locale/br/LC_MESSAGES/django.po
django/contrib/redirects/locale/bs/LC_MESSAGES/django.mo
django/contrib/redirects/locale/bs/LC_MESSAGES/django.po
django/contrib/redirects/locale/ca/LC_MESSAGES/django.mo
django/contrib/redirects/locale/ca/LC_MESSAGES/django.po
django/contrib/redirects/locale/cs/LC_MESSAGES/django.mo
django/contrib/redirects/locale/cs/LC_MESSAGES/django.po
django/contrib/redirects/locale/cy/LC_MESSAGES/django.mo
django/contrib/redirects/locale/cy/LC_MESSAGES/django.po
django/contrib/redirects/locale/da/LC_MESSAGES/django.mo
django/contrib/redirects/locale/da/LC_MESSAGES/django.po
django/contrib/redirects/locale/de/LC_MESSAGES/django.mo
django/contrib/redirects/locale/de/LC_MESSAGES/django.po
django/contrib/redirects/locale/dsb/LC_MESSAGES/django.mo
django/contrib/redirects/locale/dsb/LC_MESSAGES/django.po
django/contrib/redirects/locale/el/LC_MESSAGES/django.mo
django/contrib/redirects/locale/el/LC_MESSAGES/django.po
django/contrib/redirects/locale/en/LC_MESSAGES/django.mo
django/contrib/redirects/locale/en/LC_MESSAGES/django.po
django/contrib/redirects/locale/en_AU/LC_MESSAGES/django.mo
django/contrib/redirects/locale/en_AU/LC_MESSAGES/django.po
django/contrib/redirects/locale/en_GB/LC_MESSAGES/django.mo
django/contrib/redirects/locale/en_GB/LC_MESSAGES/django.po
django/contrib/redirects/locale/eo/LC_MESSAGES/django.mo
django/contrib/redirects/locale/eo/LC_MESSAGES/django.po
django/contrib/redirects/locale/es/LC_MESSAGES/django.mo
django/contrib/redirects/locale/es/LC_MESSAGES/django.po
django/contrib/redirects/locale/es_AR/LC_MESSAGES/django.mo
django/contrib/redirects/locale/es_AR/LC_MESSAGES/django.po
django/contrib/redirects/locale/es_CO/LC_MESSAGES/django.mo
django/contrib/redirects/locale/es_CO/LC_MESSAGES/django.po
django/contrib/redirects/locale/es_MX/LC_MESSAGES/django.mo
django/contrib/redirects/locale/es_MX/LC_MESSAGES/django.po
django/contrib/redirects/locale/es_VE/LC_MESSAGES/django.mo
django/contrib/redirects/locale/es_VE/LC_MESSAGES/django.po
django/contrib/redirects/locale/et/LC_MESSAGES/django.mo
django/contrib/redirects/locale/et/LC_MESSAGES/django.po
django/contrib/redirects/locale/eu/LC_MESSAGES/django.mo
django/contrib/redirects/locale/eu/LC_MESSAGES/django.po
django/contrib/redirects/locale/fa/LC_MESSAGES/django.mo
django/contrib/redirects/locale/fa/LC_MESSAGES/django.po
django/contrib/redirects/locale/fi/LC_MESSAGES/django.mo
django/contrib/redirects/locale/fi/LC_MESSAGES/django.po
django/contrib/redirects/locale/fr/LC_MESSAGES/django.mo
django/contrib/redirects/locale/fr/LC_MESSAGES/django.po
django/contrib/redirects/locale/fy/LC_MESSAGES/django.mo
django/contrib/redirects/locale/fy/LC_MESSAGES/django.po
django/contrib/redirects/locale/ga/LC_MESSAGES/django.mo
django/contrib/redirects/locale/ga/LC_MESSAGES/django.po
django/contrib/redirects/locale/gd/LC_MESSAGES/django.mo
django/contrib/redirects/locale/gd/LC_MESSAGES/django.po
django/contrib/redirects/locale/gl/LC_MESSAGES/django.mo
django/contrib/redirects/locale/gl/LC_MESSAGES/django.po
django/contrib/redirects/locale/he/LC_MESSAGES/django.mo
django/contrib/redirects/locale/he/LC_MESSAGES/django.po
django/contrib/redirects/locale/hi/LC_MESSAGES/django.mo
django/contrib/redirects/locale/hi/LC_MESSAGES/django.po
django/contrib/redirects/locale/hr/LC_MESSAGES/django.mo
django/contrib/redirects/locale/hr/LC_MESSAGES/django.po
django/contrib/redirects/locale/hsb/LC_MESSAGES/django.mo
django/contrib/redirects/locale/hsb/LC_MESSAGES/django.po
django/contrib/redirects/locale/hu/LC_MESSAGES/django.mo
django/contrib/redirects/locale/hu/LC_MESSAGES/django.po
django/contrib/redirects/locale/ia/LC_MESSAGES/django.mo
django/contrib/redirects/locale/ia/LC_MESSAGES/django.po
django/contrib/redirects/locale/id/LC_MESSAGES/django.mo
django/contrib/redirects/locale/id/LC_MESSAGES/django.po
django/contrib/redirects/locale/io/LC_MESSAGES/django.mo
django/contrib/redirects/locale/io/LC_MESSAGES/django.po
django/contrib/redirects/locale/is/LC_MESSAGES/django.mo
django/contrib/redirects/locale/is/LC_MESSAGES/django.po
django/contrib/redirects/locale/it/LC_MESSAGES/django.mo
django/contrib/redirects/locale/it/LC_MESSAGES/django.po
django/contrib/redirects/locale/ja/LC_MESSAGES/django.mo
django/contrib/redirects/locale/ja/LC_MESSAGES/django.po
django/contrib/redirects/locale/ka/LC_MESSAGES/django.mo
django/contrib/redirects/locale/ka/LC_MESSAGES/django.po
django/contrib/redirects/locale/kk/LC_MESSAGES/django.mo
django/contrib/redirects/locale/kk/LC_MESSAGES/django.po
django/contrib/redirects/locale/km/LC_MESSAGES/django.mo
django/contrib/redirects/locale/km/LC_MESSAGES/django.po
django/contrib/redirects/locale/kn/LC_MESSAGES/django.mo
django/contrib/redirects/locale/kn/LC_MESSAGES/django.po
django/contrib/redirects/locale/ko/LC_MESSAGES/django.mo
django/contrib/redirects/locale/ko/LC_MESSAGES/django.po
django/contrib/redirects/locale/lb/LC_MESSAGES/django.mo
django/contrib/redirects/locale/lb/LC_MESSAGES/django.po
django/contrib/redirects/locale/lt/LC_MESSAGES/django.mo
django/contrib/redirects/locale/lt/LC_MESSAGES/django.po
django/contrib/redirects/locale/lv/LC_MESSAGES/django.mo
django/contrib/redirects/locale/lv/LC_MESSAGES/django.po
django/contrib/redirects/locale/mk/LC_MESSAGES/django.mo
django/contrib/redirects/locale/mk/LC_MESSAGES/django.po
django/contrib/redirects/locale/ml/LC_MESSAGES/django.mo
django/contrib/redirects/locale/ml/LC_MESSAGES/django.po
django/contrib/redirects/locale/mn/LC_MESSAGES/django.mo
django/contrib/redirects/locale/mn/LC_MESSAGES/django.po
django/contrib/redirects/locale/mr/LC_MESSAGES/django.mo
django/contrib/redirects/locale/mr/LC_MESSAGES/django.po
django/contrib/redirects/locale/my/LC_MESSAGES/django.mo
django/contrib/redirects/locale/my/LC_MESSAGES/django.po
django/contrib/redirects/locale/nb/LC_MESSAGES/django.mo
django/contrib/redirects/locale/nb/LC_MESSAGES/django.po
django/contrib/redirects/locale/ne/LC_MESSAGES/django.mo
django/contrib/redirects/locale/ne/LC_MESSAGES/django.po
django/contrib/redirects/locale/nl/LC_MESSAGES/django.mo
django/contrib/redirects/locale/nl/LC_MESSAGES/django.po
django/contrib/redirects/locale/nn/LC_MESSAGES/django.mo
django/contrib/redirects/locale/nn/LC_MESSAGES/django.po
django/contrib/redirects/locale/os/LC_MESSAGES/django.mo
django/contrib/redirects/locale/os/LC_MESSAGES/django.po
django/contrib/redirects/locale/pa/LC_MESSAGES/django.mo
django/contrib/redirects/locale/pa/LC_MESSAGES/django.po
django/contrib/redirects/locale/pl/LC_MESSAGES/django.mo
django/contrib/redirects/locale/pl/LC_MESSAGES/django.po
django/contrib/redirects/locale/pt/LC_MESSAGES/django.mo
django/contrib/redirects/locale/pt/LC_MESSAGES/django.po
django/contrib/redirects/locale/pt_BR/LC_MESSAGES/django.mo
django/contrib/redirects/locale/pt_BR/LC_MESSAGES/django.po
django/contrib/redirects/locale/ro/LC_MESSAGES/django.mo
django/contrib/redirects/locale/ro/LC_MESSAGES/django.po
django/contrib/redirects/locale/ru/LC_MESSAGES/django.mo
django/contrib/redirects/locale/ru/LC_MESSAGES/django.po
django/contrib/redirects/locale/sk/LC_MESSAGES/django.mo
django/contrib/redirects/locale/sk/LC_MESSAGES/django.po
django/contrib/redirects/locale/sl/LC_MESSAGES/django.mo
django/contrib/redirects/locale/sl/LC_MESSAGES/django.po
django/contrib/redirects/locale/sq/LC_MESSAGES/django.mo
django/contrib/redirects/locale/sq/LC_MESSAGES/django.po
django/contrib/redirects/locale/sr/LC_MESSAGES/django.mo
django/contrib/redirects/locale/sr/LC_MESSAGES/django.po
django/contrib/redirects/locale/sr_Latn/LC_MESSAGES/django.mo
django/contrib/redirects/locale/sr_Latn/LC_MESSAGES/django.po
django/contrib/redirects/locale/sv/LC_MESSAGES/django.mo
django/contrib/redirects/locale/sv/LC_MESSAGES/django.po
django/contrib/redirects/locale/sw/LC_MESSAGES/django.mo
django/contrib/redirects/locale/sw/LC_MESSAGES/django.po
django/contrib/redirects/locale/ta/LC_MESSAGES/django.mo
django/contrib/redirects/locale/ta/LC_MESSAGES/django.po
django/contrib/redirects/locale/te/LC_MESSAGES/django.mo
django/contrib/redirects/locale/te/LC_MESSAGES/django.po
django/contrib/redirects/locale/th/LC_MESSAGES/django.mo
django/contrib/redirects/locale/th/LC_MESSAGES/django.po
django/contrib/redirects/locale/tr/LC_MESSAGES/django.mo
django/contrib/redirects/locale/tr/LC_MESSAGES/django.po
django/contrib/redirects/locale/tt/LC_MESSAGES/django.mo
django/contrib/redirects/locale/tt/LC_MESSAGES/django.po
django/contrib/redirects/locale/udm/LC_MESSAGES/django.mo
django/contrib/redirects/locale/udm/LC_MESSAGES/django.po
django/contrib/redirects/locale/uk/LC_MESSAGES/django.mo
django/contrib/redirects/locale/uk/LC_MESSAGES/django.po
django/contrib/redirects/locale/ur/LC_MESSAGES/django.mo
django/contrib/redirects/locale/ur/LC_MESSAGES/django.po
django/contrib/redirects/locale/vi/LC_MESSAGES/django.mo
django/contrib/redirects/locale/vi/LC_MESSAGES/django.po
django/contrib/redirects/locale/zh_Hans/LC_MESSAGES/django.mo
django/contrib/redirects/locale/zh_Hans/LC_MESSAGES/django.po
django/contrib/redirects/locale/zh_Hant/LC_MESSAGES/django.mo
django/contrib/redirects/locale/zh_Hant/LC_MESSAGES/django.po
django/contrib/redirects/migrations/0001_initial.py
django/contrib/redirects/migrations/__init__.py
django/contrib/sessions/__init__.py
django/contrib/sessions/apps.py
django/contrib/sessions/base_session.py
django/contrib/sessions/exceptions.py
django/contrib/sessions/middleware.py
django/contrib/sessions/models.py
django/contrib/sessions/serializers.py
django/contrib/sessions/backends/__init__.py
django/contrib/sessions/backends/base.py
django/contrib/sessions/backends/cache.py
django/contrib/sessions/backends/cached_db.py
django/contrib/sessions/backends/db.py
django/contrib/sessions/backends/file.py
django/contrib/sessions/backends/signed_cookies.py
django/contrib/sessions/locale/af/LC_MESSAGES/django.mo
django/contrib/sessions/locale/af/LC_MESSAGES/django.po
django/contrib/sessions/locale/ar/LC_MESSAGES/django.mo
django/contrib/sessions/locale/ar/LC_MESSAGES/django.po
django/contrib/sessions/locale/ast/LC_MESSAGES/django.mo
django/contrib/sessions/locale/ast/LC_MESSAGES/django.po
django/contrib/sessions/locale/az/LC_MESSAGES/django.mo
django/contrib/sessions/locale/az/LC_MESSAGES/django.po
django/contrib/sessions/locale/be/LC_MESSAGES/django.mo
django/contrib/sessions/locale/be/LC_MESSAGES/django.po
django/contrib/sessions/locale/bg/LC_MESSAGES/django.mo
django/contrib/sessions/locale/bg/LC_MESSAGES/django.po
django/contrib/sessions/locale/bn/LC_MESSAGES/django.mo
django/contrib/sessions/locale/bn/LC_MESSAGES/django.po
django/contrib/sessions/locale/br/LC_MESSAGES/django.mo
django/contrib/sessions/locale/br/LC_MESSAGES/django.po
django/contrib/sessions/locale/bs/LC_MESSAGES/django.mo
django/contrib/sessions/locale/bs/LC_MESSAGES/django.po
django/contrib/sessions/locale/ca/LC_MESSAGES/django.mo
django/contrib/sessions/locale/ca/LC_MESSAGES/django.po
django/contrib/sessions/locale/cs/LC_MESSAGES/django.mo
django/contrib/sessions/locale/cs/LC_MESSAGES/django.po
django/contrib/sessions/locale/cy/LC_MESSAGES/django.mo
django/contrib/sessions/locale/cy/LC_MESSAGES/django.po
django/contrib/sessions/locale/da/LC_MESSAGES/django.mo
django/contrib/sessions/locale/da/LC_MESSAGES/django.po
django/contrib/sessions/locale/de/LC_MESSAGES/django.mo
django/contrib/sessions/locale/de/LC_MESSAGES/django.po
django/contrib/sessions/locale/dsb/LC_MESSAGES/django.mo
django/contrib/sessions/locale/dsb/LC_MESSAGES/django.po
django/contrib/sessions/locale/el/LC_MESSAGES/django.mo
django/contrib/sessions/locale/el/LC_MESSAGES/django.po
django/contrib/sessions/locale/en/LC_MESSAGES/django.mo
django/contrib/sessions/locale/en/LC_MESSAGES/django.po
django/contrib/sessions/locale/en_AU/LC_MESSAGES/django.mo
django/contrib/sessions/locale/en_AU/LC_MESSAGES/django.po
django/contrib/sessions/locale/en_GB/LC_MESSAGES/django.mo
django/contrib/sessions/locale/en_GB/LC_MESSAGES/django.po
django/contrib/sessions/locale/eo/LC_MESSAGES/django.mo
django/contrib/sessions/locale/eo/LC_MESSAGES/django.po
django/contrib/sessions/locale/es/LC_MESSAGES/django.mo
django/contrib/sessions/locale/es/LC_MESSAGES/django.po
django/contrib/sessions/locale/es_AR/LC_MESSAGES/django.mo
django/contrib/sessions/locale/es_AR/LC_MESSAGES/django.po
django/contrib/sessions/locale/es_CO/LC_MESSAGES/django.mo
django/contrib/sessions/locale/es_CO/LC_MESSAGES/django.po
django/contrib/sessions/locale/es_MX/LC_MESSAGES/django.mo
django/contrib/sessions/locale/es_MX/LC_MESSAGES/django.po
django/contrib/sessions/locale/es_VE/LC_MESSAGES/django.mo
django/contrib/sessions/locale/es_VE/LC_MESSAGES/django.po
django/contrib/sessions/locale/et/LC_MESSAGES/django.mo
django/contrib/sessions/locale/et/LC_MESSAGES/django.po
django/contrib/sessions/locale/eu/LC_MESSAGES/django.mo
django/contrib/sessions/locale/eu/LC_MESSAGES/django.po
django/contrib/sessions/locale/fa/LC_MESSAGES/django.mo
django/contrib/sessions/locale/fa/LC_MESSAGES/django.po
django/contrib/sessions/locale/fi/LC_MESSAGES/django.mo
django/contrib/sessions/locale/fi/LC_MESSAGES/django.po
django/contrib/sessions/locale/fr/LC_MESSAGES/django.mo
django/contrib/sessions/locale/fr/LC_MESSAGES/django.po
django/contrib/sessions/locale/fy/LC_MESSAGES/django.mo
django/contrib/sessions/locale/fy/LC_MESSAGES/django.po
django/contrib/sessions/locale/ga/LC_MESSAGES/django.mo
django/contrib/sessions/locale/ga/LC_MESSAGES/django.po
django/contrib/sessions/locale/gd/LC_MESSAGES/django.mo
django/contrib/sessions/locale/gd/LC_MESSAGES/django.po
django/contrib/sessions/locale/gl/LC_MESSAGES/django.mo
django/contrib/sessions/locale/gl/LC_MESSAGES/django.po
django/contrib/sessions/locale/he/LC_MESSAGES/django.mo
django/contrib/sessions/locale/he/LC_MESSAGES/django.po
django/contrib/sessions/locale/hi/LC_MESSAGES/django.mo
django/contrib/sessions/locale/hi/LC_MESSAGES/django.po
django/contrib/sessions/locale/hr/LC_MESSAGES/django.mo
django/contrib/sessions/locale/hr/LC_MESSAGES/django.po
django/contrib/sessions/locale/hsb/LC_MESSAGES/django.mo
django/contrib/sessions/locale/hsb/LC_MESSAGES/django.po
django/contrib/sessions/locale/hu/LC_MESSAGES/django.mo
django/contrib/sessions/locale/hu/LC_MESSAGES/django.po
django/contrib/sessions/locale/ia/LC_MESSAGES/django.mo
django/contrib/sessions/locale/ia/LC_MESSAGES/django.po
django/contrib/sessions/locale/id/LC_MESSAGES/django.mo
django/contrib/sessions/locale/id/LC_MESSAGES/django.po
django/contrib/sessions/locale/io/LC_MESSAGES/django.mo
django/contrib/sessions/locale/io/LC_MESSAGES/django.po
django/contrib/sessions/locale/is/LC_MESSAGES/django.mo
django/contrib/sessions/locale/is/LC_MESSAGES/django.po
django/contrib/sessions/locale/it/LC_MESSAGES/django.mo
django/contrib/sessions/locale/it/LC_MESSAGES/django.po
django/contrib/sessions/locale/ja/LC_MESSAGES/django.mo
django/contrib/sessions/locale/ja/LC_MESSAGES/django.po
django/contrib/sessions/locale/ka/LC_MESSAGES/django.mo
django/contrib/sessions/locale/ka/LC_MESSAGES/django.po
django/contrib/sessions/locale/kk/LC_MESSAGES/django.mo
django/contrib/sessions/locale/kk/LC_MESSAGES/django.po
django/contrib/sessions/locale/km/LC_MESSAGES/django.mo
django/contrib/sessions/locale/km/LC_MESSAGES/django.po
django/contrib/sessions/locale/kn/LC_MESSAGES/django.mo
django/contrib/sessions/locale/kn/LC_MESSAGES/django.po
django/contrib/sessions/locale/ko/LC_MESSAGES/django.mo
django/contrib/sessions/locale/ko/LC_MESSAGES/django.po
django/contrib/sessions/locale/lb/LC_MESSAGES/django.mo
django/contrib/sessions/locale/lb/LC_MESSAGES/django.po
django/contrib/sessions/locale/lt/LC_MESSAGES/django.mo
django/contrib/sessions/locale/lt/LC_MESSAGES/django.po
django/contrib/sessions/locale/lv/LC_MESSAGES/django.mo
django/contrib/sessions/locale/lv/LC_MESSAGES/django.po
django/contrib/sessions/locale/mk/LC_MESSAGES/django.mo
django/contrib/sessions/locale/mk/LC_MESSAGES/django.po
django/contrib/sessions/locale/ml/LC_MESSAGES/django.mo
django/contrib/sessions/locale/ml/LC_MESSAGES/django.po
django/contrib/sessions/locale/mn/LC_MESSAGES/django.mo
django/contrib/sessions/locale/mn/LC_MESSAGES/django.po
django/contrib/sessions/locale/mr/LC_MESSAGES/django.mo
django/contrib/sessions/locale/mr/LC_MESSAGES/django.po
django/contrib/sessions/locale/my/LC_MESSAGES/django.mo
django/contrib/sessions/locale/my/LC_MESSAGES/django.po
django/contrib/sessions/locale/nb/LC_MESSAGES/django.mo
django/contrib/sessions/locale/nb/LC_MESSAGES/django.po
django/contrib/sessions/locale/ne/LC_MESSAGES/django.mo
django/contrib/sessions/locale/ne/LC_MESSAGES/django.po
django/contrib/sessions/locale/nl/LC_MESSAGES/django.mo
django/contrib/sessions/locale/nl/LC_MESSAGES/django.po
django/contrib/sessions/locale/nn/LC_MESSAGES/django.mo
django/contrib/sessions/locale/nn/LC_MESSAGES/django.po
django/contrib/sessions/locale/os/LC_MESSAGES/django.mo
django/contrib/sessions/locale/os/LC_MESSAGES/django.po
django/contrib/sessions/locale/pa/LC_MESSAGES/django.mo
django/contrib/sessions/locale/pa/LC_MESSAGES/django.po
django/contrib/sessions/locale/pl/LC_MESSAGES/django.mo
django/contrib/sessions/locale/pl/LC_MESSAGES/django.po
django/contrib/sessions/locale/pt/LC_MESSAGES/django.mo
django/contrib/sessions/locale/pt/LC_MESSAGES/django.po
django/contrib/sessions/locale/pt_BR/LC_MESSAGES/django.mo
django/contrib/sessions/locale/pt_BR/LC_MESSAGES/django.po
django/contrib/sessions/locale/ro/LC_MESSAGES/django.mo
django/contrib/sessions/locale/ro/LC_MESSAGES/django.po
django/contrib/sessions/locale/ru/LC_MESSAGES/django.mo
django/contrib/sessions/locale/ru/LC_MESSAGES/django.po
django/contrib/sessions/locale/sk/LC_MESSAGES/django.mo
django/contrib/sessions/locale/sk/LC_MESSAGES/django.po
django/contrib/sessions/locale/sl/LC_MESSAGES/django.mo
django/contrib/sessions/locale/sl/LC_MESSAGES/django.po
django/contrib/sessions/locale/sq/LC_MESSAGES/django.mo
django/contrib/sessions/locale/sq/LC_MESSAGES/django.po
django/contrib/sessions/locale/sr/LC_MESSAGES/django.mo
django/contrib/sessions/locale/sr/LC_MESSAGES/django.po
django/contrib/sessions/locale/sr_Latn/LC_MESSAGES/django.mo
django/contrib/sessions/locale/sr_Latn/LC_MESSAGES/django.po
django/contrib/sessions/locale/sv/LC_MESSAGES/django.mo
django/contrib/sessions/locale/sv/LC_MESSAGES/django.po
django/contrib/sessions/locale/sw/LC_MESSAGES/django.mo
django/contrib/sessions/locale/sw/LC_MESSAGES/django.po
django/contrib/sessions/locale/ta/LC_MESSAGES/django.mo
django/contrib/sessions/locale/ta/LC_MESSAGES/django.po
django/contrib/sessions/locale/te/LC_MESSAGES/django.mo
django/contrib/sessions/locale/te/LC_MESSAGES/django.po
django/contrib/sessions/locale/th/LC_MESSAGES/django.mo
django/contrib/sessions/locale/th/LC_MESSAGES/django.po
django/contrib/sessions/locale/tr/LC_MESSAGES/django.mo
django/contrib/sessions/locale/tr/LC_MESSAGES/django.po
django/contrib/sessions/locale/tt/LC_MESSAGES/django.mo
django/contrib/sessions/locale/tt/LC_MESSAGES/django.po
django/contrib/sessions/locale/udm/LC_MESSAGES/django.mo
django/contrib/sessions/locale/udm/LC_MESSAGES/django.po
django/contrib/sessions/locale/uk/LC_MESSAGES/django.mo
django/contrib/sessions/locale/uk/LC_MESSAGES/django.po
django/contrib/sessions/locale/ur/LC_MESSAGES/django.mo
django/contrib/sessions/locale/ur/LC_MESSAGES/django.po
django/contrib/sessions/locale/vi/LC_MESSAGES/django.mo
django/contrib/sessions/locale/vi/LC_MESSAGES/django.po
django/contrib/sessions/locale/zh_Hans/LC_MESSAGES/django.mo
django/contrib/sessions/locale/zh_Hans/LC_MESSAGES/django.po
django/contrib/sessions/locale/zh_Hant/LC_MESSAGES/django.mo
django/contrib/sessions/locale/zh_Hant/LC_MESSAGES/django.po
django/contrib/sessions/management/__init__.py
django/contrib/sessions/management/commands/__init__.py
django/contrib/sessions/management/commands/clearsessions.py
django/contrib/sessions/migrations/0001_initial.py
django/contrib/sessions/migrations/__init__.py
django/contrib/sitemaps/__init__.py
django/contrib/sitemaps/apps.py
django/contrib/sitemaps/views.py
django/contrib/sitemaps/management/__init__.py
django/contrib/sitemaps/management/commands/__init__.py
django/contrib/sitemaps/management/commands/ping_google.py
django/contrib/sitemaps/templates/sitemap.xml
django/contrib/sitemaps/templates/sitemap_index.xml
django/contrib/sites/__init__.py
django/contrib/sites/admin.py
django/contrib/sites/apps.py
django/contrib/sites/management.py
django/contrib/sites/managers.py
django/contrib/sites/middleware.py
django/contrib/sites/models.py
django/contrib/sites/requests.py
django/contrib/sites/shortcuts.py
django/contrib/sites/locale/af/LC_MESSAGES/django.mo
django/contrib/sites/locale/af/LC_MESSAGES/django.po
django/contrib/sites/locale/ar/LC_MESSAGES/django.mo
django/contrib/sites/locale/ar/LC_MESSAGES/django.po
django/contrib/sites/locale/ast/LC_MESSAGES/django.mo
django/contrib/sites/locale/ast/LC_MESSAGES/django.po
django/contrib/sites/locale/az/LC_MESSAGES/django.mo
django/contrib/sites/locale/az/LC_MESSAGES/django.po
django/contrib/sites/locale/be/LC_MESSAGES/django.mo
django/contrib/sites/locale/be/LC_MESSAGES/django.po
django/contrib/sites/locale/bg/LC_MESSAGES/django.mo
django/contrib/sites/locale/bg/LC_MESSAGES/django.po
django/contrib/sites/locale/bn/LC_MESSAGES/django.mo
django/contrib/sites/locale/bn/LC_MESSAGES/django.po
django/contrib/sites/locale/br/LC_MESSAGES/django.mo
django/contrib/sites/locale/br/LC_MESSAGES/django.po
django/contrib/sites/locale/bs/LC_MESSAGES/django.mo
django/contrib/sites/locale/bs/LC_MESSAGES/django.po
django/contrib/sites/locale/ca/LC_MESSAGES/django.mo
django/contrib/sites/locale/ca/LC_MESSAGES/django.po
django/contrib/sites/locale/cs/LC_MESSAGES/django.mo
django/contrib/sites/locale/cs/LC_MESSAGES/django.po
django/contrib/sites/locale/cy/LC_MESSAGES/django.mo
django/contrib/sites/locale/cy/LC_MESSAGES/django.po
django/contrib/sites/locale/da/LC_MESSAGES/django.mo
django/contrib/sites/locale/da/LC_MESSAGES/django.po
django/contrib/sites/locale/de/LC_MESSAGES/django.mo
django/contrib/sites/locale/de/LC_MESSAGES/django.po
django/contrib/sites/locale/dsb/LC_MESSAGES/django.mo
django/contrib/sites/locale/dsb/LC_MESSAGES/django.po
django/contrib/sites/locale/el/LC_MESSAGES/django.mo
django/contrib/sites/locale/el/LC_MESSAGES/django.po
django/contrib/sites/locale/en/LC_MESSAGES/django.mo
django/contrib/sites/locale/en/LC_MESSAGES/django.po
django/contrib/sites/locale/en_AU/LC_MESSAGES/django.mo
django/contrib/sites/locale/en_AU/LC_MESSAGES/django.po
django/contrib/sites/locale/en_GB/LC_MESSAGES/django.mo
django/contrib/sites/locale/en_GB/LC_MESSAGES/django.po
django/contrib/sites/locale/eo/LC_MESSAGES/django.mo
django/contrib/sites/locale/eo/LC_MESSAGES/django.po
django/contrib/sites/locale/es/LC_MESSAGES/django.mo
django/contrib/sites/locale/es/LC_MESSAGES/django.po
django/contrib/sites/locale/es_AR/LC_MESSAGES/django.mo
django/contrib/sites/locale/es_AR/LC_MESSAGES/django.po
django/contrib/sites/locale/es_CO/LC_MESSAGES/django.mo
django/contrib/sites/locale/es_CO/LC_MESSAGES/django.po
django/contrib/sites/locale/es_MX/LC_MESSAGES/django.mo
django/contrib/sites/locale/es_MX/LC_MESSAGES/django.po
django/contrib/sites/locale/es_VE/LC_MESSAGES/django.mo
django/contrib/sites/locale/es_VE/LC_MESSAGES/django.po
django/contrib/sites/locale/et/LC_MESSAGES/django.mo
django/contrib/sites/locale/et/LC_MESSAGES/django.po
django/contrib/sites/locale/eu/LC_MESSAGES/django.mo
django/contrib/sites/locale/eu/LC_MESSAGES/django.po
django/contrib/sites/locale/fa/LC_MESSAGES/django.mo
django/contrib/sites/locale/fa/LC_MESSAGES/django.po
django/contrib/sites/locale/fi/LC_MESSAGES/django.mo
django/contrib/sites/locale/fi/LC_MESSAGES/django.po
django/contrib/sites/locale/fr/LC_MESSAGES/django.mo
django/contrib/sites/locale/fr/LC_MESSAGES/django.po
django/contrib/sites/locale/fy/LC_MESSAGES/django.mo
django/contrib/sites/locale/fy/LC_MESSAGES/django.po
django/contrib/sites/locale/ga/LC_MESSAGES/django.mo
django/contrib/sites/locale/ga/LC_MESSAGES/django.po
django/contrib/sites/locale/gd/LC_MESSAGES/django.mo
django/contrib/sites/locale/gd/LC_MESSAGES/django.po
django/contrib/sites/locale/gl/LC_MESSAGES/django.mo
django/contrib/sites/locale/gl/LC_MESSAGES/django.po
django/contrib/sites/locale/he/LC_MESSAGES/django.mo
django/contrib/sites/locale/he/LC_MESSAGES/django.po
django/contrib/sites/locale/hi/LC_MESSAGES/django.mo
django/contrib/sites/locale/hi/LC_MESSAGES/django.po
django/contrib/sites/locale/hr/LC_MESSAGES/django.mo
django/contrib/sites/locale/hr/LC_MESSAGES/django.po
django/contrib/sites/locale/hsb/LC_MESSAGES/django.mo
django/contrib/sites/locale/hsb/LC_MESSAGES/django.po
django/contrib/sites/locale/hu/LC_MESSAGES/django.mo
django/contrib/sites/locale/hu/LC_MESSAGES/django.po
django/contrib/sites/locale/hy/LC_MESSAGES/django.mo
django/contrib/sites/locale/hy/LC_MESSAGES/django.po
django/contrib/sites/locale/ia/LC_MESSAGES/django.mo
django/contrib/sites/locale/ia/LC_MESSAGES/django.po
django/contrib/sites/locale/id/LC_MESSAGES/django.mo
django/contrib/sites/locale/id/LC_MESSAGES/django.po
django/contrib/sites/locale/io/LC_MESSAGES/django.mo
django/contrib/sites/locale/io/LC_MESSAGES/django.po
django/contrib/sites/locale/is/LC_MESSAGES/django.mo
django/contrib/sites/locale/is/LC_MESSAGES/django.po
django/contrib/sites/locale/it/LC_MESSAGES/django.mo
django/contrib/sites/locale/it/LC_MESSAGES/django.po
django/contrib/sites/locale/ja/LC_MESSAGES/django.mo
django/contrib/sites/locale/ja/LC_MESSAGES/django.po
django/contrib/sites/locale/ka/LC_MESSAGES/django.mo
django/contrib/sites/locale/ka/LC_MESSAGES/django.po
django/contrib/sites/locale/kk/LC_MESSAGES/django.mo
django/contrib/sites/locale/kk/LC_MESSAGES/django.po
django/contrib/sites/locale/km/LC_MESSAGES/django.mo
django/contrib/sites/locale/km/LC_MESSAGES/django.po
django/contrib/sites/locale/kn/LC_MESSAGES/django.mo
django/contrib/sites/locale/kn/LC_MESSAGES/django.po
django/contrib/sites/locale/ko/LC_MESSAGES/django.mo
django/contrib/sites/locale/ko/LC_MESSAGES/django.po
django/contrib/sites/locale/lb/LC_MESSAGES/django.mo
django/contrib/sites/locale/lb/LC_MESSAGES/django.po
django/contrib/sites/locale/lt/LC_MESSAGES/django.mo
django/contrib/sites/locale/lt/LC_MESSAGES/django.po
django/contrib/sites/locale/lv/LC_MESSAGES/django.mo
django/contrib/sites/locale/lv/LC_MESSAGES/django.po
django/contrib/sites/locale/mk/LC_MESSAGES/django.mo
django/contrib/sites/locale/mk/LC_MESSAGES/django.po
django/contrib/sites/locale/ml/LC_MESSAGES/django.mo
django/contrib/sites/locale/ml/LC_MESSAGES/django.po
django/contrib/sites/locale/mn/LC_MESSAGES/django.mo
django/contrib/sites/locale/mn/LC_MESSAGES/django.po
django/contrib/sites/locale/mr/LC_MESSAGES/django.mo
django/contrib/sites/locale/mr/LC_MESSAGES/django.po
django/contrib/sites/locale/my/LC_MESSAGES/django.mo
django/contrib/sites/locale/my/LC_MESSAGES/django.po
django/contrib/sites/locale/nb/LC_MESSAGES/django.mo
django/contrib/sites/locale/nb/LC_MESSAGES/django.po
django/contrib/sites/locale/ne/LC_MESSAGES/django.mo
django/contrib/sites/locale/ne/LC_MESSAGES/django.po
django/contrib/sites/locale/nl/LC_MESSAGES/django.mo
django/contrib/sites/locale/nl/LC_MESSAGES/django.po
django/contrib/sites/locale/nn/LC_MESSAGES/django.mo
django/contrib/sites/locale/nn/LC_MESSAGES/django.po
django/contrib/sites/locale/os/LC_MESSAGES/django.mo
django/contrib/sites/locale/os/LC_MESSAGES/django.po
django/contrib/sites/locale/pa/LC_MESSAGES/django.mo
django/contrib/sites/locale/pa/LC_MESSAGES/django.po
django/contrib/sites/locale/pl/LC_MESSAGES/django.mo
django/contrib/sites/locale/pl/LC_MESSAGES/django.po
django/contrib/sites/locale/pt/LC_MESSAGES/django.mo
django/contrib/sites/locale/pt/LC_MESSAGES/django.po
django/contrib/sites/locale/pt_BR/LC_MESSAGES/django.mo
django/contrib/sites/locale/pt_BR/LC_MESSAGES/django.po
django/contrib/sites/locale/ro/LC_MESSAGES/django.mo
django/contrib/sites/locale/ro/LC_MESSAGES/django.po
django/contrib/sites/locale/ru/LC_MESSAGES/django.mo
django/contrib/sites/locale/ru/LC_MESSAGES/django.po
django/contrib/sites/locale/sk/LC_MESSAGES/django.mo
django/contrib/sites/locale/sk/LC_MESSAGES/django.po
django/contrib/sites/locale/sl/LC_MESSAGES/django.mo
django/contrib/sites/locale/sl/LC_MESSAGES/django.po
django/contrib/sites/locale/sq/LC_MESSAGES/django.mo
django/contrib/sites/locale/sq/LC_MESSAGES/django.po
django/contrib/sites/locale/sr/LC_MESSAGES/django.mo
django/contrib/sites/locale/sr/LC_MESSAGES/django.po
django/contrib/sites/locale/sr_Latn/LC_MESSAGES/django.mo
django/contrib/sites/locale/sr_Latn/LC_MESSAGES/django.po
django/contrib/sites/locale/sv/LC_MESSAGES/django.mo
django/contrib/sites/locale/sv/LC_MESSAGES/django.po
django/contrib/sites/locale/sw/LC_MESSAGES/django.mo
django/contrib/sites/locale/sw/LC_MESSAGES/django.po
django/contrib/sites/locale/ta/LC_MESSAGES/django.mo
django/contrib/sites/locale/ta/LC_MESSAGES/django.po
django/contrib/sites/locale/te/LC_MESSAGES/django.mo
django/contrib/sites/locale/te/LC_MESSAGES/django.po
django/contrib/sites/locale/th/LC_MESSAGES/django.mo
django/contrib/sites/locale/th/LC_MESSAGES/django.po
django/contrib/sites/locale/tr/LC_MESSAGES/django.mo
django/contrib/sites/locale/tr/LC_MESSAGES/django.po
django/contrib/sites/locale/tt/LC_MESSAGES/django.mo
django/contrib/sites/locale/tt/LC_MESSAGES/django.po
django/contrib/sites/locale/udm/LC_MESSAGES/django.mo
django/contrib/sites/locale/udm/LC_MESSAGES/django.po
django/contrib/sites/locale/uk/LC_MESSAGES/django.mo
django/contrib/sites/locale/uk/LC_MESSAGES/django.po
django/contrib/sites/locale/ur/LC_MESSAGES/django.mo
django/contrib/sites/locale/ur/LC_MESSAGES/django.po
django/contrib/sites/locale/vi/LC_MESSAGES/django.mo
django/contrib/sites/locale/vi/LC_MESSAGES/django.po
django/contrib/sites/locale/zh_Hans/LC_MESSAGES/django.mo
django/contrib/sites/locale/zh_Hans/LC_MESSAGES/django.po
django/contrib/sites/locale/zh_Hant/LC_MESSAGES/django.mo
django/contrib/sites/locale/zh_Hant/LC_MESSAGES/django.po
django/contrib/sites/migrations/0001_initial.py
django/contrib/sites/migrations/0002_alter_domain_unique.py
django/contrib/sites/migrations/__init__.py
django/contrib/staticfiles/__init__.py
django/contrib/staticfiles/apps.py
django/contrib/staticfiles/finders.py
django/contrib/staticfiles/handlers.py
django/contrib/staticfiles/storage.py
django/contrib/staticfiles/testing.py
django/contrib/staticfiles/urls.py
django/contrib/staticfiles/utils.py
django/contrib/staticfiles/views.py
django/contrib/staticfiles/management/__init__.py
django/contrib/staticfiles/management/commands/__init__.py
django/contrib/staticfiles/management/commands/collectstatic.py
django/contrib/staticfiles/management/commands/findstatic.py
django/contrib/staticfiles/management/commands/runserver.py
django/contrib/staticfiles/templatetags/__init__.py
django/contrib/staticfiles/templatetags/staticfiles.py
django/contrib/syndication/__init__.py
django/contrib/syndication/apps.py
django/contrib/syndication/views.py
django/core/__init__.py
django/core/exceptions.py
django/core/paginator.py
django/core/signals.py
django/core/signing.py
django/core/urlresolvers.py
django/core/validators.py
django/core/wsgi.py
django/core/cache/__init__.py
django/core/cache/utils.py
django/core/cache/backends/__init__.py
django/core/cache/backends/base.py
django/core/cache/backends/db.py
django/core/cache/backends/dummy.py
django/core/cache/backends/filebased.py
django/core/cache/backends/locmem.py
django/core/cache/backends/memcached.py
django/core/checks/__init__.py
django/core/checks/caches.py
django/core/checks/database.py
django/core/checks/messages.py
django/core/checks/model_checks.py
django/core/checks/registry.py
django/core/checks/templates.py
django/core/checks/urls.py
django/core/checks/utils.py
django/core/checks/compatibility/__init__.py
django/core/checks/compatibility/django_1_10.py
django/core/checks/compatibility/django_1_8_0.py
django/core/checks/security/__init__.py
django/core/checks/security/base.py
django/core/checks/security/csrf.py
django/core/checks/security/sessions.py
django/core/files/__init__.py
django/core/files/base.py
django/core/files/images.py
django/core/files/locks.py
django/core/files/move.py
django/core/files/storage.py
django/core/files/temp.py
django/core/files/uploadedfile.py
django/core/files/uploadhandler.py
django/core/files/utils.py
django/core/handlers/__init__.py
django/core/handlers/base.py
django/core/handlers/exception.py
django/core/handlers/wsgi.py
django/core/mail/__init__.py
django/core/mail/message.py
django/core/mail/utils.py
django/core/mail/backends/__init__.py
django/core/mail/backends/base.py
django/core/mail/backends/console.py
django/core/mail/backends/dummy.py
django/core/mail/backends/filebased.py
django/core/mail/backends/locmem.py
django/core/mail/backends/smtp.py
django/core/management/__init__.py
django/core/management/base.py
django/core/management/color.py
django/core/management/sql.py
django/core/management/templates.py
django/core/management/utils.py
django/core/management/commands/__init__.py
django/core/management/commands/check.py
django/core/management/commands/compilemessages.py
django/core/management/commands/createcachetable.py
django/core/management/commands/dbshell.py
django/core/management/commands/diffsettings.py
django/core/management/commands/dumpdata.py
django/core/management/commands/flush.py
django/core/management/commands/inspectdb.py
django/core/management/commands/loaddata.py
django/core/management/commands/makemessages.py
django/core/management/commands/makemigrations.py
django/core/management/commands/migrate.py
django/core/management/commands/runserver.py
django/core/management/commands/sendtestemail.py
django/core/management/commands/shell.py
django/core/management/commands/showmigrations.py
django/core/management/commands/sqlflush.py
django/core/management/commands/sqlmigrate.py
django/core/management/commands/sqlsequencereset.py
django/core/management/commands/squashmigrations.py
django/core/management/commands/startapp.py
django/core/management/commands/startproject.py
django/core/management/commands/test.py
django/core/management/commands/testserver.py
django/core/serializers/__init__.py
django/core/serializers/base.py
django/core/serializers/json.py
django/core/serializers/python.py
django/core/serializers/pyyaml.py
django/core/serializers/xml_serializer.py
django/core/servers/__init__.py
django/core/servers/basehttp.py
django/db/__init__.py
django/db/transaction.py
django/db/utils.py
django/db/backends/__init__.py
django/db/backends/signals.py
django/db/backends/utils.py
django/db/backends/base/__init__.py
django/db/backends/base/base.py
django/db/backends/base/client.py
django/db/backends/base/creation.py
django/db/backends/base/features.py
django/db/backends/base/introspection.py
django/db/backends/base/operations.py
django/db/backends/base/schema.py
django/db/backends/base/validation.py
django/db/backends/dummy/__init__.py
django/db/backends/dummy/base.py
django/db/backends/dummy/features.py
django/db/backends/mysql/__init__.py
django/db/backends/mysql/base.py
django/db/backends/mysql/client.py
django/db/backends/mysql/compiler.py
django/db/backends/mysql/creation.py
django/db/backends/mysql/features.py
django/db/backends/mysql/introspection.py
django/db/backends/mysql/operations.py
django/db/backends/mysql/schema.py
django/db/backends/mysql/validation.py
django/db/backends/oracle/__init__.py
django/db/backends/oracle/base.py
django/db/backends/oracle/client.py
django/db/backends/oracle/compiler.py
django/db/backends/oracle/creation.py
django/db/backends/oracle/features.py
django/db/backends/oracle/functions.py
django/db/backends/oracle/introspection.py
django/db/backends/oracle/operations.py
django/db/backends/oracle/schema.py
django/db/backends/oracle/utils.py
django/db/backends/postgresql/__init__.py
django/db/backends/postgresql/base.py
django/db/backends/postgresql/client.py
django/db/backends/postgresql/creation.py
django/db/backends/postgresql/features.py
django/db/backends/postgresql/introspection.py
django/db/backends/postgresql/operations.py
django/db/backends/postgresql/schema.py
django/db/backends/postgresql/utils.py
django/db/backends/postgresql/version.py
django/db/backends/postgresql_psycopg2/__init__.py
django/db/backends/postgresql_psycopg2/base.py
django/db/backends/postgresql_psycopg2/client.py
django/db/backends/postgresql_psycopg2/creation.py
django/db/backends/postgresql_psycopg2/features.py
django/db/backends/postgresql_psycopg2/introspection.py
django/db/backends/postgresql_psycopg2/operations.py
django/db/backends/postgresql_psycopg2/schema.py
django/db/backends/postgresql_psycopg2/utils.py
django/db/backends/postgresql_psycopg2/version.py
django/db/backends/sqlite3/__init__.py
django/db/backends/sqlite3/base.py
django/db/backends/sqlite3/client.py
django/db/backends/sqlite3/creation.py
django/db/backends/sqlite3/features.py
django/db/backends/sqlite3/introspection.py
django/db/backends/sqlite3/operations.py
django/db/backends/sqlite3/schema.py
django/db/migrations/__init__.py
django/db/migrations/autodetector.py
django/db/migrations/exceptions.py
django/db/migrations/executor.py
django/db/migrations/graph.py
django/db/migrations/loader.py
django/db/migrations/migration.py
django/db/migrations/optimizer.py
django/db/migrations/questioner.py
django/db/migrations/recorder.py
django/db/migrations/serializer.py
django/db/migrations/state.py
django/db/migrations/topological_sort.py
django/db/migrations/utils.py
django/db/migrations/writer.py
django/db/migrations/operations/__init__.py
django/db/migrations/operations/base.py
django/db/migrations/operations/fields.py
django/db/migrations/operations/models.py
django/db/migrations/operations/special.py
django/db/migrations/operations/utils.py
django/db/models/__init__.py
django/db/models/aggregates.py
django/db/models/base.py
django/db/models/constants.py
django/db/models/deletion.py
django/db/models/expressions.py
django/db/models/indexes.py
django/db/models/lookups.py
django/db/models/manager.py
django/db/models/options.py
django/db/models/query.py
django/db/models/query_utils.py
django/db/models/signals.py
django/db/models/utils.py
django/db/models/fields/__init__.py
django/db/models/fields/files.py
django/db/models/fields/proxy.py
django/db/models/fields/related.py
django/db/models/fields/related_descriptors.py
django/db/models/fields/related_lookups.py
django/db/models/fields/reverse_related.py
django/db/models/functions/__init__.py
django/db/models/functions/base.py
django/db/models/functions/datetime.py
django/db/models/sql/__init__.py
django/db/models/sql/compiler.py
django/db/models/sql/constants.py
django/db/models/sql/datastructures.py
django/db/models/sql/query.py
django/db/models/sql/subqueries.py
django/db/models/sql/where.py
django/dispatch/__init__.py
django/dispatch/dispatcher.py
django/dispatch/license.txt
django/dispatch/weakref_backports.py
django/forms/__init__.py
django/forms/boundfield.py
django/forms/fields.py
django/forms/forms.py
django/forms/formsets.py
django/forms/models.py
django/forms/renderers.py
django/forms/utils.py
django/forms/widgets.py
django/forms/extras/__init__.py
django/forms/extras/widgets.py
django/forms/jinja2/django/forms/widgets/attrs.html
django/forms/jinja2/django/forms/widgets/checkbox.html
django/forms/jinja2/django/forms/widgets/checkbox_option.html
django/forms/jinja2/django/forms/widgets/checkbox_select.html
django/forms/jinja2/django/forms/widgets/clearable_file_input.html
django/forms/jinja2/django/forms/widgets/date.html
django/forms/jinja2/django/forms/widgets/datetime.html
django/forms/jinja2/django/forms/widgets/email.html
django/forms/jinja2/django/forms/widgets/file.html
django/forms/jinja2/django/forms/widgets/hidden.html
django/forms/jinja2/django/forms/widgets/input.html
django/forms/jinja2/django/forms/widgets/input_option.html
django/forms/jinja2/django/forms/widgets/multiple_hidden.html
django/forms/jinja2/django/forms/widgets/multiple_input.html
django/forms/jinja2/django/forms/widgets/multiwidget.html
django/forms/jinja2/django/forms/widgets/number.html
django/forms/jinja2/django/forms/widgets/password.html
django/forms/jinja2/django/forms/widgets/radio.html
django/forms/jinja2/django/forms/widgets/radio_option.html
django/forms/jinja2/django/forms/widgets/select.html
django/forms/jinja2/django/forms/widgets/select_date.html
django/forms/jinja2/django/forms/widgets/select_option.html
django/forms/jinja2/django/forms/widgets/splitdatetime.html
django/forms/jinja2/django/forms/widgets/splithiddendatetime.html
django/forms/jinja2/django/forms/widgets/text.html
django/forms/jinja2/django/forms/widgets/textarea.html
django/forms/jinja2/django/forms/widgets/time.html
django/forms/jinja2/django/forms/widgets/url.html
django/forms/templates/django/forms/widgets/attrs.html
django/forms/templates/django/forms/widgets/checkbox.html
django/forms/templates/django/forms/widgets/checkbox_option.html
django/forms/templates/django/forms/widgets/checkbox_select.html
django/forms/templates/django/forms/widgets/clearable_file_input.html
django/forms/templates/django/forms/widgets/date.html
django/forms/templates/django/forms/widgets/datetime.html
django/forms/templates/django/forms/widgets/email.html
django/forms/templates/django/forms/widgets/file.html
django/forms/templates/django/forms/widgets/hidden.html
django/forms/templates/django/forms/widgets/input.html
django/forms/templates/django/forms/widgets/input_option.html
django/forms/templates/django/forms/widgets/multiple_hidden.html
django/forms/templates/django/forms/widgets/multiple_input.html
django/forms/templates/django/forms/widgets/multiwidget.html
django/forms/templates/django/forms/widgets/number.html
django/forms/templates/django/forms/widgets/password.html
django/forms/templates/django/forms/widgets/radio.html
django/forms/templates/django/forms/widgets/radio_option.html
django/forms/templates/django/forms/widgets/select.html
django/forms/templates/django/forms/widgets/select_date.html
django/forms/templates/django/forms/widgets/select_option.html
django/forms/templates/django/forms/widgets/splitdatetime.html
django/forms/templates/django/forms/widgets/splithiddendatetime.html
django/forms/templates/django/forms/widgets/text.html
django/forms/templates/django/forms/widgets/textarea.html
django/forms/templates/django/forms/widgets/time.html
django/forms/templates/django/forms/widgets/url.html
django/http/__init__.py
django/http/cookie.py
django/http/multipartparser.py
django/http/request.py
django/http/response.py
django/middleware/__init__.py
django/middleware/cache.py
django/middleware/clickjacking.py
django/middleware/common.py
django/middleware/csrf.py
django/middleware/gzip.py
django/middleware/http.py
django/middleware/locale.py
django/middleware/security.py
django/template/__init__.py
django/template/base.py
django/template/context.py
django/template/context_processors.py
django/template/defaultfilters.py
django/template/defaulttags.py
django/template/engine.py
django/template/exceptions.py
django/template/library.py
django/template/loader.py
django/template/loader_tags.py
django/template/response.py
django/template/smartif.py
django/template/utils.py
django/template/backends/__init__.py
django/template/backends/base.py
django/template/backends/django.py
django/template/backends/dummy.py
django/template/backends/jinja2.py
django/template/backends/utils.py
django/template/loaders/__init__.py
django/template/loaders/app_directories.py
django/template/loaders/base.py
django/template/loaders/cached.py
django/template/loaders/eggs.py
django/template/loaders/filesystem.py
django/template/loaders/locmem.py
django/templatetags/__init__.py
django/templatetags/cache.py
django/templatetags/i18n.py
django/templatetags/l10n.py
django/templatetags/static.py
django/templatetags/tz.py
django/test/__init__.py
django/test/client.py
django/test/html.py
django/test/runner.py
django/test/selenium.py
django/test/signals.py
django/test/testcases.py
django/test/utils.py
django/urls/__init__.py
django/urls/base.py
django/urls/exceptions.py
django/urls/resolvers.py
django/urls/utils.py
django/utils/__init__.py
django/utils/_os.py
django/utils/archive.py
django/utils/autoreload.py
django/utils/baseconv.py
django/utils/cache.py
django/utils/crypto.py
django/utils/datastructures.py
django/utils/dateformat.py
django/utils/dateparse.py
django/utils/dates.py
django/utils/datetime_safe.py
django/utils/deconstruct.py
django/utils/decorators.py
django/utils/deprecation.py
django/utils/duration.py
django/utils/encoding.py
django/utils/feedgenerator.py
django/utils/formats.py
django/utils/functional.py
django/utils/glob.py
django/utils/html.py
django/utils/html_parser.py
django/utils/http.py
django/utils/inspect.py
django/utils/ipv6.py
django/utils/itercompat.py
django/utils/jslex.py
django/utils/log.py
django/utils/lorem_ipsum.py
django/utils/lru_cache.py
django/utils/module_loading.py
django/utils/numberformat.py
django/utils/regex_helper.py
django/utils/safestring.py
django/utils/six.py
django/utils/synch.py
django/utils/termcolors.py
django/utils/text.py
django/utils/timesince.py
django/utils/timezone.py
django/utils/tree.py
django/utils/version.py
django/utils/xmlutils.py
django/utils/translation/__init__.py
django/utils/translation/template.py
django/utils/translation/trans_null.py
django/utils/translation/trans_real.py
django/views/__init__.py
django/views/csrf.py
django/views/debug.py
django/views/defaults.py
django/views/i18n.py
django/views/static.py
django/views/decorators/__init__.py
django/views/decorators/cache.py
django/views/decorators/clickjacking.py
django/views/decorators/csrf.py
django/views/decorators/debug.py
django/views/decorators/gzip.py
django/views/decorators/http.py
django/views/decorators/vary.py
django/views/generic/__init__.py
django/views/generic/base.py
django/views/generic/dates.py
django/views/generic/detail.py
django/views/generic/edit.py
django/views/generic/list.py
docs/Makefile
docs/README
docs/conf.py
docs/contents.txt
docs/glossary.txt
docs/index.txt
docs/make.bat
docs/spelling_wordlist
docs/_ext/cve_role.py
docs/_ext/djangodocs.py
docs/_ext/ticket_role.py
docs/_theme/djangodocs/genindex.html
docs/_theme/djangodocs/layout.html
docs/_theme/djangodocs/modindex.html
docs/_theme/djangodocs/search.html
docs/_theme/djangodocs/theme.conf
docs/_theme/djangodocs-epub/epub-cover.html
docs/_theme/djangodocs-epub/theme.conf
docs/_theme/djangodocs-epub/static/docicons-behindscenes.png
docs/_theme/djangodocs-epub/static/docicons-note.png
docs/_theme/djangodocs-epub/static/docicons-philosophy.png
docs/_theme/djangodocs-epub/static/docicons-warning.png
docs/_theme/djangodocs-epub/static/epub.css
docs/_theme/djangodocs/static/default.css
docs/_theme/djangodocs/static/djangodocs.css
docs/_theme/djangodocs/static/docicons-behindscenes.png
docs/_theme/djangodocs/static/docicons-note.png
docs/_theme/djangodocs/static/docicons-philosophy.png
docs/_theme/djangodocs/static/docicons-warning.png
docs/_theme/djangodocs/static/homepage.css
docs/_theme/djangodocs/static/reset-fonts-grids.css
docs/faq/admin.txt
docs/faq/contributing.txt
docs/faq/general.txt
docs/faq/help.txt
docs/faq/index.txt
docs/faq/install.txt
docs/faq/models.txt
docs/faq/troubleshooting.txt
docs/faq/usage.txt
docs/howto/auth-remote-user.txt
docs/howto/custom-file-storage.txt
docs/howto/custom-lookups.txt
docs/howto/custom-management-commands.txt
docs/howto/custom-model-fields.txt
docs/howto/custom-template-tags.txt
docs/howto/error-reporting.txt
docs/howto/index.txt
docs/howto/initial-data.txt
docs/howto/jython.txt
docs/howto/legacy-databases.txt
docs/howto/outputting-csv.txt
docs/howto/outputting-pdf.txt
docs/howto/overriding-templates.txt
docs/howto/upgrade-version.txt
docs/howto/windows.txt
docs/howto/writing-migrations.txt
docs/howto/deployment/checklist.txt
docs/howto/deployment/index.txt
docs/howto/deployment/wsgi/apache-auth.txt
docs/howto/deployment/wsgi/gunicorn.txt
docs/howto/deployment/wsgi/index.txt
docs/howto/deployment/wsgi/modwsgi.txt
docs/howto/deployment/wsgi/uwsgi.txt
docs/howto/static-files/deployment.txt
docs/howto/static-files/index.txt
docs/internals/deprecation.txt
docs/internals/git.txt
docs/internals/howto-release-django.txt
docs/internals/index.txt
docs/internals/mailing-lists.txt
docs/internals/organization.txt
docs/internals/release-process.txt
docs/internals/security.txt
docs/internals/_images/triage_process.graffle
docs/internals/_images/triage_process.pdf
docs/internals/_images/triage_process.svg
docs/internals/contributing/bugs-and-features.txt
docs/internals/contributing/committing-code.txt
docs/internals/contributing/index.txt
docs/internals/contributing/localizing.txt
docs/internals/contributing/new-contributors.txt
docs/internals/contributing/triaging-tickets.txt
docs/internals/contributing/writing-documentation.txt
docs/internals/contributing/writing-code/coding-style.txt
docs/internals/contributing/writing-code/index.txt
docs/internals/contributing/writing-code/javascript.txt
docs/internals/contributing/writing-code/submitting-patches.txt
docs/internals/contributing/writing-code/unit-tests.txt
docs/internals/contributing/writing-code/working-with-git.txt
docs/intro/contributing.txt
docs/intro/index.txt
docs/intro/install.txt
docs/intro/overview.txt
docs/intro/reusable-apps.txt
docs/intro/tutorial01.txt
docs/intro/tutorial02.txt
docs/intro/tutorial03.txt
docs/intro/tutorial04.txt
docs/intro/tutorial05.txt
docs/intro/tutorial06.txt
docs/intro/tutorial07.txt
docs/intro/whatsnext.txt
docs/intro/_images/admin01.png
docs/intro/_images/admin02.png
docs/intro/_images/admin03t.png
docs/intro/_images/admin04t.png
docs/intro/_images/admin05t.png
docs/intro/_images/admin06t.png
docs/intro/_images/admin07.png
docs/intro/_images/admin08t.png
docs/intro/_images/admin09.png
docs/intro/_images/admin10t.png
docs/intro/_images/admin11t.png
docs/intro/_images/admin12t.png
docs/intro/_images/admin13t.png
docs/intro/_images/admin14t.png
docs/man/django-admin.1
docs/misc/api-stability.txt
docs/misc/design-philosophies.txt
docs/misc/distributions.txt
docs/misc/index.txt
docs/ref/applications.txt
docs/ref/checks.txt
docs/ref/clickjacking.txt
docs/ref/csrf.txt
docs/ref/databases.txt
docs/ref/django-admin.txt
docs/ref/exceptions.txt
docs/ref/index.txt
docs/ref/middleware.txt
docs/ref/migration-operations.txt
docs/ref/request-response.txt
docs/ref/schema-editor.txt
docs/ref/settings.txt
docs/ref/signals.txt
docs/ref/template-response.txt
docs/ref/unicode.txt
docs/ref/urlresolvers.txt
docs/ref/urls.txt
docs/ref/utils.txt
docs/ref/validators.txt
docs/ref/views.txt
docs/ref/class-based-views/base.txt
docs/ref/class-based-views/flattened-index.txt
docs/ref/class-based-views/generic-date-based.txt
docs/ref/class-based-views/generic-display.txt
docs/ref/class-based-views/generic-editing.txt
docs/ref/class-based-views/index.txt
docs/ref/class-based-views/mixins-date-based.txt
docs/ref/class-based-views/mixins-editing.txt
docs/ref/class-based-views/mixins-multiple-object.txt
docs/ref/class-based-views/mixins-simple.txt
docs/ref/class-based-views/mixins-single-object.txt
docs/ref/class-based-views/mixins.txt
docs/ref/contrib/auth.txt
docs/ref/contrib/contenttypes.txt
docs/ref/contrib/flatpages.txt
docs/ref/contrib/humanize.txt
docs/ref/contrib/index.txt
docs/ref/contrib/messages.txt
docs/ref/contrib/redirects.txt
docs/ref/contrib/sitemaps.txt
docs/ref/contrib/sites.txt
docs/ref/contrib/staticfiles.txt
docs/ref/contrib/syndication.txt
docs/ref/contrib/admin/actions.txt
docs/ref/contrib/admin/admindocs.txt
docs/ref/contrib/admin/index.txt
docs/ref/contrib/admin/javascript.txt
docs/ref/contrib/admin/_images/actions-as-modeladmin-methods.png
docs/ref/contrib/admin/_images/adding-actions-to-the-modeladmin.png
docs/ref/contrib/admin/_images/admin-actions.png
docs/ref/contrib/admin/_images/fieldsets.png
docs/ref/contrib/admin/_images/list_filter.png
docs/ref/contrib/admin/_images/raw_id_fields.png
docs/ref/contrib/gis/admin.txt
docs/ref/contrib/gis/commands.txt
docs/ref/contrib/gis/db-api.txt
docs/ref/contrib/gis/deployment.txt
docs/ref/contrib/gis/feeds.txt
docs/ref/contrib/gis/forms-api.txt
docs/ref/contrib/gis/functions.txt
docs/ref/contrib/gis/gdal.txt
docs/ref/contrib/gis/geoip.txt
docs/ref/contrib/gis/geoip2.txt
docs/ref/contrib/gis/geoquerysets.txt
docs/ref/contrib/gis/geos.txt
docs/ref/contrib/gis/index.txt
docs/ref/contrib/gis/layermapping.txt
docs/ref/contrib/gis/measure.txt
docs/ref/contrib/gis/model-api.txt
docs/ref/contrib/gis/ogrinspect.txt
docs/ref/contrib/gis/serializers.txt
docs/ref/contrib/gis/sitemaps.txt
docs/ref/contrib/gis/testing.txt
docs/ref/contrib/gis/tutorial.txt
docs/ref/contrib/gis/utils.txt
docs/ref/contrib/gis/install/geodjango_setup.bat
docs/ref/contrib/gis/install/geolibs.txt
docs/ref/contrib/gis/install/index.txt
docs/ref/contrib/gis/install/postgis.txt
docs/ref/contrib/gis/install/spatialite.txt
docs/ref/contrib/postgres/aggregates.txt
docs/ref/contrib/postgres/fields.txt
docs/ref/contrib/postgres/forms.txt
docs/ref/contrib/postgres/functions.txt
docs/ref/contrib/postgres/index.txt
docs/ref/contrib/postgres/indexes.txt
docs/ref/contrib/postgres/lookups.txt
docs/ref/contrib/postgres/operations.txt
docs/ref/contrib/postgres/search.txt
docs/ref/contrib/postgres/validators.txt
docs/ref/files/file.txt
docs/ref/files/index.txt
docs/ref/files/storage.txt
docs/ref/files/uploads.txt
docs/ref/forms/api.txt
docs/ref/forms/fields.txt
docs/ref/forms/formsets.txt
docs/ref/forms/index.txt
docs/ref/forms/models.txt
docs/ref/forms/renderers.txt
docs/ref/forms/validation.txt
docs/ref/forms/widgets.txt
docs/ref/models/class.txt
docs/ref/models/conditional-expressions.txt
docs/ref/models/database-functions.txt
docs/ref/models/expressions.txt
docs/ref/models/fields.txt
docs/ref/models/index.txt
docs/ref/models/indexes.txt
docs/ref/models/instances.txt
docs/ref/models/lookups.txt
docs/ref/models/meta.txt
docs/ref/models/options.txt
docs/ref/models/querysets.txt
docs/ref/models/relations.txt
docs/ref/templates/api.txt
docs/ref/templates/builtins.txt
docs/ref/templates/index.txt
docs/ref/templates/language.txt
docs/ref/templates/upgrading.txt
docs/releases/0.95.txt
docs/releases/0.96.txt
docs/releases/1.0-porting-guide.txt
docs/releases/1.0.1.txt
docs/releases/1.0.2.txt
docs/releases/1.0.txt
docs/releases/1.1.2.txt
docs/releases/1.1.3.txt
docs/releases/1.1.4.txt
docs/releases/1.1.txt
docs/releases/1.10.1.txt
docs/releases/1.10.2.txt
docs/releases/1.10.3.txt
docs/releases/1.10.4.txt
docs/releases/1.10.5.txt
docs/releases/1.10.6.txt
docs/releases/1.10.7.txt
docs/releases/1.10.8.txt
docs/releases/1.10.txt
docs/releases/1.11.1.txt
docs/releases/1.11.10.txt
docs/releases/1.11.11.txt
docs/releases/1.11.2.txt
docs/releases/1.11.3.txt
docs/releases/1.11.4.txt
docs/releases/1.11.5.txt
docs/releases/1.11.6.txt
docs/releases/1.11.7.txt
docs/releases/1.11.8.txt
docs/releases/1.11.9.txt
docs/releases/1.11.txt
docs/releases/1.2.1.txt
docs/releases/1.2.2.txt
docs/releases/1.2.3.txt
docs/releases/1.2.4.txt
docs/releases/1.2.5.txt
docs/releases/1.2.6.txt
docs/releases/1.2.7.txt
docs/releases/1.2.txt
docs/releases/1.3.1.txt
docs/releases/1.3.2.txt
docs/releases/1.3.3.txt
docs/releases/1.3.4.txt
docs/releases/1.3.5.txt
docs/releases/1.3.6.txt
docs/releases/1.3.7.txt
docs/releases/1.3.txt
docs/releases/1.4.1.txt
docs/releases/1.4.10.txt
docs/releases/1.4.11.txt
docs/releases/1.4.12.txt
docs/releases/1.4.13.txt
docs/releases/1.4.14.txt
docs/releases/1.4.15.txt
docs/releases/1.4.16.txt
docs/releases/1.4.17.txt
docs/releases/1.4.18.txt
docs/releases/1.4.19.txt
docs/releases/1.4.2.txt
docs/releases/1.4.20.txt
docs/releases/1.4.21.txt
docs/releases/1.4.22.txt
docs/releases/1.4.3.txt
docs/releases/1.4.4.txt
docs/releases/1.4.5.txt
docs/releases/1.4.6.txt
docs/releases/1.4.7.txt
docs/releases/1.4.8.txt
docs/releases/1.4.9.txt
docs/releases/1.4.txt
docs/releases/1.5.1.txt
docs/releases/1.5.10.txt
docs/releases/1.5.11.txt
docs/releases/1.5.12.txt
docs/releases/1.5.2.txt
docs/releases/1.5.3.txt
docs/releases/1.5.4.txt
docs/releases/1.5.5.txt
docs/releases/1.5.6.txt
docs/releases/1.5.7.txt
docs/releases/1.5.8.txt
docs/releases/1.5.9.txt
docs/releases/1.5.txt
docs/releases/1.6.1.txt
docs/releases/1.6.10.txt
docs/releases/1.6.11.txt
docs/releases/1.6.2.txt
docs/releases/1.6.3.txt
docs/releases/1.6.4.txt
docs/releases/1.6.5.txt
docs/releases/1.6.6.txt
docs/releases/1.6.7.txt
docs/releases/1.6.8.txt
docs/releases/1.6.9.txt
docs/releases/1.6.txt
docs/releases/1.7.1.txt
docs/releases/1.7.10.txt
docs/releases/1.7.11.txt
docs/releases/1.7.2.txt
docs/releases/1.7.3.txt
docs/releases/1.7.4.txt
docs/releases/1.7.5.txt
docs/releases/1.7.6.txt
docs/releases/1.7.7.txt
docs/releases/1.7.8.txt
docs/releases/1.7.9.txt
docs/releases/1.7.txt
docs/releases/1.8.1.txt
docs/releases/1.8.10.txt
docs/releases/1.8.11.txt
docs/releases/1.8.12.txt
docs/releases/1.8.13.txt
docs/releases/1.8.14.txt
docs/releases/1.8.15.txt
docs/releases/1.8.16.txt
docs/releases/1.8.17.txt
docs/releases/1.8.18.txt
docs/releases/1.8.19.txt
docs/releases/1.8.2.txt
docs/releases/1.8.3.txt
docs/releases/1.8.4.txt
docs/releases/1.8.5.txt
docs/releases/1.8.6.txt
docs/releases/1.8.7.txt
docs/releases/1.8.8.txt
docs/releases/1.8.9.txt
docs/releases/1.8.txt
docs/releases/1.9.1.txt
docs/releases/1.9.10.txt
docs/releases/1.9.11.txt
docs/releases/1.9.12.txt
docs/releases/1.9.13.txt
docs/releases/1.9.2.txt
docs/releases/1.9.3.txt
docs/releases/1.9.4.txt
docs/releases/1.9.5.txt
docs/releases/1.9.6.txt
docs/releases/1.9.7.txt
docs/releases/1.9.8.txt
docs/releases/1.9.9.txt
docs/releases/1.9.txt
docs/releases/index.txt
docs/releases/security.txt
docs/topics/cache.txt
docs/topics/checks.txt
docs/topics/conditional-view-processing.txt
docs/topics/email.txt
docs/topics/external-packages.txt
docs/topics/files.txt
docs/topics/index.txt
docs/topics/install.txt
docs/topics/logging.txt
docs/topics/migrations.txt
docs/topics/pagination.txt
docs/topics/performance.txt
docs/topics/python3.txt
docs/topics/security.txt
docs/topics/serialization.txt
docs/topics/settings.txt
docs/topics/signals.txt
docs/topics/signing.txt
docs/topics/templates.txt
docs/topics/_images/postmortem.png
docs/topics/_images/template-lines.png
docs/topics/auth/customizing.txt
docs/topics/auth/default.txt
docs/topics/auth/index.txt
docs/topics/auth/passwords.txt
docs/topics/class-based-views/generic-display.txt
docs/topics/class-based-views/generic-editing.txt
docs/topics/class-based-views/index.txt
docs/topics/class-based-views/intro.txt
docs/topics/class-based-views/mixins.txt
docs/topics/db/aggregation.txt
docs/topics/db/index.txt
docs/topics/db/managers.txt
docs/topics/db/models.txt
docs/topics/db/multi-db.txt
docs/topics/db/optimization.txt
docs/topics/db/queries.txt
docs/topics/db/search.txt
docs/topics/db/sql.txt
docs/topics/db/tablespaces.txt
docs/topics/db/transactions.txt
docs/topics/db/examples/index.txt
docs/topics/db/examples/many_to_many.txt
docs/topics/db/examples/many_to_one.txt
docs/topics/db/examples/one_to_one.txt
docs/topics/forms/formsets.txt
docs/topics/forms/index.txt
docs/topics/forms/media.txt
docs/topics/forms/modelforms.txt
docs/topics/http/decorators.txt
docs/topics/http/file-uploads.txt
docs/topics/http/generic-views.txt
docs/topics/http/index.txt
docs/topics/http/middleware.txt
docs/topics/http/sessions.txt
docs/topics/http/shortcuts.txt
docs/topics/http/urls.txt
docs/topics/http/views.txt
docs/topics/http/_images/middleware.pdf
docs/topics/i18n/formatting.txt
docs/topics/i18n/index.txt
docs/topics/i18n/timezones.txt
docs/topics/i18n/translation.txt
docs/topics/testing/advanced.txt
docs/topics/testing/index.txt
docs/topics/testing/overview.txt
docs/topics/testing/tools.txt
docs/topics/testing/_images/django_unittest_classes_hierarchy.graffle
docs/topics/testing/_images/django_unittest_classes_hierarchy.pdf
docs/topics/testing/_images/django_unittest_classes_hierarchy.svg
extras/Makefile
extras/README.TXT
extras/django_bash_completion
js_tests/tests.html
js_tests/admin/DateTimeShortcuts.test.js
js_tests/admin/RelatedObjectLookups.test.js
js_tests/admin/SelectBox.test.js
js_tests/admin/SelectFilter2.test.js
js_tests/admin/actions.test.js
js_tests/admin/core.test.js
js_tests/admin/inlines.test.js
js_tests/admin/jsi18n-mocks.test.js
js_tests/admin/timeparse.test.js
js_tests/gis/mapwidget.test.js
js_tests/qunit/qunit.css
js_tests/qunit/qunit.js
scripts/manage_translations.py
scripts/rpm-install.sh
tests/.coveragerc
tests/README.rst
tests/runtests.py
tests/test_sqlite.py
tests/urls.py
tests/absolute_url_overrides/__init__.py
tests/absolute_url_overrides/tests.py
tests/admin_autodiscover/__init__.py
tests/admin_autodiscover/admin.py
tests/admin_autodiscover/models.py
tests/admin_autodiscover/tests.py
tests/admin_changelist/__init__.py
tests/admin_changelist/admin.py
tests/admin_changelist/models.py
tests/admin_changelist/tests.py
tests/admin_changelist/urls.py
tests/admin_checks/__init__.py
tests/admin_checks/models.py
tests/admin_checks/tests.py
tests/admin_custom_urls/__init__.py
tests/admin_custom_urls/models.py
tests/admin_custom_urls/tests.py
tests/admin_custom_urls/urls.py
tests/admin_docs/__init__.py
tests/admin_docs/evilfile.txt
tests/admin_docs/models.py
tests/admin_docs/namespace_urls.py
tests/admin_docs/test_middleware.py
tests/admin_docs/test_utils.py
tests/admin_docs/test_views.py
tests/admin_docs/tests.py
tests/admin_docs/urls.py
tests/admin_docs/views.py
tests/admin_filters/__init__.py
tests/admin_filters/models.py
tests/admin_filters/tests.py
tests/admin_inlines/__init__.py
tests/admin_inlines/admin.py
tests/admin_inlines/models.py
tests/admin_inlines/test_templates.py
tests/admin_inlines/tests.py
tests/admin_inlines/urls.py
tests/admin_ordering/__init__.py
tests/admin_ordering/models.py
tests/admin_ordering/tests.py
tests/admin_registration/__init__.py
tests/admin_registration/models.py
tests/admin_registration/tests.py
tests/admin_scripts/__init__.py
tests/admin_scripts/tests.py
tests/admin_scripts/urls.py
tests/admin_scripts/another_app_waiting_migration/__init__.py
tests/admin_scripts/another_app_waiting_migration/models.py
tests/admin_scripts/another_app_waiting_migration/migrations/0001_initial.py
tests/admin_scripts/another_app_waiting_migration/migrations/__init__.py
tests/admin_scripts/app_raising_messages/__init__.py
tests/admin_scripts/app_raising_messages/models.py
tests/admin_scripts/app_raising_warning/__init__.py
tests/admin_scripts/app_raising_warning/models.py
tests/admin_scripts/app_waiting_migration/__init__.py
tests/admin_scripts/app_waiting_migration/models.py
tests/admin_scripts/app_waiting_migration/migrations/0001_initial.py
tests/admin_scripts/app_waiting_migration/migrations/__init__.py
tests/admin_scripts/app_with_import/__init__.py
tests/admin_scripts/app_with_import/models.py
tests/admin_scripts/broken_app/__init__.py
tests/admin_scripts/broken_app/models.py
tests/admin_scripts/complex_app/__init__.py
tests/admin_scripts/complex_app/admin/__init__.py
tests/admin_scripts/complex_app/admin/foo.py
tests/admin_scripts/complex_app/management/__init__.py
tests/admin_scripts/complex_app/management/commands/__init__.py
tests/admin_scripts/complex_app/management/commands/duplicate.py
tests/admin_scripts/complex_app/models/__init__.py
tests/admin_scripts/complex_app/models/bar.py
tests/admin_scripts/complex_app/models/foo.py
tests/admin_scripts/custom_templates/project_template.tgz
tests/admin_scripts/custom_templates/app_template/__init__.py
tests/admin_scripts/custom_templates/app_template/api.py
tests/admin_scripts/custom_templates/project_template/manage.py-tpl
tests/admin_scripts/custom_templates/project_template/ticket-18091-non-ascii-template.txt
tests/admin_scripts/custom_templates/project_template/ticket-19397-binary-file.ico
tests/admin_scripts/custom_templates/project_template/additional_dir/Procfile
tests/admin_scripts/custom_templates/project_template/additional_dir/additional_file.py
tests/admin_scripts/custom_templates/project_template/additional_dir/extra.py
tests/admin_scripts/custom_templates/project_template/additional_dir/localized.py
tests/admin_scripts/custom_templates/project_template/additional_dir/requirements.txt
tests/admin_scripts/custom_templates/project_template/project_name/__init__.py
tests/admin_scripts/custom_templates/project_template/project_name/settings.py
tests/admin_scripts/management/__init__.py
tests/admin_scripts/management/commands/__init__.py
tests/admin_scripts/management/commands/app_command.py
tests/admin_scripts/management/commands/base_command.py
tests/admin_scripts/management/commands/custom_startproject.py
tests/admin_scripts/management/commands/label_command.py
tests/admin_scripts/management/commands/noargs_command.py
tests/admin_scripts/simple_app/__init__.py
tests/admin_scripts/simple_app/models.py
tests/admin_scripts/simple_app/management/__init__.py
tests/admin_scripts/simple_app/management/commands/__init__.py
tests/admin_scripts/simple_app/management/commands/duplicate.py
tests/admin_utils/__init__.py
tests/admin_utils/admin.py
tests/admin_utils/models.py
tests/admin_utils/test_logentry.py
tests/admin_utils/tests.py
tests/admin_utils/urls.py
tests/admin_views/__init__.py
tests/admin_views/admin.py
tests/admin_views/custom_has_permission_admin.py
tests/admin_views/customadmin.py
tests/admin_views/forms.py
tests/admin_views/models.py
tests/admin_views/test_adminsite.py
tests/admin_views/test_multidb.py
tests/admin_views/test_templatetags.py
tests/admin_views/tests.py
tests/admin_views/urls.py
tests/admin_views/views.py
tests/admin_views/templates/custom_filter_template.html
tests/admin_views/templates/admin/base_site.html
tests/admin_widgets/__init__.py
tests/admin_widgets/models.py
tests/admin_widgets/tests.py
tests/admin_widgets/urls.py
tests/admin_widgets/widgetadmin.py
tests/aggregation/__init__.py
tests/aggregation/models.py
tests/aggregation/tests.py
tests/aggregation_regress/__init__.py
tests/aggregation_regress/models.py
tests/aggregation_regress/tests.py
tests/annotations/__init__.py
tests/annotations/models.py
tests/annotations/tests.py
tests/app_loading/__init__.py
tests/app_loading/tests.py
tests/app_loading/eggs/brokenapp.egg
tests/app_loading/eggs/modelapp.egg
tests/app_loading/eggs/nomodelapp.egg
tests/app_loading/eggs/omelet.egg
tests/app_loading/not_installed/__init__.py
tests/app_loading/not_installed/models.py
tests/apps/__init__.py
tests/apps/apps.py
tests/apps/models.py
tests/apps/tests.py
tests/apps/default_config_app/__init__.py
tests/apps/default_config_app/apps.py
tests/apps/namespace_package_base/nsapp/apps.py
tests/apps/namespace_package_other_base/nsapp/.keep
tests/auth_tests/__init__.py
tests/auth_tests/backend_alias.py
tests/auth_tests/client.py
tests/auth_tests/common-passwords-custom.txt
tests/auth_tests/settings.py
tests/auth_tests/test_admin_multidb.py
tests/auth_tests/test_auth_backends.py
tests/auth_tests/test_auth_backends_deprecation.py
tests/auth_tests/test_basic.py
tests/auth_tests/test_checks.py
tests/auth_tests/test_context_processors.py
tests/auth_tests/test_decorators.py
tests/auth_tests/test_deprecated_views.py
tests/auth_tests/test_forms.py
tests/auth_tests/test_handlers.py
tests/auth_tests/test_hashers.py
tests/auth_tests/test_management.py
tests/auth_tests/test_middleware.py
tests/auth_tests/test_mixins.py
tests/auth_tests/test_models.py
tests/auth_tests/test_remote_user.py
tests/auth_tests/test_signals.py
tests/auth_tests/test_templates.py
tests/auth_tests/test_tokens.py
tests/auth_tests/test_validators.py
tests/auth_tests/test_views.py
tests/auth_tests/urls.py
tests/auth_tests/urls_admin.py
tests/auth_tests/urls_custom_user_admin.py
tests/auth_tests/urls_deprecated.py
tests/auth_tests/fixtures/natural.json
tests/auth_tests/fixtures/regular.json
tests/auth_tests/models/__init__.py
tests/auth_tests/models/custom_permissions.py
tests/auth_tests/models/custom_user.py
tests/auth_tests/models/invalid_models.py
tests/auth_tests/models/is_active.py
tests/auth_tests/models/uuid_pk.py
tests/auth_tests/models/with_custom_email_field.py
tests/auth_tests/models/with_foreign_key.py
tests/auth_tests/models/with_integer_username.py
tests/auth_tests/templates/context_processors/auth_attrs_access.html
tests/auth_tests/templates/context_processors/auth_attrs_messages.html
tests/auth_tests/templates/context_processors/auth_attrs_no_access.html
tests/auth_tests/templates/context_processors/auth_attrs_perm_in_perms.html
tests/auth_tests/templates/context_processors/auth_attrs_perms.html
tests/auth_tests/templates/context_processors/auth_attrs_test_access.html
tests/auth_tests/templates/context_processors/auth_attrs_user.html
tests/auth_tests/templates/registration/html_password_reset_email.html
tests/auth_tests/templates/registration/logged_out.html
tests/auth_tests/templates/registration/login.html
tests/auth_tests/templates/registration/password_change_form.html
tests/auth_tests/templates/registration/password_reset_complete.html
tests/auth_tests/templates/registration/password_reset_confirm.html
tests/auth_tests/templates/registration/password_reset_done.html
tests/auth_tests/templates/registration/password_reset_email.html
tests/auth_tests/templates/registration/password_reset_form.html
tests/auth_tests/templates/registration/password_reset_subject.txt
tests/backends/__init__.py
tests/backends/models.py
tests/backends/test_creation.py
tests/backends/test_features.py
tests/backends/test_mysql.py
tests/backends/test_postgresql.py
tests/backends/test_utils.py
tests/backends/tests.py
tests/base/__init__.py
tests/base/models.py
tests/bash_completion/__init__.py
tests/bash_completion/tests.py
tests/bash_completion/management/__init__.py
tests/bash_completion/management/commands/__init__.py
tests/bash_completion/management/commands/test_command.py
tests/basic/__init__.py
tests/basic/models.py
tests/basic/tests.py
tests/builtin_server/__init__.py
tests/builtin_server/tests.py
tests/bulk_create/__init__.py
tests/bulk_create/models.py
tests/bulk_create/tests.py
tests/cache/__init__.py
tests/cache/closeable_cache.py
tests/cache/liberal_backend.py
tests/cache/models.py
tests/cache/tests.py
tests/check_framework/__init__.py
tests/check_framework/models.py
tests/check_framework/test_caches.py
tests/check_framework/test_database.py
tests/check_framework/test_model_field_deprecation.py
tests/check_framework/test_multi_db.py
tests/check_framework/test_security.py
tests/check_framework/test_templates.py
tests/check_framework/test_urls.py
tests/check_framework/tests.py
tests/check_framework/tests_1_10_compatibility.py
tests/check_framework/tests_1_8_compatibility.py
tests/check_framework/urls/__init__.py
tests/check_framework/urls/beginning_with_slash.py
tests/check_framework/urls/contains_tuple.py
tests/check_framework/urls/include_with_dollar.py
tests/check_framework/urls/name_with_colon.py
tests/check_framework/urls/no_warnings.py
tests/check_framework/urls/non_unique_namespaces.py
tests/check_framework/urls/unique_namespaces.py
tests/check_framework/urls/warning_in_include.py
tests/choices/__init__.py
tests/choices/models.py
tests/choices/tests.py
tests/conditional_processing/__init__.py
tests/conditional_processing/tests.py
tests/conditional_processing/urls.py
tests/conditional_processing/views.py
tests/contenttypes_tests/__init__.py
tests/contenttypes_tests/models.py
tests/contenttypes_tests/test_models.py
tests/contenttypes_tests/test_order_with_respect_to.py
tests/contenttypes_tests/tests.py
tests/contenttypes_tests/urls.py
tests/contenttypes_tests/operations_migrations/0001_initial.py
tests/contenttypes_tests/operations_migrations/0002_rename_foo.py
tests/contenttypes_tests/operations_migrations/__init__.py
tests/context_processors/__init__.py
tests/context_processors/models.py
tests/context_processors/tests.py
tests/context_processors/urls.py
tests/context_processors/views.py
tests/context_processors/templates/context_processors/debug.html
tests/context_processors/templates/context_processors/request_attrs.html
tests/csrf_tests/__init__.py
tests/csrf_tests/csrf_token_error_handler_urls.py
tests/csrf_tests/test_context_processor.py
tests/csrf_tests/tests.py
tests/csrf_tests/views.py
tests/custom_columns/__init__.py
tests/custom_columns/models.py
tests/custom_columns/tests.py
tests/custom_lookups/__init__.py
tests/custom_lookups/models.py
tests/custom_lookups/tests.py
tests/custom_managers/__init__.py
tests/custom_managers/models.py
tests/custom_managers/tests.py
tests/custom_methods/__init__.py
tests/custom_methods/models.py
tests/custom_methods/tests.py
tests/custom_migration_operations/__init__.py
tests/custom_migration_operations/more_operations.py
tests/custom_migration_operations/operations.py
tests/custom_pk/__init__.py
tests/custom_pk/fields.py
tests/custom_pk/models.py
tests/custom_pk/tests.py
tests/datatypes/__init__.py
tests/datatypes/models.py
tests/datatypes/tests.py
tests/dates/__init__.py
tests/dates/models.py
tests/dates/tests.py
tests/datetimes/__init__.py
tests/datetimes/models.py
tests/datetimes/tests.py
tests/db_functions/__init__.py
tests/db_functions/models.py
tests/db_functions/test_cast.py
tests/db_functions/test_datetime.py
tests/db_functions/tests.py
tests/db_typecasts/__init__.py
tests/db_typecasts/tests.py
tests/dbshell/__init__.py
tests/dbshell/test_mysql.py
tests/dbshell/test_postgresql_psycopg2.py
tests/decorators/__init__.py
tests/decorators/tests.py
tests/defer/__init__.py
tests/defer/models.py
tests/defer/tests.py
tests/defer_regress/__init__.py
tests/defer_regress/models.py
tests/defer_regress/tests.py
tests/delete/__init__.py
tests/delete/models.py
tests/delete/tests.py
tests/delete_regress/__init__.py
tests/delete_regress/models.py
tests/delete_regress/tests.py
tests/deprecation/__init__.py
tests/deprecation/tests.py
tests/dispatch/__init__.py
tests/dispatch/test_removedindjango20.py
tests/dispatch/tests.py
tests/distinct_on_fields/__init__.py
tests/distinct_on_fields/models.py
tests/distinct_on_fields/tests.py
tests/empty/__init__.py
tests/empty/models.py
tests/empty/tests.py
tests/empty/no_models/__init__.py
tests/expressions/__init__.py
tests/expressions/models.py
tests/expressions/test_queryset_values.py
tests/expressions/tests.py
tests/expressions_case/__init__.py
tests/expressions_case/models.py
tests/expressions_case/tests.py
tests/extra_regress/__init__.py
tests/extra_regress/models.py
tests/extra_regress/tests.py
tests/field_deconstruction/__init__.py
tests/field_deconstruction/tests.py
tests/field_defaults/__init__.py
tests/field_defaults/models.py
tests/field_defaults/tests.py
tests/field_subclassing/__init__.py
tests/field_subclassing/fields.py
tests/field_subclassing/tests.py
tests/file_storage/__init__.py
tests/file_storage/models.py
tests/file_storage/test_generate_filename.py
tests/file_storage/tests.py
tests/file_storage/urls.py
tests/file_uploads/__init__.py
tests/file_uploads/models.py
tests/file_uploads/tests.py
tests/file_uploads/uploadhandler.py
tests/file_uploads/urls.py
tests/file_uploads/views.py
tests/files/__init__.py
tests/files/brokenimg.png
tests/files/magic.png
tests/files/test.png
tests/files/test1.png
tests/files/tests.py
tests/fixtures/__init__.py
tests/fixtures/models.py
tests/fixtures/tests.py
tests/fixtures/fixtures/db_fixture_1.default.json
tests/fixtures/fixtures/db_fixture_2.default.json.gz
tests/fixtures/fixtures/db_fixture_3.nosuchdb.json
tests/fixtures/fixtures/fixture1.json
tests/fixtures/fixtures/fixture2.json
tests/fixtures/fixtures/fixture2.xml
tests/fixtures/fixtures/fixture3.xml
tests/fixtures/fixtures/fixture4.json.zip
tests/fixtures/fixtures/fixture5.json.gz
tests/fixtures/fixtures/fixture5.json.zip
tests/fixtures/fixtures/fixture6.json
tests/fixtures/fixtures/fixture7.xml
tests/fixtures/fixtures/fixture8.json
tests/fixtures/fixtures/fixture9.xml
tests/fixtures/fixtures/fixture_with[special]chars.json
tests/fixtures/fixtures/invalid.json
tests/fixtures_model_package/__init__.py
tests/fixtures_model_package/tests.py
tests/fixtures_model_package/fixtures/fixture1.json
tests/fixtures_model_package/fixtures/fixture2.json
tests/fixtures_model_package/fixtures/fixture2.xml
tests/fixtures_model_package/models/__init__.py
tests/fixtures_regress/__init__.py
tests/fixtures_regress/models.py
tests/fixtures_regress/tests.py
tests/fixtures_regress/fixtures/absolute.json
tests/fixtures_regress/fixtures/animal.xml
tests/fixtures_regress/fixtures/bad_fixture1.unkn
tests/fixtures_regress/fixtures/bad_fixture2.xml
tests/fixtures_regress/fixtures/big-fixture.json
tests/fixtures_regress/fixtures/empty.json
tests/fixtures_regress/fixtures/feature.json
tests/fixtures_regress/fixtures/forward_ref.json
tests/fixtures_regress/fixtures/forward_ref_bad_data.json
tests/fixtures_regress/fixtures/forward_ref_lookup.json
tests/fixtures_regress/fixtures/m2mtoself.json
tests/fixtures_regress/fixtures/model-inheritance.json
tests/fixtures_regress/fixtures/nk-inheritance.json
tests/fixtures_regress/fixtures/nk-inheritance2.xml
tests/fixtures_regress/fixtures/non_natural_1.json
tests/fixtures_regress/fixtures/non_natural_2.xml
tests/fixtures_regress/fixtures/path.containing.dots.json
tests/fixtures_regress/fixtures/pretty.xml
tests/fixtures_regress/fixtures/sequence.json
tests/fixtures_regress/fixtures/sequence_extra.json
tests/fixtures_regress/fixtures/sequence_extra_xml.xml
tests/fixtures_regress/fixtures/special-article.json
tests/fixtures_regress/fixtures/thingy.json
tests/fixtures_regress/fixtures_1/forward_ref_1.json
tests/fixtures_regress/fixtures_1/inner/absolute.json
tests/fixtures_regress/fixtures_2/forward_ref_2.json
tests/flatpages_tests/__init__.py
tests/flatpages_tests/settings.py
tests/flatpages_tests/test_csrf.py
tests/flatpages_tests/test_forms.py
tests/flatpages_tests/test_middleware.py
tests/flatpages_tests/test_models.py
tests/flatpages_tests/test_sitemaps.py
tests/flatpages_tests/test_templatetags.py
tests/flatpages_tests/test_views.py
tests/flatpages_tests/urls.py
tests/flatpages_tests/templates/flatpages/default.html
tests/flatpages_tests/templates/registration/login.html
tests/force_insert_update/__init__.py
tests/force_insert_update/models.py
tests/force_insert_update/tests.py
tests/foreign_object/__init__.py
tests/foreign_object/test_agnostic_order_trimjoin.py
tests/foreign_object/test_empty_join.py
tests/foreign_object/test_forms.py
tests/foreign_object/tests.py
tests/foreign_object/models/__init__.py
tests/foreign_object/models/article.py
tests/foreign_object/models/customers.py
tests/foreign_object/models/empty_join.py
tests/foreign_object/models/person.py
tests/forms_tests/__init__.py
tests/forms_tests/models.py
tests/forms_tests/urls.py
tests/forms_tests/views.py
tests/forms_tests/field_tests/__init__.py
tests/forms_tests/field_tests/test_base.py
tests/forms_tests/field_tests/test_booleanfield.py
tests/forms_tests/field_tests/test_charfield.py
tests/forms_tests/field_tests/test_choicefield.py
tests/forms_tests/field_tests/test_combofield.py
tests/forms_tests/field_tests/test_datefield.py
tests/forms_tests/field_tests/test_datetimefield.py
tests/forms_tests/field_tests/test_decimalfield.py
tests/forms_tests/field_tests/test_durationfield.py
tests/forms_tests/field_tests/test_emailfield.py
tests/forms_tests/field_tests/test_filefield.py
tests/forms_tests/field_tests/test_filepathfield.py
tests/forms_tests/field_tests/test_floatfield.py
tests/forms_tests/field_tests/test_genericipaddressfield.py
tests/forms_tests/field_tests/test_imagefield.py
tests/forms_tests/field_tests/test_integerfield.py
tests/forms_tests/field_tests/test_multiplechoicefield.py
tests/forms_tests/field_tests/test_multivaluefield.py
tests/forms_tests/field_tests/test_nullbooleanfield.py
tests/forms_tests/field_tests/test_regexfield.py
tests/forms_tests/field_tests/test_slugfield.py
tests/forms_tests/field_tests/test_splitdatetimefield.py
tests/forms_tests/field_tests/test_timefield.py
tests/forms_tests/field_tests/test_typedchoicefield.py
tests/forms_tests/field_tests/test_typedmultiplechoicefield.py
tests/forms_tests/field_tests/test_urlfield.py
tests/forms_tests/field_tests/test_uuidfield.py
tests/forms_tests/jinja2/forms_tests/custom_widget.html
tests/forms_tests/templates/forms_tests/article_form.html
tests/forms_tests/templates/forms_tests/custom_widget.html
tests/forms_tests/tests/__init__.py
tests/forms_tests/tests/test_error_messages.py
tests/forms_tests/tests/test_forms.py
tests/forms_tests/tests/test_formsets.py
tests/forms_tests/tests/test_i18n.py
tests/forms_tests/tests/test_input_formats.py
tests/forms_tests/tests/test_media.py
tests/forms_tests/tests/test_renderers.py
tests/forms_tests/tests/test_utils.py
tests/forms_tests/tests/test_validators.py
tests/forms_tests/tests/test_widgets.py
tests/forms_tests/tests/tests.py
tests/forms_tests/tests/filepath_test_files/.dot-file
tests/forms_tests/tests/filepath_test_files/1x1.bmp
tests/forms_tests/tests/filepath_test_files/1x1.png
tests/forms_tests/tests/filepath_test_files/fake-image.jpg
tests/forms_tests/tests/filepath_test_files/real-text-file.txt
tests/forms_tests/tests/filepath_test_files/directory/.keep
tests/forms_tests/widget_tests/__init__.py
tests/forms_tests/widget_tests/base.py
tests/forms_tests/widget_tests/test_checkboxinput.py
tests/forms_tests/widget_tests/test_checkboxselectmultiple.py
tests/forms_tests/widget_tests/test_clearablefileinput.py
tests/forms_tests/widget_tests/test_dateinput.py
tests/forms_tests/widget_tests/test_datetimeinput.py
tests/forms_tests/widget_tests/test_fileinput.py
tests/forms_tests/widget_tests/test_hiddeninput.py
tests/forms_tests/widget_tests/test_input.py
tests/forms_tests/widget_tests/test_multiplehiddeninput.py
tests/forms_tests/widget_tests/test_multiwidget.py
tests/forms_tests/widget_tests/test_nullbooleanselect.py
tests/forms_tests/widget_tests/test_numberinput.py
tests/forms_tests/widget_tests/test_passwordinput.py
tests/forms_tests/widget_tests/test_radioselect.py
tests/forms_tests/widget_tests/test_render_deprecation.py
tests/forms_tests/widget_tests/test_select.py
tests/forms_tests/widget_tests/test_selectdatewidget.py
tests/forms_tests/widget_tests/test_selectmultiple.py
tests/forms_tests/widget_tests/test_splitdatetimewidget.py
tests/forms_tests/widget_tests/test_splithiddendatetimewidget.py
tests/forms_tests/widget_tests/test_textarea.py
tests/forms_tests/widget_tests/test_textinput.py
tests/forms_tests/widget_tests/test_timeinput.py
tests/forms_tests/widget_tests/test_widget.py
tests/from_db_value/__init__.py
tests/from_db_value/models.py
tests/from_db_value/tests.py
tests/generic_inline_admin/__init__.py
tests/generic_inline_admin/admin.py
tests/generic_inline_admin/models.py
tests/generic_inline_admin/tests.py
tests/generic_inline_admin/urls.py
tests/generic_relations/__init__.py
tests/generic_relations/models.py
tests/generic_relations/tests.py
tests/generic_relations_regress/__init__.py
tests/generic_relations_regress/models.py
tests/generic_relations_regress/tests.py
tests/generic_views/__init__.py
tests/generic_views/forms.py
tests/generic_views/models.py
tests/generic_views/test_base.py
tests/generic_views/test_dates.py
tests/generic_views/test_detail.py
tests/generic_views/test_edit.py
tests/generic_views/test_list.py
tests/generic_views/urls.py
tests/generic_views/views.py
tests/generic_views/jinja2/generic_views/using.html
tests/generic_views/templates/generic_views/about.html
tests/generic_views/templates/generic_views/apple_detail.html
tests/generic_views/templates/generic_views/artist_detail.html
tests/generic_views/templates/generic_views/artist_form.html
tests/generic_views/templates/generic_views/author_confirm_delete.html
tests/generic_views/templates/generic_views/author_detail.html
tests/generic_views/templates/generic_views/author_form.html
tests/generic_views/templates/generic_views/author_list.html
tests/generic_views/templates/generic_views/author_objects.html
tests/generic_views/templates/generic_views/author_view.html
tests/generic_views/templates/generic_views/book_archive.html
tests/generic_views/templates/generic_views/book_archive_day.html
tests/generic_views/templates/generic_views/book_archive_month.html
tests/generic_views/templates/generic_views/book_archive_week.html
tests/generic_views/templates/generic_views/book_archive_year.html
tests/generic_views/templates/generic_views/book_detail.html
tests/generic_views/templates/generic_views/book_list.html
tests/generic_views/templates/generic_views/confirm_delete.html
tests/generic_views/templates/generic_views/detail.html
tests/generic_views/templates/generic_views/form.html
tests/generic_views/templates/generic_views/list.html
tests/generic_views/templates/generic_views/page_template.html
tests/generic_views/templates/generic_views/robots.txt
tests/generic_views/templates/generic_views/using.html
tests/generic_views/templates/registration/login.html
tests/get_earliest_or_latest/__init__.py
tests/get_earliest_or_latest/models.py
tests/get_earliest_or_latest/tests.py
tests/get_object_or_404/__init__.py
tests/get_object_or_404/models.py
tests/get_object_or_404/tests.py
tests/get_or_create/__init__.py
tests/get_or_create/models.py
tests/get_or_create/tests.py
tests/gis_tests/__init__.py
tests/gis_tests/admin.py
tests/gis_tests/models.py
tests/gis_tests/test_data.py
tests/gis_tests/test_geoforms.py
tests/gis_tests/test_geoip.py
tests/gis_tests/test_geoip2.py
tests/gis_tests/test_measure.py
tests/gis_tests/test_ptr.py
tests/gis_tests/test_spatialrefsys.py
tests/gis_tests/test_wkt.py
tests/gis_tests/tests.py
tests/gis_tests/utils.py
tests/gis_tests/data/__init__.py
tests/gis_tests/data/geometries.json
tests/gis_tests/data/texas.dbf
tests/gis_tests/data/ch-city/ch-city.dbf
tests/gis_tests/data/ch-city/ch-city.prj
tests/gis_tests/data/ch-city/ch-city.shp
tests/gis_tests/data/ch-city/ch-city.shx
tests/gis_tests/data/cities/cities.dbf
tests/gis_tests/data/cities/cities.prj
tests/gis_tests/data/cities/cities.shp
tests/gis_tests/data/cities/cities.shx
tests/gis_tests/data/counties/counties.dbf
tests/gis_tests/data/counties/counties.shp
tests/gis_tests/data/counties/counties.shx
tests/gis_tests/data/gas_lines/gas_leitung.dbf
tests/gis_tests/data/gas_lines/gas_leitung.prj
tests/gis_tests/data/gas_lines/gas_leitung.shp
tests/gis_tests/data/gas_lines/gas_leitung.shx
tests/gis_tests/data/interstates/interstates.dbf
tests/gis_tests/data/interstates/interstates.prj
tests/gis_tests/data/interstates/interstates.shp
tests/gis_tests/data/interstates/interstates.shx
tests/gis_tests/data/invalid/emptypoints.dbf
tests/gis_tests/data/invalid/emptypoints.shp
tests/gis_tests/data/invalid/emptypoints.shx
tests/gis_tests/data/rasters/__init__.py
tests/gis_tests/data/rasters/raster.numpy.txt
tests/gis_tests/data/rasters/raster.tif
tests/gis_tests/data/rasters/textrasters.py
tests/gis_tests/data/test_point/test_point.dbf
tests/gis_tests/data/test_point/test_point.prj
tests/gis_tests/data/test_point/test_point.shp
tests/gis_tests/data/test_point/test_point.shx
tests/gis_tests/data/test_poly/test_poly.dbf
tests/gis_tests/data/test_poly/test_poly.prj
tests/gis_tests/data/test_poly/test_poly.shp
tests/gis_tests/data/test_poly/test_poly.shx
tests/gis_tests/data/test_vrt/test_vrt.csv
tests/gis_tests/data/test_vrt/test_vrt.vrt
tests/gis_tests/distapp/__init__.py
tests/gis_tests/distapp/models.py
tests/gis_tests/distapp/tests.py
tests/gis_tests/distapp/fixtures/initial.json
tests/gis_tests/gdal_tests/__init__.py
tests/gis_tests/gdal_tests/test_driver.py
tests/gis_tests/gdal_tests/test_ds.py
tests/gis_tests/gdal_tests/test_envelope.py
tests/gis_tests/gdal_tests/test_geom.py
tests/gis_tests/gdal_tests/test_raster.py
tests/gis_tests/gdal_tests/test_srs.py
tests/gis_tests/geo3d/__init__.py
tests/gis_tests/geo3d/models.py
tests/gis_tests/geo3d/tests.py
tests/gis_tests/geo3d/views.py
tests/gis_tests/geoadmin/__init__.py
tests/gis_tests/geoadmin/admin.py
tests/gis_tests/geoadmin/models.py
tests/gis_tests/geoadmin/tests.py
tests/gis_tests/geoadmin/urls.py
tests/gis_tests/geoapp/__init__.py
tests/gis_tests/geoapp/feeds.py
tests/gis_tests/geoapp/models.py
tests/gis_tests/geoapp/sitemaps.py
tests/gis_tests/geoapp/test_expressions.py
tests/gis_tests/geoapp/test_feeds.py
tests/gis_tests/geoapp/test_functions.py
tests/gis_tests/geoapp/test_regress.py
tests/gis_tests/geoapp/test_serializers.py
tests/gis_tests/geoapp/test_sitemaps.py
tests/gis_tests/geoapp/tests.py
tests/gis_tests/geoapp/urls.py
tests/gis_tests/geoapp/fixtures/initial.json.gz
tests/gis_tests/geogapp/__init__.py
tests/gis_tests/geogapp/models.py
tests/gis_tests/geogapp/tests.py
tests/gis_tests/geogapp/fixtures/initial.json
tests/gis_tests/geos_tests/__init__.py
tests/gis_tests/geos_tests/test_geos.py
tests/gis_tests/geos_tests/test_geos_mutation.py
tests/gis_tests/geos_tests/test_io.py
tests/gis_tests/geos_tests/test_mutable_list.py
tests/gis_tests/gis_migrations/__init__.py
tests/gis_tests/gis_migrations/test_commands.py
tests/gis_tests/gis_migrations/test_operations.py
tests/gis_tests/gis_migrations/migrations/0001_initial.py
tests/gis_tests/gis_migrations/migrations/__init__.py
tests/gis_tests/inspectapp/__init__.py
tests/gis_tests/inspectapp/models.py
tests/gis_tests/inspectapp/tests.py
tests/gis_tests/layermap/__init__.py
tests/gis_tests/layermap/models.py
tests/gis_tests/layermap/tests.py
tests/gis_tests/maps/__init__.py
tests/gis_tests/rasterapp/__init__.py
tests/gis_tests/rasterapp/models.py
tests/gis_tests/rasterapp/test_rasterfield.py
tests/gis_tests/relatedapp/__init__.py
tests/gis_tests/relatedapp/models.py
tests/gis_tests/relatedapp/tests.py
tests/gis_tests/relatedapp/fixtures/initial.json
tests/handlers/__init__.py
tests/handlers/test_exception.py
tests/handlers/tests.py
tests/handlers/tests_custom_error_handlers.py
tests/handlers/urls.py
tests/handlers/views.py
tests/handlers/templates/test_handler.html
tests/httpwrappers/__init__.py
tests/httpwrappers/abc.txt
tests/httpwrappers/tests.py
tests/humanize_tests/__init__.py
tests/humanize_tests/tests.py
tests/i18n/__init__.py
tests/i18n/forms.py
tests/i18n/models.py
tests/i18n/test_compilation.py
tests/i18n/test_extraction.py
tests/i18n/test_management.py
tests/i18n/test_percents.py
tests/i18n/tests.py
tests/i18n/urls.py
tests/i18n/urls_default_unprefixed.py
tests/i18n/utils.py
tests/i18n/commands/__init__.py
tests/i18n/commands/code.sample
tests/i18n/commands/javascript.js
tests/i18n/commands/not_utf8.sample
tests/i18n/commands/app_with_locale/locale/ru/LC_MESSAGES/django.po
tests/i18n/commands/ignore_dir/ignored.html
tests/i18n/commands/locale/en/LC_MESSAGES/django.mo
tests/i18n/commands/locale/en/LC_MESSAGES/django.po
tests/i18n/commands/locale/es_AR/LC_MESSAGES/django.po
tests/i18n/commands/locale/fr/LC_MESSAGES/django.po
tests/i18n/commands/locale/hr/LC_MESSAGES/django.po
tests/i18n/commands/locale/ja/LC_MESSAGES/django.po
tests/i18n/commands/locale/ko/LC_MESSAGES/django.po
tests/i18n/commands/locale/pt_BR/LC_MESSAGES/django.pristine
tests/i18n/commands/locale/ru/LC_MESSAGES/django.po
tests/i18n/commands/locale/xxx/LC_MESSAGES/django.mo
tests/i18n/commands/locale/xxx/LC_MESSAGES/django.po
tests/i18n/commands/media_root/media_ignored.html
tests/i18n/commands/someapp/static/javascript.js
tests/i18n/commands/static/javascript_ignored.js
tests/i18n/commands/static/static_ignored.html
tests/i18n/commands/templates/comments.thtml
tests/i18n/commands/templates/empty.html
tests/i18n/commands/templates/plural.djtpl
tests/i18n/commands/templates/template_with_error.tpl
tests/i18n/commands/templates/test.html
tests/i18n/commands/templates/xxx_ignored.html
tests/i18n/commands/templates/subdir/ignored.html
tests/i18n/contenttypes/__init__.py
tests/i18n/contenttypes/tests.py
tests/i18n/contenttypes/locale/en/LC_MESSAGES/django.mo
tests/i18n/contenttypes/locale/en/LC_MESSAGES/django.po
tests/i18n/contenttypes/locale/fr/LC_MESSAGES/django.mo
tests/i18n/contenttypes/locale/fr/LC_MESSAGES/django.po
tests/i18n/exclude/__init__.py
tests/i18n/exclude/canned_locale/en/LC_MESSAGES/django.po
tests/i18n/exclude/canned_locale/fr/LC_MESSAGES/django.po
tests/i18n/exclude/canned_locale/it/LC_MESSAGES/django.po
tests/i18n/other/__init__.py
tests/i18n/other/locale/__init__.py
tests/i18n/other/locale/de/__init__.py
tests/i18n/other/locale/de/formats.py
tests/i18n/other/locale/de/LC_MESSAGES/django.mo
tests/i18n/other/locale/de/LC_MESSAGES/django.po
tests/i18n/other/locale/fr/__init__.py
tests/i18n/other/locale/fr/formats.py
tests/i18n/other/locale/fr/LC_MESSAGES/django.mo
tests/i18n/other/locale/fr/LC_MESSAGES/django.po
tests/i18n/other2/__init__.py
tests/i18n/other2/locale/__init__.py
tests/i18n/other2/locale/de/__init__.py
tests/i18n/other2/locale/de/formats.py
tests/i18n/patterns/__init__.py
tests/i18n/patterns/tests.py
tests/i18n/patterns/locale/en/LC_MESSAGES/django.mo
tests/i18n/patterns/locale/en/LC_MESSAGES/django.po
tests/i18n/patterns/locale/nl/LC_MESSAGES/django.mo
tests/i18n/patterns/locale/nl/LC_MESSAGES/django.po
tests/i18n/patterns/locale/pt_BR/LC_MESSAGES/django.mo
tests/i18n/patterns/locale/pt_BR/LC_MESSAGES/django.po
tests/i18n/patterns/templates/404.html
tests/i18n/patterns/templates/dummy.html
tests/i18n/patterns/urls/__init__.py
tests/i18n/patterns/urls/default.py
tests/i18n/patterns/urls/disabled.py
tests/i18n/patterns/urls/included.py
tests/i18n/patterns/urls/namespace.py
tests/i18n/patterns/urls/path_unused.py
tests/i18n/patterns/urls/wrong.py
tests/i18n/patterns/urls/wrong_namespace.py
tests/i18n/project_dir/__init__.py
tests/i18n/project_dir/app_no_locale/__init__.py
tests/i18n/project_dir/app_no_locale/models.py
tests/i18n/project_dir/app_with_locale/__init__.py
tests/i18n/project_dir/app_with_locale/models.py
tests/i18n/project_dir/app_with_locale/locale/.gitkeep
tests/i18n/project_dir/project_locale/.gitkeep
tests/i18n/resolution/__init__.py
tests/i18n/resolution/locale/de/LC_MESSAGES/django.mo
tests/i18n/resolution/locale/de/LC_MESSAGES/django.po
tests/i18n/sampleproject/manage.py
tests/i18n/sampleproject/update_catalogs.py
tests/i18n/sampleproject/locale/fr/LC_MESSAGES/django.mo
tests/i18n/sampleproject/locale/fr/LC_MESSAGES/django.po
tests/i18n/sampleproject/sampleproject/__init__.py
tests/i18n/sampleproject/sampleproject/settings.py
tests/i18n/sampleproject/templates/percents.html
tests/import_error_package/__init__.py
tests/indexes/__init__.py
tests/indexes/models.py
tests/indexes/tests.py
tests/inline_formsets/__init__.py
tests/inline_formsets/models.py
tests/inline_formsets/tests.py
tests/inspectdb/__init__.py
tests/inspectdb/models.py
tests/inspectdb/tests.py
tests/introspection/__init__.py
tests/introspection/models.py
tests/introspection/tests.py
tests/invalid_models_tests/__init__.py
tests/invalid_models_tests/test_backend_specific.py
tests/invalid_models_tests/test_custom_fields.py
tests/invalid_models_tests/test_deprecated_fields.py
tests/invalid_models_tests/test_models.py
tests/invalid_models_tests/test_ordinary_fields.py
tests/invalid_models_tests/test_relative_fields.py
tests/known_related_objects/__init__.py
tests/known_related_objects/models.py
tests/known_related_objects/tests.py
tests/logging_tests/__init__.py
tests/logging_tests/logconfig.py
tests/logging_tests/tests.py
tests/logging_tests/urls.py
tests/logging_tests/urls_i18n.py
tests/logging_tests/views.py
tests/lookup/__init__.py
tests/lookup/models.py
tests/lookup/test_decimalfield.py
tests/lookup/test_timefield.py
tests/lookup/tests.py
tests/m2m_and_m2o/__init__.py
tests/m2m_and_m2o/models.py
tests/m2m_and_m2o/tests.py
tests/m2m_intermediary/__init__.py
tests/m2m_intermediary/models.py
tests/m2m_intermediary/tests.py
tests/m2m_multiple/__init__.py
tests/m2m_multiple/models.py
tests/m2m_multiple/tests.py
tests/m2m_recursive/__init__.py
tests/m2m_recursive/models.py
tests/m2m_recursive/tests.py
tests/m2m_regress/__init__.py
tests/m2m_regress/models.py
tests/m2m_regress/tests.py
tests/m2m_signals/__init__.py
tests/m2m_signals/models.py
tests/m2m_signals/tests.py
tests/m2m_through/__init__.py
tests/m2m_through/models.py
tests/m2m_through/tests.py
tests/m2m_through_regress/__init__.py
tests/m2m_through_regress/models.py
tests/m2m_through_regress/test_multitable.py
tests/m2m_through_regress/tests.py
tests/m2m_through_regress/fixtures/m2m_through.json
tests/m2o_recursive/__init__.py
tests/m2o_recursive/models.py
tests/m2o_recursive/tests.py
tests/mail/__init__.py
tests/mail/custombackend.py
tests/mail/test_sendtestemail.py
tests/mail/tests.py
tests/mail/attachments/file.png
tests/mail/attachments/file.txt
tests/mail/attachments/file_png
tests/mail/attachments/file_png.txt
tests/mail/attachments/file_txt
tests/mail/attachments/file_txt.png
tests/managers_regress/__init__.py
tests/managers_regress/models.py
tests/managers_regress/tests.py
tests/many_to_many/__init__.py
tests/many_to_many/models.py
tests/many_to_many/tests.py
tests/many_to_one/__init__.py
tests/many_to_one/models.py
tests/many_to_one/tests.py
tests/many_to_one_null/__init__.py
tests/many_to_one_null/models.py
tests/many_to_one_null/tests.py
tests/max_lengths/__init__.py
tests/max_lengths/models.py
tests/max_lengths/tests.py
tests/messages_tests/__init__.py
tests/messages_tests/base.py
tests/messages_tests/test_api.py
tests/messages_tests/test_cookie.py
tests/messages_tests/test_fallback.py
tests/messages_tests/test_middleware.py
tests/messages_tests/test_mixins.py
tests/messages_tests/test_session.py
tests/messages_tests/urls.py
tests/middleware/__init__.py
tests/middleware/cond_get_urls.py
tests/middleware/extra_urls.py
tests/middleware/test_security.py
tests/middleware/tests.py
tests/middleware/urls.py
tests/middleware/views.py
tests/middleware_exceptions/__init__.py
tests/middleware_exceptions/middleware.py
tests/middleware_exceptions/test_legacy.py
tests/middleware_exceptions/tests.py
tests/middleware_exceptions/urls.py
tests/middleware_exceptions/views.py
tests/migrate_signals/__init__.py
tests/migrate_signals/models.py
tests/migrate_signals/tests.py
tests/migrate_signals/custom_migrations/0001_initial.py
tests/migrate_signals/custom_migrations/__init__.py
tests/migration_test_data_persistence/__init__.py
tests/migration_test_data_persistence/models.py
tests/migration_test_data_persistence/tests.py
tests/migration_test_data_persistence/migrations/0001_initial.py
tests/migration_test_data_persistence/migrations/0002_add_book.py
tests/migration_test_data_persistence/migrations/__init__.py
tests/migrations/__init__.py
tests/migrations/models.py
tests/migrations/routers.py
tests/migrations/test_autodetector.py
tests/migrations/test_base.py
tests/migrations/test_commands.py
tests/migrations/test_deprecated_fields.py
tests/migrations/test_exceptions.py
tests/migrations/test_executor.py
tests/migrations/test_graph.py
tests/migrations/test_loader.py
tests/migrations/test_multidb.py
tests/migrations/test_operations.py
tests/migrations/test_optimizer.py
tests/migrations/test_questioner.py
tests/migrations/test_state.py
tests/migrations/test_writer.py
tests/migrations/deprecated_field_migrations/0001_initial.py
tests/migrations/deprecated_field_migrations/0002_remove_ipaddressfield_ip.py
tests/migrations/deprecated_field_migrations/__init__.py
tests/migrations/faulty_migrations/__init__.py
tests/migrations/faulty_migrations/file.py
tests/migrations/faulty_migrations/namespace/foo/__init__.py
tests/migrations/migrations_test_apps/__init__.py
tests/migrations/migrations_test_apps/alter_fk/__init__.py
tests/migrations/migrations_test_apps/alter_fk/author_app/__init__.py
tests/migrations/migrations_test_apps/alter_fk/author_app/migrations/0001_initial.py
tests/migrations/migrations_test_apps/alter_fk/author_app/migrations/0002_alter_id.py
tests/migrations/migrations_test_apps/alter_fk/author_app/migrations/__init__.py
tests/migrations/migrations_test_apps/alter_fk/book_app/__init__.py
tests/migrations/migrations_test_apps/alter_fk/book_app/migrations/0001_initial.py
tests/migrations/migrations_test_apps/alter_fk/book_app/migrations/__init__.py
tests/migrations/migrations_test_apps/conflicting_app_with_dependencies/__init__.py
tests/migrations/migrations_test_apps/conflicting_app_with_dependencies/migrations/0001_initial.py
tests/migrations/migrations_test_apps/conflicting_app_with_dependencies/migrations/0002_conflicting_second.py
tests/migrations/migrations_test_apps/conflicting_app_with_dependencies/migrations/0002_second.py
tests/migrations/migrations_test_apps/conflicting_app_with_dependencies/migrations/__init__.py
tests/migrations/migrations_test_apps/lookuperror_a/__init__.py
tests/migrations/migrations_test_apps/lookuperror_a/models.py
tests/migrations/migrations_test_apps/lookuperror_a/migrations/0001_initial.py
tests/migrations/migrations_test_apps/lookuperror_a/migrations/0002_a2.py
tests/migrations/migrations_test_apps/lookuperror_a/migrations/0003_a3.py
tests/migrations/migrations_test_apps/lookuperror_a/migrations/0004_a4.py
tests/migrations/migrations_test_apps/lookuperror_a/migrations/__init__.py
tests/migrations/migrations_test_apps/lookuperror_b/__init__.py
tests/migrations/migrations_test_apps/lookuperror_b/models.py
tests/migrations/migrations_test_apps/lookuperror_b/migrations/0001_initial.py
tests/migrations/migrations_test_apps/lookuperror_b/migrations/0002_b2.py
tests/migrations/migrations_test_apps/lookuperror_b/migrations/0003_b3.py
tests/migrations/migrations_test_apps/lookuperror_b/migrations/__init__.py
tests/migrations/migrations_test_apps/lookuperror_c/__init__.py
tests/migrations/migrations_test_apps/lookuperror_c/models.py
tests/migrations/migrations_test_apps/lookuperror_c/migrations/0001_initial.py
tests/migrations/migrations_test_apps/lookuperror_c/migrations/0002_c2.py
tests/migrations/migrations_test_apps/lookuperror_c/migrations/0003_c3.py
tests/migrations/migrations_test_apps/lookuperror_c/migrations/__init__.py
tests/migrations/migrations_test_apps/migrated_app/__init__.py
tests/migrations/migrations_test_apps/migrated_app/models.py
tests/migrations/migrations_test_apps/migrated_app/migrations/0001_initial.py
tests/migrations/migrations_test_apps/migrated_app/migrations/__init__.py
tests/migrations/migrations_test_apps/migrated_unapplied_app/__init__.py
tests/migrations/migrations_test_apps/migrated_unapplied_app/models.py
tests/migrations/migrations_test_apps/migrated_unapplied_app/migrations/0001_initial.py
tests/migrations/migrations_test_apps/migrated_unapplied_app/migrations/__init__.py
tests/migrations/migrations_test_apps/mutate_state_a/__init__.py
tests/migrations/migrations_test_apps/mutate_state_a/migrations/0001_initial.py
tests/migrations/migrations_test_apps/mutate_state_a/migrations/__init__.py
tests/migrations/migrations_test_apps/mutate_state_b/__init__.py
tests/migrations/migrations_test_apps/mutate_state_b/migrations/0001_initial.py
tests/migrations/migrations_test_apps/mutate_state_b/migrations/0002_add_field.py
tests/migrations/migrations_test_apps/mutate_state_b/migrations/__init__.py
tests/migrations/migrations_test_apps/normal/__init__.py
tests/migrations/migrations_test_apps/unmigrated_app/__init__.py
tests/migrations/migrations_test_apps/unmigrated_app/models.py
tests/migrations/migrations_test_apps/unmigrated_app_syncdb/__init__.py
tests/migrations/migrations_test_apps/unmigrated_app_syncdb/models.py
tests/migrations/migrations_test_apps/unspecified_app_with_conflict/__init__.py
tests/migrations/migrations_test_apps/unspecified_app_with_conflict/models.py
tests/migrations/migrations_test_apps/unspecified_app_with_conflict/migrations/0001_initial.py
tests/migrations/migrations_test_apps/unspecified_app_with_conflict/migrations/0002_conflicting_second.py
tests/migrations/migrations_test_apps/unspecified_app_with_conflict/migrations/0002_second.py
tests/migrations/migrations_test_apps/unspecified_app_with_conflict/migrations/__init__.py
tests/migrations/migrations_test_apps/with_package_model/__init__.py
tests/migrations/migrations_test_apps/with_package_model/models/__init__.py
tests/migrations/migrations_test_apps/without_init_file/__init__.py
tests/migrations/migrations_test_apps/without_init_file/migrations/.keep
tests/migrations/related_models_app/__init__.py
tests/migrations/test_add_many_to_many_field_initial/0001_initial.py
tests/migrations/test_add_many_to_many_field_initial/0002_initial.py
tests/migrations/test_add_many_to_many_field_initial/__init__.py
tests/migrations/test_auto_now_add/0001_initial.py
tests/migrations/test_auto_now_add/__init__.py
tests/migrations/test_migrations/0001_initial.py
tests/migrations/test_migrations/0002_second.py
tests/migrations/test_migrations/__init__.py
tests/migrations/test_migrations_atomic_operation/0001_initial.py
tests/migrations/test_migrations_atomic_operation/__init__.py
tests/migrations/test_migrations_backwards_deps_1/0001_initial.py
tests/migrations/test_migrations_backwards_deps_1/0002_second.py
tests/migrations/test_migrations_conflict/0001_initial.py
tests/migrations/test_migrations_conflict/0002_conflicting_second.py
tests/migrations/test_migrations_conflict/0002_second.py
tests/migrations/test_migrations_conflict/__init__.py
tests/migrations/test_migrations_custom_user/0001_initial.py
tests/migrations/test_migrations_custom_user/__init__.py
tests/migrations/test_migrations_empty/__init__.py
tests/migrations/test_migrations_fake_split_initial/0001_initial.py
tests/migrations/test_migrations_fake_split_initial/0002_second.py
tests/migrations/test_migrations_fake_split_initial/__init__.py
tests/migrations/test_migrations_first/__init__.py
tests/migrations/test_migrations_first/second.py
tests/migrations/test_migrations_first/thefirst.py
tests/migrations/test_migrations_initial_false/0001_not_initial.py
tests/migrations/test_migrations_initial_false/__init__.py
tests/migrations/test_migrations_no_ancestor/0001_initial.py
tests/migrations/test_migrations_no_ancestor/0002_conflicting_second.py
tests/migrations/test_migrations_no_ancestor/0002_second.py
tests/migrations/test_migrations_no_ancestor/__init__.py
tests/migrations/test_migrations_no_changes/0001_initial.py
tests/migrations/test_migrations_no_changes/0002_second.py
tests/migrations/test_migrations_no_changes/0003_third.py
tests/migrations/test_migrations_no_changes/__init__.py
tests/migrations/test_migrations_no_default/0001_initial.py
tests/migrations/test_migrations_no_default/__init__.py
tests/migrations/test_migrations_non_atomic/0001_initial.py
tests/migrations/test_migrations_non_atomic/__init__.py
tests/migrations/test_migrations_order/0001.py
tests/migrations/test_migrations_order/__init__.py
tests/migrations/test_migrations_run_before/0001_initial.py
tests/migrations/test_migrations_run_before/0002_second.py
tests/migrations/test_migrations_run_before/0003_third.py
tests/migrations/test_migrations_run_before/__init__.py
tests/migrations/test_migrations_squash_noop/0001_initial.py
tests/migrations/test_migrations_squash_noop/0002_second.py
tests/migrations/test_migrations_squash_noop/__init__.py
tests/migrations/test_migrations_squashed/0001_initial.py
tests/migrations/test_migrations_squashed/0001_squashed_0002.py
tests/migrations/test_migrations_squashed/0002_second.py
tests/migrations/test_migrations_squashed/__init__.py
tests/migrations/test_migrations_squashed_complex/1_auto.py
tests/migrations/test_migrations_squashed_complex/2_auto.py
tests/migrations/test_migrations_squashed_complex/3_auto.py
tests/migrations/test_migrations_squashed_complex/3_squashed_5.py
tests/migrations/test_migrations_squashed_complex/4_auto.py
tests/migrations/test_migrations_squashed_complex/5_auto.py
tests/migrations/test_migrations_squashed_complex/6_auto.py
tests/migrations/test_migrations_squashed_complex/7_auto.py
tests/migrations/test_migrations_squashed_complex/__init__.py
tests/migrations/test_migrations_squashed_complex_multi_apps/__init__.py
tests/migrations/test_migrations_squashed_complex_multi_apps/app1/1_auto.py
tests/migrations/test_migrations_squashed_complex_multi_apps/app1/2_auto.py
tests/migrations/test_migrations_squashed_complex_multi_apps/app1/2_squashed_3.py
tests/migrations/test_migrations_squashed_complex_multi_apps/app1/3_auto.py
tests/migrations/test_migrations_squashed_complex_multi_apps/app1/4_auto.py
tests/migrations/test_migrations_squashed_complex_multi_apps/app1/__init__.py
tests/migrations/test_migrations_squashed_complex_multi_apps/app2/1_auto.py
tests/migrations/test_migrations_squashed_complex_multi_apps/app2/1_squashed_2.py
tests/migrations/test_migrations_squashed_complex_multi_apps/app2/2_auto.py
tests/migrations/test_migrations_squashed_complex_multi_apps/app2/__init__.py
tests/migrations/test_migrations_squashed_erroneous/1_auto.py
tests/migrations/test_migrations_squashed_erroneous/2_auto.py
tests/migrations/test_migrations_squashed_erroneous/3_squashed_5.py
tests/migrations/test_migrations_squashed_erroneous/6_auto.py
tests/migrations/test_migrations_squashed_erroneous/7_auto.py
tests/migrations/test_migrations_squashed_erroneous/__init__.py
tests/migrations/test_migrations_squashed_extra/0001_initial.py
tests/migrations/test_migrations_squashed_extra/0001_squashed_0002.py
tests/migrations/test_migrations_squashed_extra/0002_second.py
tests/migrations/test_migrations_squashed_extra/0003_third.py
tests/migrations/test_migrations_squashed_extra/__init__.py
tests/migrations/test_migrations_squashed_ref_squashed/__init__.py
tests/migrations/test_migrations_squashed_ref_squashed/app1/1_auto.py
tests/migrations/test_migrations_squashed_ref_squashed/app1/2_auto.py
tests/migrations/test_migrations_squashed_ref_squashed/app1/2_squashed_3.py
tests/migrations/test_migrations_squashed_ref_squashed/app1/3_auto.py
tests/migrations/test_migrations_squashed_ref_squashed/app1/4_auto.py
tests/migrations/test_migrations_squashed_ref_squashed/app1/__init__.py
tests/migrations/test_migrations_squashed_ref_squashed/app2/1_auto.py
tests/migrations/test_migrations_squashed_ref_squashed/app2/1_squashed_2.py
tests/migrations/test_migrations_squashed_ref_squashed/app2/2_auto.py
tests/migrations/test_migrations_squashed_ref_squashed/app2/__init__.py
tests/migrations/test_migrations_unmigdep/0001_initial.py
tests/migrations/test_migrations_unmigdep/__init__.py
tests/migrations2/__init__.py
tests/migrations2/models.py
tests/migrations2/test_migrations_2/0001_initial.py
tests/migrations2/test_migrations_2/__init__.py
tests/migrations2/test_migrations_2_first/0001_initial.py
tests/migrations2/test_migrations_2_first/0002_second.py
tests/migrations2/test_migrations_2_first/__init__.py
tests/migrations2/test_migrations_2_no_deps/0001_initial.py
tests/migrations2/test_migrations_2_no_deps/__init__.py
tests/model_fields/4x8.png
tests/model_fields/8x4.png
tests/model_fields/__init__.py
tests/model_fields/models.py
tests/model_fields/test_binaryfield.py
tests/model_fields/test_booleanfield.py
tests/model_fields/test_charfield.py
tests/model_fields/test_datetimefield.py
tests/model_fields/test_decimalfield.py
tests/model_fields/test_durationfield.py
tests/model_fields/test_field_flags.py
tests/model_fields/test_filefield.py
tests/model_fields/test_floatfield.py
tests/model_fields/test_foreignkey.py
tests/model_fields/test_genericipaddressfield.py
tests/model_fields/test_imagefield.py
tests/model_fields/test_integerfield.py
tests/model_fields/test_manytomanyfield.py
tests/model_fields/test_promises.py
tests/model_fields/test_slugfield.py
tests/model_fields/test_textfield.py
tests/model_fields/test_uuid.py
tests/model_fields/tests.py
tests/model_forms/__init__.py
tests/model_forms/models.py
tests/model_forms/test.png
tests/model_forms/test2.png
tests/model_forms/test_uuid.py
tests/model_forms/tests.py
tests/model_formsets/__init__.py
tests/model_formsets/models.py
tests/model_formsets/test_uuid.py
tests/model_formsets/tests.py
tests/model_formsets_regress/__init__.py
tests/model_formsets_regress/models.py
tests/model_formsets_regress/tests.py
tests/model_indexes/__init__.py
tests/model_indexes/models.py
tests/model_indexes/tests.py
tests/model_inheritance/__init__.py
tests/model_inheritance/models.py
tests/model_inheritance/test_abstract_inheritance.py
tests/model_inheritance/tests.py
tests/model_inheritance_regress/__init__.py
tests/model_inheritance_regress/models.py
tests/model_inheritance_regress/tests.py
tests/model_meta/__init__.py
tests/model_meta/models.py
tests/model_meta/results.py
tests/model_meta/test_removedindjango21.py
tests/model_meta/tests.py
tests/model_options/__init__.py
tests/model_options/test_default_related_name.py
tests/model_options/test_tablespaces.py
tests/model_options/models/__init__.py
tests/model_options/models/default_related_name.py
tests/model_options/models/tablespaces.py
tests/model_package/__init__.py
tests/model_package/tests.py
tests/model_package/models/__init__.py
tests/model_package/models/article.py
tests/model_package/models/publication.py
tests/model_permalink/__init__.py
tests/model_permalink/models.py
tests/model_permalink/tests.py
tests/model_permalink/urls.py
tests/model_permalink/views.py
tests/model_regress/__init__.py
tests/model_regress/models.py
tests/model_regress/test_pickle.py
tests/model_regress/tests.py
tests/modeladmin/__init__.py
tests/modeladmin/models.py
tests/modeladmin/test_checks.py
tests/modeladmin/tests.py
tests/multiple_database/__init__.py
tests/multiple_database/models.py
tests/multiple_database/routers.py
tests/multiple_database/tests.py
tests/multiple_database/fixtures/multidb-common.json
tests/multiple_database/fixtures/multidb.default.json
tests/multiple_database/fixtures/multidb.other.json
tests/multiple_database/fixtures/pets.json
tests/mutually_referential/__init__.py
tests/mutually_referential/models.py
tests/mutually_referential/tests.py
tests/nested_foreign_keys/__init__.py
tests/nested_foreign_keys/models.py
tests/nested_foreign_keys/tests.py
tests/no_models/__init__.py
tests/no_models/tests.py
tests/null_fk/__init__.py
tests/null_fk/models.py
tests/null_fk/tests.py
tests/null_fk_ordering/__init__.py
tests/null_fk_ordering/models.py
tests/null_fk_ordering/tests.py
tests/null_queries/__init__.py
tests/null_queries/models.py
tests/null_queries/tests.py
tests/one_to_one/__init__.py
tests/one_to_one/models.py
tests/one_to_one/tests.py
tests/or_lookups/__init__.py
tests/or_lookups/models.py
tests/or_lookups/tests.py
tests/order_with_respect_to/__init__.py
tests/order_with_respect_to/base_tests.py
tests/order_with_respect_to/models.py
tests/order_with_respect_to/tests.py
tests/ordering/__init__.py
tests/ordering/models.py
tests/ordering/tests.py
tests/pagination/__init__.py
tests/pagination/custom.py
tests/pagination/models.py
tests/pagination/tests.py
tests/postgres_tests/__init__.py
tests/postgres_tests/fields.py
tests/postgres_tests/models.py
tests/postgres_tests/test_aggregates.py
tests/postgres_tests/test_array.py
tests/postgres_tests/test_citext.py
tests/postgres_tests/test_functions.py
tests/postgres_tests/test_hstore.py
tests/postgres_tests/test_indexes.py
tests/postgres_tests/test_json.py
tests/postgres_tests/test_ranges.py
tests/postgres_tests/test_search.py
tests/postgres_tests/test_trigram.py
tests/postgres_tests/test_unaccent.py
tests/postgres_tests/array_default_migrations/0001_initial.py
tests/postgres_tests/array_default_migrations/0002_integerarraymodel_field_2.py
tests/postgres_tests/array_default_migrations/__init__.py
tests/postgres_tests/array_index_migrations/0001_initial.py
tests/postgres_tests/array_index_migrations/__init__.py
tests/postgres_tests/migrations/0001_setup_extensions.py
tests/postgres_tests/migrations/0002_create_test_models.py
tests/postgres_tests/migrations/__init__.py
tests/prefetch_related/__init__.py
tests/prefetch_related/models.py
tests/prefetch_related/test_prefetch_related_objects.py
tests/prefetch_related/test_uuid.py
tests/prefetch_related/tests.py
tests/project_template/__init__.py
tests/project_template/test_settings.py
tests/project_template/urls.py
tests/project_template/views.py
tests/properties/__init__.py
tests/properties/models.py
tests/properties/tests.py
tests/proxy_model_inheritance/__init__.py
tests/proxy_model_inheritance/models.py
tests/proxy_model_inheritance/tests.py
tests/proxy_model_inheritance/app1/__init__.py
tests/proxy_model_inheritance/app1/models.py
tests/proxy_model_inheritance/app2/__init__.py
tests/proxy_model_inheritance/app2/models.py
tests/proxy_models/__init__.py
tests/proxy_models/admin.py
tests/proxy_models/models.py
tests/proxy_models/tests.py
tests/proxy_models/urls.py
tests/proxy_models/fixtures/mypeople.json
tests/queries/__init__.py
tests/queries/models.py
tests/queries/test_qs_combinators.py
tests/queries/tests.py
tests/queryset_pickle/__init__.py
tests/queryset_pickle/models.py
tests/queryset_pickle/tests.py
tests/raw_query/__init__.py
tests/raw_query/models.py
tests/raw_query/tests.py
tests/redirects_tests/__init__.py
tests/redirects_tests/tests.py
tests/requests/__init__.py
tests/requests/test_data_upload_settings.py
tests/requests/tests.py
tests/requirements/base.txt
tests/requirements/mysql.txt
tests/requirements/oracle.txt
tests/requirements/postgres.txt
tests/requirements/py2.txt
tests/requirements/py3.txt
tests/reserved_names/__init__.py
tests/reserved_names/models.py
tests/reserved_names/tests.py
tests/resolve_url/__init__.py
tests/resolve_url/models.py
tests/resolve_url/tests.py
tests/resolve_url/urls.py
tests/responses/__init__.py
tests/responses/tests.py
tests/reverse_lookup/__init__.py
tests/reverse_lookup/models.py
tests/reverse_lookup/tests.py
tests/save_delete_hooks/__init__.py
tests/save_delete_hooks/models.py
tests/save_delete_hooks/tests.py
tests/schema/__init__.py
tests/schema/fields.py
tests/schema/models.py
tests/schema/tests.py
tests/select_for_update/__init__.py
tests/select_for_update/models.py
tests/select_for_update/tests.py
tests/select_related/__init__.py
tests/select_related/models.py
tests/select_related/tests.py
tests/select_related_onetoone/__init__.py
tests/select_related_onetoone/models.py
tests/select_related_onetoone/tests.py
tests/select_related_regress/__init__.py
tests/select_related_regress/models.py
tests/select_related_regress/tests.py
tests/serializers/__init__.py
tests/serializers/test_data.py
tests/serializers/test_deserializedobject.py
tests/serializers/test_json.py
tests/serializers/test_natural.py
tests/serializers/test_xml.py
tests/serializers/test_yaml.py
tests/serializers/tests.py
tests/serializers/models/__init__.py
tests/serializers/models/base.py
tests/serializers/models/data.py
tests/serializers/models/natural.py
tests/servers/__init__.py
tests/servers/models.py
tests/servers/test_basehttp.py
tests/servers/test_liveserverthread.py
tests/servers/tests.py
tests/servers/urls.py
tests/servers/views.py
tests/servers/another_app/__init__.py
tests/servers/another_app/static/another_app/another_app_static_file.txt
tests/servers/fixtures/testdata.json
tests/servers/media/example_media_file.txt
tests/servers/static/example_static_file.txt
tests/sessions_tests/__init__.py
tests/sessions_tests/models.py
tests/sessions_tests/tests.py
tests/settings_tests/__init__.py
tests/settings_tests/tests.py
tests/shell/__init__.py
tests/shell/tests.py
tests/shortcuts/__init__.py
tests/shortcuts/tests.py
tests/shortcuts/urls.py
tests/shortcuts/views.py
tests/shortcuts/jinja2/shortcuts/using.html
tests/shortcuts/templates/shortcuts/render_test.html
tests/shortcuts/templates/shortcuts/using.html
tests/signals/__init__.py
tests/signals/models.py
tests/signals/tests.py
tests/signed_cookies_tests/__init__.py
tests/signed_cookies_tests/tests.py
tests/signing/__init__.py
tests/signing/tests.py
tests/sitemaps_tests/__init__.py
tests/sitemaps_tests/base.py
tests/sitemaps_tests/models.py
tests/sitemaps_tests/test_generic.py
tests/sitemaps_tests/test_http.py
tests/sitemaps_tests/test_https.py
tests/sitemaps_tests/test_management.py
tests/sitemaps_tests/test_utils.py
tests/sitemaps_tests/templates/custom_sitemap.xml
tests/sitemaps_tests/templates/custom_sitemap_index.xml
tests/sitemaps_tests/urls/__init__.py
tests/sitemaps_tests/urls/empty.py
tests/sitemaps_tests/urls/http.py
tests/sitemaps_tests/urls/https.py
tests/sitemaps_tests/urls/index_only.py
tests/sites_framework/__init__.py
tests/sites_framework/models.py
tests/sites_framework/tests.py
tests/sites_framework/migrations/0001_initial.py
tests/sites_framework/migrations/__init__.py
tests/sites_tests/__init__.py
tests/sites_tests/tests.py
tests/staticfiles_tests/__init__.py
tests/staticfiles_tests/cases.py
tests/staticfiles_tests/settings.py
tests/staticfiles_tests/storage.py
tests/staticfiles_tests/test_finders.py
tests/staticfiles_tests/test_forms.py
tests/staticfiles_tests/test_liveserver.py
tests/staticfiles_tests/test_management.py
tests/staticfiles_tests/test_storage.py
tests/staticfiles_tests/test_templatetags.py
tests/staticfiles_tests/test_views.py
tests/staticfiles_tests/apps/__init__.py
tests/staticfiles_tests/apps/staticfiles_config.py
tests/staticfiles_tests/apps/no_label/__init__.py
tests/staticfiles_tests/apps/no_label/static/file2.txt
tests/staticfiles_tests/apps/test/__init__.py
tests/staticfiles_tests/apps/test/otherdir/odfile.txt
tests/staticfiles_tests/apps/test/static/test/.hidden
tests/staticfiles_tests/apps/test/static/test/CVS
tests/staticfiles_tests/apps/test/static/test/file.txt
tests/staticfiles_tests/apps/test/static/test/file1.txt
tests/staticfiles_tests/apps/test/static/test/nonascii.css
tests/staticfiles_tests/apps/test/static/test/test.ignoreme
tests/staticfiles_tests/apps/test/static/test/window.png
tests/staticfiles_tests/apps/test/static/test/⊗.txt
tests/staticfiles_tests/project/documents/absolute_root.css
tests/staticfiles_tests/project/documents/styles_root.css
tests/staticfiles_tests/project/documents/test.txt
tests/staticfiles_tests/project/documents/cached/absolute.css
tests/staticfiles_tests/project/documents/cached/import.css
tests/staticfiles_tests/project/documents/cached/other.css
tests/staticfiles_tests/project/documents/cached/relative.css
tests/staticfiles_tests/project/documents/cached/styles.css
tests/staticfiles_tests/project/documents/cached/styles_insensitive.css
tests/staticfiles_tests/project/documents/cached/test.js
tests/staticfiles_tests/project/documents/cached/url.css
tests/staticfiles_tests/project/documents/cached/css/fragments.css
tests/staticfiles_tests/project/documents/cached/css/ignored.css
tests/staticfiles_tests/project/documents/cached/css/window.css
tests/staticfiles_tests/project/documents/cached/css/fonts/font.eot
tests/staticfiles_tests/project/documents/cached/css/fonts/font.svg
tests/staticfiles_tests/project/documents/cached/css/img/window.png
tests/staticfiles_tests/project/documents/cached/img/relative.png
tests/staticfiles_tests/project/documents/subdir/test.txt
tests/staticfiles_tests/project/documents/test/backup~
tests/staticfiles_tests/project/documents/test/camelCase.txt
tests/staticfiles_tests/project/documents/test/file.txt
tests/staticfiles_tests/project/faulty/faulty.css
tests/staticfiles_tests/project/loop/bar.css
tests/staticfiles_tests/project/loop/foo.css
tests/staticfiles_tests/project/prefixed/test.txt
tests/staticfiles_tests/project/site_media/media/media-file.txt
tests/staticfiles_tests/project/site_media/static/testfile.txt
tests/staticfiles_tests/urls/__init__.py
tests/staticfiles_tests/urls/default.py
tests/staticfiles_tests/urls/helper.py
tests/str/__init__.py
tests/str/models.py
tests/str/tests.py
tests/string_lookup/__init__.py
tests/string_lookup/models.py
tests/string_lookup/tests.py
tests/swappable_models/__init__.py
tests/swappable_models/models.py
tests/swappable_models/tests.py
tests/syndication_tests/__init__.py
tests/syndication_tests/feeds.py
tests/syndication_tests/models.py
tests/syndication_tests/tests.py
tests/syndication_tests/urls.py
tests/syndication_tests/templates/syndication/description.html
tests/syndication_tests/templates/syndication/description_context.html
tests/syndication_tests/templates/syndication/title.html
tests/syndication_tests/templates/syndication/title_context.html
tests/template_backends/__init__.py
tests/template_backends/test_django.py
tests/template_backends/test_dummy.py
tests/template_backends/test_jinja2.py
tests/template_backends/test_utils.py
tests/template_backends/apps/__init__.py
tests/template_backends/apps/good/__init__.py
tests/template_backends/apps/good/templatetags/__init__.py
tests/template_backends/apps/good/templatetags/empty.py
tests/template_backends/apps/good/templatetags/good_tags.py
tests/template_backends/apps/good/templatetags/override.py
tests/template_backends/apps/good/templatetags/subpackage/__init__.py
tests/template_backends/apps/good/templatetags/subpackage/tags.py
tests/template_backends/apps/importerror/__init__.py
tests/template_backends/apps/importerror/templatetags/__init__.py
tests/template_backends/apps/importerror/templatetags/broken_tags.py
tests/template_backends/forbidden/template_backends/hello.html
tests/template_backends/jinja2/template_backends/csrf.html
tests/template_backends/jinja2/template_backends/django_escaping.html
tests/template_backends/jinja2/template_backends/hello.html
tests/template_backends/jinja2/template_backends/syntax_error.html
tests/template_backends/jinja2/template_backends/syntax_error2.html
tests/template_backends/template_strings/template_backends/csrf.html
tests/template_backends/template_strings/template_backends/hello.html
tests/template_backends/templates/template_backends/csrf.html
tests/template_backends/templates/template_backends/django_escaping.html
tests/template_backends/templates/template_backends/hello.html
tests/template_backends/templates/template_backends/syntax_error.html
tests/template_loader/__init__.py
tests/template_loader/tests.py
tests/template_loader/template_strings/template_loader/hello.html
tests/template_loader/templates/template_loader/goodbye.html
tests/template_loader/templates/template_loader/hello.html
tests/template_loader/templates/template_loader/request.html
tests/template_tests/__init__.py
tests/template_tests/alternate_urls.py
tests/template_tests/annotated_tag_function.py
tests/template_tests/broken_tag.py
tests/template_tests/test_callables.py
tests/template_tests/test_context.py
tests/template_tests/test_custom.py
tests/template_tests/test_engine.py
tests/template_tests/test_extends.py
tests/template_tests/test_extends_relative.py
tests/template_tests/test_library.py
tests/template_tests/test_loaders.py
tests/template_tests/test_logging.py
tests/template_tests/test_nodelist.py
tests/template_tests/test_origin.py
tests/template_tests/test_parser.py
tests/template_tests/test_response.py
tests/template_tests/test_smartif.py
tests/template_tests/test_unicode.py
tests/template_tests/tests.py
tests/template_tests/urls.py
tests/template_tests/utils.py
tests/template_tests/views.py
tests/template_tests/eggs/tagsegg.egg
tests/template_tests/filter_tests/__init__.py
tests/template_tests/filter_tests/test_add.py
tests/template_tests/filter_tests/test_addslashes.py
tests/template_tests/filter_tests/test_autoescape.py
tests/template_tests/filter_tests/test_capfirst.py
tests/template_tests/filter_tests/test_center.py
tests/template_tests/filter_tests/test_chaining.py
tests/template_tests/filter_tests/test_cut.py
tests/template_tests/filter_tests/test_date.py
tests/template_tests/filter_tests/test_default.py
tests/template_tests/filter_tests/test_default_if_none.py
tests/template_tests/filter_tests/test_dictsort.py
tests/template_tests/filter_tests/test_dictsortreversed.py
tests/template_tests/filter_tests/test_divisibleby.py
tests/template_tests/filter_tests/test_escape.py
tests/template_tests/filter_tests/test_escapejs.py
tests/template_tests/filter_tests/test_filesizeformat.py
tests/template_tests/filter_tests/test_first.py
tests/template_tests/filter_tests/test_floatformat.py
tests/template_tests/filter_tests/test_force_escape.py
tests/template_tests/filter_tests/test_get_digit.py
tests/template_tests/filter_tests/test_iriencode.py
tests/template_tests/filter_tests/test_join.py
tests/template_tests/filter_tests/test_last.py
tests/template_tests/filter_tests/test_length.py
tests/template_tests/filter_tests/test_length_is.py
tests/template_tests/filter_tests/test_linebreaks.py
tests/template_tests/filter_tests/test_linebreaksbr.py
tests/template_tests/filter_tests/test_linenumbers.py
tests/template_tests/filter_tests/test_ljust.py
tests/template_tests/filter_tests/test_lower.py
tests/template_tests/filter_tests/test_make_list.py
tests/template_tests/filter_tests/test_phone2numeric.py
tests/template_tests/filter_tests/test_pluralize.py
tests/template_tests/filter_tests/test_random.py
tests/template_tests/filter_tests/test_rjust.py
tests/template_tests/filter_tests/test_safe.py
tests/template_tests/filter_tests/test_safeseq.py
tests/template_tests/filter_tests/test_slice.py
tests/template_tests/filter_tests/test_slugify.py
tests/template_tests/filter_tests/test_stringformat.py
tests/template_tests/filter_tests/test_striptags.py
tests/template_tests/filter_tests/test_time.py
tests/template_tests/filter_tests/test_timesince.py
tests/template_tests/filter_tests/test_timeuntil.py
tests/template_tests/filter_tests/test_title.py
tests/template_tests/filter_tests/test_truncatechars.py
tests/template_tests/filter_tests/test_truncatechars_html.py
tests/template_tests/filter_tests/test_truncatewords.py
tests/template_tests/filter_tests/test_truncatewords_html.py
tests/template_tests/filter_tests/test_unordered_list.py
tests/template_tests/filter_tests/test_upper.py
tests/template_tests/filter_tests/test_urlencode.py
tests/template_tests/filter_tests/test_urlize.py
tests/template_tests/filter_tests/test_urlizetrunc.py
tests/template_tests/filter_tests/test_wordcount.py
tests/template_tests/filter_tests/test_wordwrap.py
tests/template_tests/filter_tests/test_yesno.py
tests/template_tests/filter_tests/timezone_utils.py
tests/template_tests/jinja2/template_tests/using.html
tests/template_tests/other_templates/test_dirs.html
tests/template_tests/other_templates/priority/foo.html
tests/template_tests/recursive_templates/fs/extend-missing.html
tests/template_tests/recursive_templates/fs/one.html
tests/template_tests/recursive_templates/fs/other-recursive.html
tests/template_tests/recursive_templates/fs/recursive.html
tests/template_tests/recursive_templates/fs/self.html
tests/template_tests/recursive_templates/fs/three.html
tests/template_tests/recursive_templates/fs/two.html
tests/template_tests/recursive_templates/fs2/recursive.html
tests/template_tests/recursive_templates/fs3/recursive.html
tests/template_tests/relative_templates/error_extends.html
tests/template_tests/relative_templates/error_include.html
tests/template_tests/relative_templates/one.html
tests/template_tests/relative_templates/three.html
tests/template_tests/relative_templates/two.html
tests/template_tests/relative_templates/dir1/looped.html
tests/template_tests/relative_templates/dir1/one.html
tests/template_tests/relative_templates/dir1/one1.html
tests/template_tests/relative_templates/dir1/one2.html
tests/template_tests/relative_templates/dir1/one3.html
tests/template_tests/relative_templates/dir1/three.html
tests/template_tests/relative_templates/dir1/two.html
tests/template_tests/relative_templates/dir1/dir2/inc1.html
tests/template_tests/relative_templates/dir1/dir2/inc2.html
tests/template_tests/relative_templates/dir1/dir2/include_content.html
tests/template_tests/relative_templates/dir1/dir2/one.html
tests/template_tests/syntax_tests/__init__.py
tests/template_tests/syntax_tests/test_autoescape.py
tests/template_tests/syntax_tests/test_basic.py
tests/template_tests/syntax_tests/test_builtins.py
tests/template_tests/syntax_tests/test_cache.py
tests/template_tests/syntax_tests/test_comment.py
tests/template_tests/syntax_tests/test_cycle.py
tests/template_tests/syntax_tests/test_exceptions.py
tests/template_tests/syntax_tests/test_extends.py
tests/template_tests/syntax_tests/test_filter_syntax.py
tests/template_tests/syntax_tests/test_filter_tag.py
tests/template_tests/syntax_tests/test_firstof.py
tests/template_tests/syntax_tests/test_for.py
tests/template_tests/syntax_tests/test_if.py
tests/template_tests/syntax_tests/test_if_changed.py
tests/template_tests/syntax_tests/test_if_equal.py
tests/template_tests/syntax_tests/test_include.py
tests/template_tests/syntax_tests/test_invalid_string.py
tests/template_tests/syntax_tests/test_list_index.py
tests/template_tests/syntax_tests/test_load.py
tests/template_tests/syntax_tests/test_lorem.py
tests/template_tests/syntax_tests/test_multiline.py
tests/template_tests/syntax_tests/test_named_endblock.py
tests/template_tests/syntax_tests/test_now.py
tests/template_tests/syntax_tests/test_numpy.py
tests/template_tests/syntax_tests/test_regroup.py
tests/template_tests/syntax_tests/test_resetcycle.py
tests/template_tests/syntax_tests/test_setup.py
tests/template_tests/syntax_tests/test_simple_tag.py
tests/template_tests/syntax_tests/test_spaceless.py
tests/template_tests/syntax_tests/test_static.py
tests/template_tests/syntax_tests/test_template_tag.py
tests/template_tests/syntax_tests/test_url.py
tests/template_tests/syntax_tests/test_verbatim.py
tests/template_tests/syntax_tests/test_width_ratio.py
tests/template_tests/syntax_tests/test_with.py
tests/template_tests/syntax_tests/i18n/__init__.py
tests/template_tests/syntax_tests/i18n/base.py
tests/template_tests/syntax_tests/i18n/test_blocktrans.py
tests/template_tests/syntax_tests/i18n/test_filters.py
tests/template_tests/syntax_tests/i18n/test_get_available_languages.py
tests/template_tests/syntax_tests/i18n/test_get_language_info.py
tests/template_tests/syntax_tests/i18n/test_get_language_info_list.py
tests/template_tests/syntax_tests/i18n/test_trans.py
tests/template_tests/syntax_tests/i18n/test_underscore_syntax.py
tests/template_tests/templates/27584_child.html
tests/template_tests/templates/27584_parent.html
tests/template_tests/templates/27956_child.html
tests/template_tests/templates/27956_parent.html
tests/template_tests/templates/broken_base.html
tests/template_tests/templates/include_tpl.html
tests/template_tests/templates/included_base.html
tests/template_tests/templates/included_content.html
tests/template_tests/templates/inclusion.html
tests/template_tests/templates/inclusion_base.html
tests/template_tests/templates/inclusion_extends1.html
tests/template_tests/templates/inclusion_extends2.html
tests/template_tests/templates/index.html
tests/template_tests/templates/recursive_include.html
tests/template_tests/templates/response.html
tests/template_tests/templates/ssi include with spaces.html
tests/template_tests/templates/ssi_include.html
tests/template_tests/templates/test_context.html
tests/template_tests/templates/test_context_stack.html
tests/template_tests/templates/test_extends_error.html
tests/template_tests/templates/test_incl_tag_use_l10n.html
tests/template_tests/templates/test_include_error.html
tests/template_tests/templates/first/test.html
tests/template_tests/templates/priority/foo.html
tests/template_tests/templates/second/test.html
tests/template_tests/templates/template_tests/using.html
tests/template_tests/templatetags/__init__.py
tests/template_tests/templatetags/bad_tag.py
tests/template_tests/templatetags/custom.py
tests/template_tests/templatetags/inclusion.py
tests/template_tests/templatetags/tag_27584.py
tests/template_tests/templatetags/testtags.py
tests/template_tests/templatetags/subpackage/__init__.py
tests/template_tests/templatetags/subpackage/echo.py
tests/templates/base.html
tests/templates/extended.html
tests/templates/form_view.html
tests/templates/login.html
tests/templates/comments/comment_notification_email.txt
tests/templates/custom_admin/add_form.html
tests/templates/custom_admin/app_index.html
tests/templates/custom_admin/change_form.html
tests/templates/custom_admin/change_list.html
tests/templates/custom_admin/delete_confirmation.html
tests/templates/custom_admin/delete_selected_confirmation.html
tests/templates/custom_admin/index.html
tests/templates/custom_admin/login.html
tests/templates/custom_admin/logout.html
tests/templates/custom_admin/object_history.html
tests/templates/custom_admin/password_change_done.html
tests/templates/custom_admin/password_change_form.html
tests/templates/custom_admin/popup_response.html
tests/templates/views/article_archive_day.html
tests/templates/views/article_archive_month.html
tests/templates/views/article_confirm_delete.html
tests/templates/views/article_detail.html
tests/templates/views/article_form.html
tests/templates/views/article_list.html
tests/templates/views/datearticle_archive_month.html
tests/templates/views/urlarticle_detail.html
tests/templates/views/urlarticle_form.html
tests/test_client/__init__.py
tests/test_client/auth_backends.py
tests/test_client/test_conditional_content_removal.py
tests/test_client/tests.py
tests/test_client/urls.py
tests/test_client/views.py
tests/test_client_regress/__init__.py
tests/test_client_regress/auth_backends.py
tests/test_client_regress/context_processors.py
tests/test_client_regress/models.py
tests/test_client_regress/session.py
tests/test_client_regress/tests.py
tests/test_client_regress/urls.py
tests/test_client_regress/views.py
tests/test_client_regress/bad_templates/404.html
tests/test_client_regress/templates/request_context.html
tests/test_client_regress/templates/unicode.html
tests/test_discovery_sample/__init__.py
tests/test_discovery_sample/doctests.py
tests/test_discovery_sample/empty.py
tests/test_discovery_sample/pattern_tests.py
tests/test_discovery_sample/tests_sample.py
tests/test_discovery_sample/tests/__init__.py
tests/test_discovery_sample/tests/tests.py
tests/test_discovery_sample2/__init__.py
tests/test_discovery_sample2/tests.py
tests/test_exceptions/__init__.py
tests/test_exceptions/test_validation_error.py
tests/test_runner/__init__.py
tests/test_runner/models.py
tests/test_runner/runner.py
tests/test_runner/test_debug_sql.py
tests/test_runner/test_discover_runner.py
tests/test_runner/test_parallel.py
tests/test_runner/tests.py
tests/test_utils/__init__.py
tests/test_utils/models.py
tests/test_utils/test_testcase.py
tests/test_utils/test_transactiontestcase.py
tests/test_utils/tests.py
tests/test_utils/urls.py
tests/test_utils/views.py
tests/test_utils/fixtures/should_not_be_loaded.json
tests/test_utils/templates/template_used/alternative.html
tests/test_utils/templates/template_used/base.html
tests/test_utils/templates/template_used/extends.html
tests/test_utils/templates/template_used/include.html
tests/timezones/__init__.py
tests/timezones/admin.py
tests/timezones/forms.py
tests/timezones/models.py
tests/timezones/tests.py
tests/timezones/urls.py
tests/transaction_hooks/__init__.py
tests/transaction_hooks/models.py
tests/transaction_hooks/tests.py
tests/transactions/__init__.py
tests/transactions/models.py
tests/transactions/tests.py
tests/unmanaged_models/__init__.py
tests/unmanaged_models/models.py
tests/unmanaged_models/tests.py
tests/update/__init__.py
tests/update/models.py
tests/update/tests.py
tests/update_only_fields/__init__.py
tests/update_only_fields/models.py
tests/update_only_fields/tests.py
tests/urlpatterns_reverse/__init__.py
tests/urlpatterns_reverse/erroneous_urls.py
tests/urlpatterns_reverse/extra_urls.py
tests/urlpatterns_reverse/included_app_urls.py
tests/urlpatterns_reverse/included_named_urls.py
tests/urlpatterns_reverse/included_named_urls2.py
tests/urlpatterns_reverse/included_namespace_urls.py
tests/urlpatterns_reverse/included_no_kwargs_urls.py
tests/urlpatterns_reverse/included_urls.py
tests/urlpatterns_reverse/included_urls2.py
tests/urlpatterns_reverse/method_view_urls.py
tests/urlpatterns_reverse/middleware.py
tests/urlpatterns_reverse/named_urls.py
tests/urlpatterns_reverse/named_urls_conflict.py
tests/urlpatterns_reverse/namespace_urls.py
tests/urlpatterns_reverse/nested_urls.py
tests/urlpatterns_reverse/no_urls.py
tests/urlpatterns_reverse/nonimported_module.py
tests/urlpatterns_reverse/reverse_lazy_urls.py
tests/urlpatterns_reverse/test_deprecated.py
tests/urlpatterns_reverse/test_localeregexprovider.py
tests/urlpatterns_reverse/tests.py
tests/urlpatterns_reverse/urlconf_inner.py
tests/urlpatterns_reverse/urlconf_outer.py
tests/urlpatterns_reverse/urls.py
tests/urlpatterns_reverse/urls_error_handlers.py
tests/urlpatterns_reverse/urls_error_handlers_callables.py
tests/urlpatterns_reverse/urls_without_full_import.py
tests/urlpatterns_reverse/utils.py
tests/urlpatterns_reverse/views.py
tests/urlpatterns_reverse/views_broken.py
tests/urlpatterns_reverse/translations/__init__.py
tests/urlpatterns_reverse/translations/locale/__init__.py
tests/urlpatterns_reverse/translations/locale/de/__init__.py
tests/urlpatterns_reverse/translations/locale/de/LC_MESSAGES/django.mo
tests/urlpatterns_reverse/translations/locale/de/LC_MESSAGES/django.po
tests/urlpatterns_reverse/translations/locale/fr/__init__.py
tests/urlpatterns_reverse/translations/locale/fr/LC_MESSAGES/django.mo
tests/urlpatterns_reverse/translations/locale/fr/LC_MESSAGES/django.po
tests/user_commands/__init__.py
tests/user_commands/models.py
tests/user_commands/tests.py
tests/user_commands/urls.py
tests/user_commands/eggs/basic.egg
tests/user_commands/management/__init__.py
tests/user_commands/management/commands/__init__.py
tests/user_commands/management/commands/dance.py
tests/user_commands/management/commands/hal.py
tests/user_commands/management/commands/leave_locale_alone_false.py
tests/user_commands/management/commands/leave_locale_alone_true.py
tests/user_commands/management/commands/reverse_url.py
tests/user_commands/management/commands/transaction.py
tests/utils_tests/__init__.py
tests/utils_tests/models.py
tests/utils_tests/test_archive.py
tests/utils_tests/test_autoreload.py
tests/utils_tests/test_baseconv.py
tests/utils_tests/test_crypto.py
tests/utils_tests/test_datastructures.py
tests/utils_tests/test_dateformat.py
tests/utils_tests/test_dateparse.py
tests/utils_tests/test_datetime_safe.py
tests/utils_tests/test_decorators.py
tests/utils_tests/test_deprecation.py
tests/utils_tests/test_duration.py
tests/utils_tests/test_encoding.py
tests/utils_tests/test_feedgenerator.py
tests/utils_tests/test_functional.py
tests/utils_tests/test_glob.py
tests/utils_tests/test_html.py
tests/utils_tests/test_http.py
tests/utils_tests/test_inspect.py
tests/utils_tests/test_ipv6.py
tests/utils_tests/test_itercompat.py
tests/utils_tests/test_jslex.py
tests/utils_tests/test_lazyobject.py
tests/utils_tests/test_lorem_ipsum.py
tests/utils_tests/test_module_loading.py
tests/utils_tests/test_no_submodule.py
tests/utils_tests/test_numberformat.py
tests/utils_tests/test_os_utils.py
tests/utils_tests/test_regex_helper.py
tests/utils_tests/test_safestring.py
tests/utils_tests/test_simplelazyobject.py
tests/utils_tests/test_termcolors.py
tests/utils_tests/test_text.py
tests/utils_tests/test_timesince.py
tests/utils_tests/test_timezone.py
tests/utils_tests/test_tree.py
tests/utils_tests/archives/foobar.tar
tests/utils_tests/archives/foobar.tar.bz2
tests/utils_tests/archives/foobar.tar.gz
tests/utils_tests/archives/foobar.zip
tests/utils_tests/archives/leadpath_foobar.tar
tests/utils_tests/archives/leadpath_foobar.tar.bz2
tests/utils_tests/archives/leadpath_foobar.tar.gz
tests/utils_tests/archives/leadpath_foobar.zip
tests/utils_tests/eggs/test_egg.egg
tests/utils_tests/files/strip_tags1.html
tests/utils_tests/files/strip_tags2.txt
tests/utils_tests/locale/nl/LC_MESSAGES/django.mo
tests/utils_tests/locale/nl/LC_MESSAGES/django.po
tests/utils_tests/test_module/__init__.py
tests/utils_tests/test_module/another_bad_module.py
tests/utils_tests/test_module/another_good_module.py
tests/utils_tests/test_module/bad_module.py
tests/utils_tests/test_module/good_module.py
tests/validation/__init__.py
tests/validation/models.py
tests/validation/test_custom_messages.py
tests/validation/test_error_messages.py
tests/validation/test_picklable.py
tests/validation/test_unique.py
tests/validation/test_validators.py
tests/validation/tests.py
tests/validators/__init__.py
tests/validators/invalid_urls.txt
tests/validators/tests.py
tests/validators/valid_urls.txt
tests/version/__init__.py
tests/version/tests.py
tests/view_tests/__init__.py
tests/view_tests/default_urls.py
tests/view_tests/generic_urls.py
tests/view_tests/models.py
tests/view_tests/regression_21530_urls.py
tests/view_tests/urls.py
tests/view_tests/views.py
tests/view_tests/app0/__init__.py
tests/view_tests/app0/locale/en/LC_MESSAGES/djangojs.mo
tests/view_tests/app0/locale/en/LC_MESSAGES/djangojs.po
tests/view_tests/app1/__init__.py
tests/view_tests/app1/locale/fr/LC_MESSAGES/djangojs.mo
tests/view_tests/app1/locale/fr/LC_MESSAGES/djangojs.po
tests/view_tests/app2/__init__.py
tests/view_tests/app2/locale/fr/LC_MESSAGES/djangojs.mo
tests/view_tests/app2/locale/fr/LC_MESSAGES/djangojs.po
tests/view_tests/app3/__init__.py
tests/view_tests/app3/locale/es_AR/LC_MESSAGES/djangojs.mo
tests/view_tests/app3/locale/es_AR/LC_MESSAGES/djangojs.po
tests/view_tests/app4/__init__.py
tests/view_tests/app4/locale/es_AR/LC_MESSAGES/djangojs.mo
tests/view_tests/app4/locale/es_AR/LC_MESSAGES/djangojs.po
tests/view_tests/app5/__init__.py
tests/view_tests/app5/locale/fr/LC_MESSAGES/djangojs.mo
tests/view_tests/app5/locale/fr/LC_MESSAGES/djangojs.po
tests/view_tests/locale/de/LC_MESSAGES/djangojs.mo
tests/view_tests/locale/de/LC_MESSAGES/djangojs.po
tests/view_tests/locale/en_GB/LC_MESSAGES/djangojs.mo
tests/view_tests/locale/en_GB/LC_MESSAGES/djangojs.po
tests/view_tests/locale/es/LC_MESSAGES/djangojs.mo
tests/view_tests/locale/es/LC_MESSAGES/djangojs.po
tests/view_tests/locale/fr/LC_MESSAGES/djangojs.mo
tests/view_tests/locale/fr/LC_MESSAGES/djangojs.po
tests/view_tests/locale/nl/LC_MESSAGES/django.mo
tests/view_tests/locale/nl/LC_MESSAGES/django.po
tests/view_tests/locale/pt/LC_MESSAGES/djangojs.mo
tests/view_tests/locale/pt/LC_MESSAGES/djangojs.po
tests/view_tests/locale/ru/LC_MESSAGES/djangojs.mo
tests/view_tests/locale/ru/LC_MESSAGES/djangojs.po
tests/view_tests/media/file.txt
tests/view_tests/media/file.txt.gz
tests/view_tests/media/file.unknown
tests/view_tests/media/long-line.txt
tests/view_tests/templates/jsi18n-multi-catalogs.html
tests/view_tests/templates/jsi18n.html
tests/view_tests/templates/old_jsi18n-multi-catalogs.html
tests/view_tests/templates/old_jsi18n.html
tests/view_tests/templates/debug/template_exception.html
tests/view_tests/templatetags/__init__.py
tests/view_tests/templatetags/debugtags.py
tests/view_tests/tests/__init__.py
tests/view_tests/tests/py3_test_debug.py
tests/view_tests/tests/test_csrf.py
tests/view_tests/tests/test_debug.py
tests/view_tests/tests/test_defaults.py
tests/view_tests/tests/test_i18n.py
tests/view_tests/tests/test_i18n_deprecated.py
tests/view_tests/tests/test_json.py
tests/view_tests/tests/test_specials.py
tests/view_tests/tests/test_static.py
tests/wsgi/__init__.py
tests/wsgi/tests.py
tests/wsgi/urls.py
tests/wsgi/wsgi.py Django-1.11.11/Django.egg-info/not-zip-safe 0000664 0001750 0001750 00000000001 13247520351 017610 0 ustar tim tim 0000000 0000000
Django-1.11.11/Django.egg-info/dependency_links.txt 0000664 0001750 0001750 00000000001 13247520351 021430 0 ustar tim tim 0000000 0000000
Django-1.11.11/setup.cfg 0000664 0001750 0001750 00000001266 13247520354 014317 0 ustar tim tim 0000000 0000000 [bdist_rpm]
doc_files = docs extras AUTHORS INSTALL LICENSE README.rst
install-script = scripts/rpm-install.sh
[flake8]
exclude = build,.git,.tox,./django/utils/lru_cache.py,./django/utils/six.py,./django/conf/app_template/*,./django/dispatch/weakref_backports.py,./tests/.env,./xmlrunner,tests/view_tests/tests/py3_test_debug.py,tests/template_tests/annotated_tag_function.py
ignore = W601
max-line-length = 119
[isort]
combine_as_imports = true
default_section = THIRDPARTY
include_trailing_comma = true
known_first_party = django
line_length = 79
multi_line_output = 5
not_skip = __init__.py
[metadata]
license-file = LICENSE
[wheel]
universal = 1
[egg_info]
tag_build =
tag_date = 0
Django-1.11.11/MANIFEST.in 0000664 0001750 0001750 00000000463 13247517143 014234 0 ustar tim tim 0000000 0000000 include AUTHORS
include Gruntfile.js
include INSTALL
include LICENSE
include LICENSE.python
include MANIFEST.in
include package.json
include *.rst
graft django
prune django/contrib/admin/bin
graft docs
graft extras
graft js_tests
graft scripts
graft tests
global-exclude __pycache__
global-exclude *.py[co]
Django-1.11.11/README.rst 0000664 0001750 0001750 00000003476 13247517143 014174 0 ustar tim tim 0000000 0000000 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. Read the archives at https://botbot.me/freenode/django/.
* 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
Django-1.11.11/INSTALL 0000664 0001750 0001750 00000001143 13247520250 013514 0 ustar tim tim 0000000 0000000 Thanks for downloading Django.
To install it, make sure you have Python 2.7 or greater installed. Then run
this command from the command prompt:
python setup.py install
If you're upgrading from a previous version, you need to remove it first.
AS AN ALTERNATIVE, you can just copy the entire "django" directory to Python's
site-packages directory, which is located wherever your Python installation
lives. Some places you might check are:
/usr/lib/python2.7/site-packages (Unix, Python 2.7)
C:\\PYTHON\site-packages (Windows)
For more detailed instructions, see docs/intro/install.txt.
Django-1.11.11/django/ 0000775 0001750 0001750 00000000000 13247520352 013731 5 ustar tim tim 0000000 0000000 Django-1.11.11/django/apps/ 0000775 0001750 0001750 00000000000 13247520352 014674 5 ustar tim tim 0000000 0000000 Django-1.11.11/django/apps/__init__.py 0000664 0001750 0001750 00000000132 13247517143 017005 0 ustar tim tim 0000000 0000000 from .config import AppConfig
from .registry import apps
__all__ = ['AppConfig', 'apps']
Django-1.11.11/django/apps/registry.py 0000664 0001750 0001750 00000041527 13247520250 017124 0 ustar tim tim 0000000 0000000 import sys
import threading
import warnings
from collections import Counter, OrderedDict, defaultdict
from functools import partial
from django.core.exceptions import AppRegistryNotReady, ImproperlyConfigured
from django.utils import lru_cache
from .config import AppConfig
class Apps(object):
"""
A registry that stores the configuration of installed applications.
It also keeps track of models eg. to provide reverse-relations.
"""
def __init__(self, installed_apps=()):
# installed_apps is set to None when creating the master registry
# because it cannot be populated at that point. Other registries must
# provide a list of installed apps and are populated immediately.
if installed_apps is None and hasattr(sys.modules[__name__], 'apps'):
raise RuntimeError("You must supply an installed_apps argument.")
# Mapping of app labels => model names => model classes. Every time a
# model is imported, ModelBase.__new__ calls apps.register_model which
# creates an entry in all_models. All imported models are registered,
# regardless of whether they're defined in an installed application
# and whether the registry has been populated. Since it isn't possible
# to reimport a module safely (it could reexecute initialization code)
# all_models is never overridden or reset.
self.all_models = defaultdict(OrderedDict)
# Mapping of labels to AppConfig instances for installed apps.
self.app_configs = OrderedDict()
# Stack of app_configs. Used to store the current state in
# set_available_apps and set_installed_apps.
self.stored_app_configs = []
# Whether the registry is populated.
self.apps_ready = self.models_ready = self.ready = False
# Lock for thread-safe population.
self._lock = threading.Lock()
# Maps ("app_label", "modelname") tuples to lists of functions to be
# called when the corresponding model is ready. Used by this class's
# `lazy_model_operation()` and `do_pending_operations()` methods.
self._pending_operations = defaultdict(list)
# Populate apps and models, unless it's the master registry.
if installed_apps is not None:
self.populate(installed_apps)
def populate(self, installed_apps=None):
"""
Loads application configurations and models.
This method imports each application module and then each model module.
It is thread safe and idempotent, but not reentrant.
"""
if self.ready:
return
# populate() might be called by two threads in parallel on servers
# that create threads before initializing the WSGI callable.
with self._lock:
if self.ready:
return
# app_config should be pristine, otherwise the code below won't
# guarantee that the order matches the order in INSTALLED_APPS.
if self.app_configs:
raise RuntimeError("populate() isn't reentrant")
# Phase 1: initialize app configs and import app modules.
for entry in installed_apps:
if isinstance(entry, AppConfig):
app_config = entry
else:
app_config = AppConfig.create(entry)
if app_config.label in self.app_configs:
raise ImproperlyConfigured(
"Application labels aren't unique, "
"duplicates: %s" % app_config.label)
self.app_configs[app_config.label] = app_config
app_config.apps = self
# Check for duplicate app names.
counts = Counter(
app_config.name for app_config in self.app_configs.values())
duplicates = [
name for name, count in counts.most_common() if count > 1]
if duplicates:
raise ImproperlyConfigured(
"Application names aren't unique, "
"duplicates: %s" % ", ".join(duplicates))
self.apps_ready = True
# Phase 2: import models modules.
for app_config in self.app_configs.values():
app_config.import_models()
self.clear_cache()
self.models_ready = True
# Phase 3: run ready() methods of app configs.
for app_config in self.get_app_configs():
app_config.ready()
self.ready = True
def check_apps_ready(self):
"""
Raises an exception if all apps haven't been imported yet.
"""
if not self.apps_ready:
raise AppRegistryNotReady("Apps aren't loaded yet.")
def check_models_ready(self):
"""
Raises an exception if all models haven't been imported yet.
"""
if not self.models_ready:
raise AppRegistryNotReady("Models aren't loaded yet.")
def get_app_configs(self):
"""
Imports applications and returns an iterable of app configs.
"""
self.check_apps_ready()
return self.app_configs.values()
def get_app_config(self, app_label):
"""
Imports applications and returns an app config for the given label.
Raises LookupError if no application exists with this label.
"""
self.check_apps_ready()
try:
return self.app_configs[app_label]
except KeyError:
message = "No installed app with label '%s'." % app_label
for app_config in self.get_app_configs():
if app_config.name == app_label:
message += " Did you mean '%s'?" % app_config.label
break
raise LookupError(message)
# This method is performance-critical at least for Django's test suite.
@lru_cache.lru_cache(maxsize=None)
def get_models(self, include_auto_created=False, include_swapped=False):
"""
Returns a list of all installed models.
By default, the following models aren't included:
- auto-created models for many-to-many relations without
an explicit intermediate table,
- models that have been swapped out.
Set the corresponding keyword argument to True to include such models.
"""
self.check_models_ready()
result = []
for app_config in self.app_configs.values():
result.extend(list(app_config.get_models(include_auto_created, include_swapped)))
return result
def get_model(self, app_label, model_name=None, require_ready=True):
"""
Returns the model matching the given app_label and model_name.
As a shortcut, this function also accepts a single argument in the
form ..
model_name is case-insensitive.
Raises LookupError if no application exists with this label, or no
model exists with this name in the application. Raises ValueError if
called with a single argument that doesn't contain exactly one dot.
"""
if require_ready:
self.check_models_ready()
else:
self.check_apps_ready()
if model_name is None:
app_label, model_name = app_label.split('.')
app_config = self.get_app_config(app_label)
if not require_ready and app_config.models is None:
app_config.import_models()
return app_config.get_model(model_name, require_ready=require_ready)
def register_model(self, app_label, model):
# Since this method is called when models are imported, it cannot
# perform imports because of the risk of import loops. It mustn't
# call get_app_config().
model_name = model._meta.model_name
app_models = self.all_models[app_label]
if model_name in app_models:
if (model.__name__ == app_models[model_name].__name__ and
model.__module__ == app_models[model_name].__module__):
warnings.warn(
"Model '%s.%s' was already registered. "
"Reloading models is not advised as it can lead to inconsistencies, "
"most notably with related models." % (app_label, model_name),
RuntimeWarning, stacklevel=2)
else:
raise RuntimeError(
"Conflicting '%s' models in application '%s': %s and %s." %
(model_name, app_label, app_models[model_name], model))
app_models[model_name] = model
self.do_pending_operations(model)
self.clear_cache()
def is_installed(self, app_name):
"""
Checks whether an application with this name exists in the registry.
app_name is the full name of the app eg. 'django.contrib.admin'.
"""
self.check_apps_ready()
return any(ac.name == app_name for ac in self.app_configs.values())
def get_containing_app_config(self, object_name):
"""
Look for an app config containing a given object.
object_name is the dotted Python path to the object.
Returns the app config for the inner application in case of nesting.
Returns None if the object isn't in any registered app config.
"""
self.check_apps_ready()
candidates = []
for app_config in self.app_configs.values():
if object_name.startswith(app_config.name):
subpath = object_name[len(app_config.name):]
if subpath == '' or subpath[0] == '.':
candidates.append(app_config)
if candidates:
return sorted(candidates, key=lambda ac: -len(ac.name))[0]
def get_registered_model(self, app_label, model_name):
"""
Similar to get_model(), but doesn't require that an app exists with
the given app_label.
It's safe to call this method at import time, even while the registry
is being populated.
"""
model = self.all_models[app_label].get(model_name.lower())
if model is None:
raise LookupError(
"Model '%s.%s' not registered." % (app_label, model_name))
return model
@lru_cache.lru_cache(maxsize=None)
def get_swappable_settings_name(self, to_string):
"""
For a given model string (e.g. "auth.User"), return the name of the
corresponding settings name if it refers to a swappable model. If the
referred model is not swappable, return None.
This method is decorated with lru_cache because it's performance
critical when it comes to migrations. Since the swappable settings don't
change after Django has loaded the settings, there is no reason to get
the respective settings attribute over and over again.
"""
for model in self.get_models(include_swapped=True):
swapped = model._meta.swapped
# Is this model swapped out for the model given by to_string?
if swapped and swapped == to_string:
return model._meta.swappable
# Is this model swappable and the one given by to_string?
if model._meta.swappable and model._meta.label == to_string:
return model._meta.swappable
return None
def set_available_apps(self, available):
"""
Restricts the set of installed apps used by get_app_config[s].
available must be an iterable of application names.
set_available_apps() must be balanced with unset_available_apps().
Primarily used for performance optimization in TransactionTestCase.
This method is safe is the sense that it doesn't trigger any imports.
"""
available = set(available)
installed = set(app_config.name for app_config in self.get_app_configs())
if not available.issubset(installed):
raise ValueError(
"Available apps isn't a subset of installed apps, extra apps: %s"
% ", ".join(available - installed)
)
self.stored_app_configs.append(self.app_configs)
self.app_configs = OrderedDict(
(label, app_config)
for label, app_config in self.app_configs.items()
if app_config.name in available)
self.clear_cache()
def unset_available_apps(self):
"""
Cancels a previous call to set_available_apps().
"""
self.app_configs = self.stored_app_configs.pop()
self.clear_cache()
def set_installed_apps(self, installed):
"""
Enables a different set of installed apps for get_app_config[s].
installed must be an iterable in the same format as INSTALLED_APPS.
set_installed_apps() must be balanced with unset_installed_apps(),
even if it exits with an exception.
Primarily used as a receiver of the setting_changed signal in tests.
This method may trigger new imports, which may add new models to the
registry of all imported models. They will stay in the registry even
after unset_installed_apps(). Since it isn't possible to replay
imports safely (eg. that could lead to registering listeners twice),
models are registered when they're imported and never removed.
"""
if not self.ready:
raise AppRegistryNotReady("App registry isn't ready yet.")
self.stored_app_configs.append(self.app_configs)
self.app_configs = OrderedDict()
self.apps_ready = self.models_ready = self.ready = False
self.clear_cache()
self.populate(installed)
def unset_installed_apps(self):
"""
Cancels a previous call to set_installed_apps().
"""
self.app_configs = self.stored_app_configs.pop()
self.apps_ready = self.models_ready = self.ready = True
self.clear_cache()
def clear_cache(self):
"""
Clears all internal caches, for methods that alter the app registry.
This is mostly used in tests.
"""
# Call expire cache on each model. This will purge
# the relation tree and the fields cache.
self.get_models.cache_clear()
if self.ready:
# Circumvent self.get_models() to prevent that the cache is refilled.
# This particularly prevents that an empty value is cached while cloning.
for app_config in self.app_configs.values():
for model in app_config.get_models(include_auto_created=True):
model._meta._expire_cache()
def lazy_model_operation(self, function, *model_keys):
"""
Take a function and a number of ("app_label", "modelname") tuples, and
when all the corresponding models have been imported and registered,
call the function with the model classes as its arguments.
The function passed to this method must accept exactly n models as
arguments, where n=len(model_keys).
"""
# Base case: no arguments, just execute the function.
if not model_keys:
function()
# Recursive case: take the head of model_keys, wait for the
# corresponding model class to be imported and registered, then apply
# that argument to the supplied function. Pass the resulting partial
# to lazy_model_operation() along with the remaining model args and
# repeat until all models are loaded and all arguments are applied.
else:
next_model, more_models = model_keys[0], model_keys[1:]
# This will be executed after the class corresponding to next_model
# has been imported and registered. The `func` attribute provides
# duck-type compatibility with partials.
def apply_next_model(model):
next_function = partial(apply_next_model.func, model)
self.lazy_model_operation(next_function, *more_models)
apply_next_model.func = function
# If the model has already been imported and registered, partially
# apply it to the function now. If not, add it to the list of
# pending operations for the model, where it will be executed with
# the model class as its sole argument once the model is ready.
try:
model_class = self.get_registered_model(*next_model)
except LookupError:
self._pending_operations[next_model].append(apply_next_model)
else:
apply_next_model(model_class)
def do_pending_operations(self, model):
"""
Take a newly-prepared model and pass it to each function waiting for
it. This is called at the very end of `Apps.register_model()`.
"""
key = model._meta.app_label, model._meta.model_name
for function in self._pending_operations.pop(key, []):
function(model)
apps = Apps(installed_apps=None)
Django-1.11.11/django/apps/config.py 0000664 0001750 0001750 00000017773 13247520250 016527 0 ustar tim tim 0000000 0000000 import os
from importlib import import_module
from django.core.exceptions import ImproperlyConfigured
from django.utils._os import upath
from django.utils.module_loading import module_has_submodule
MODELS_MODULE_NAME = 'models'
class AppConfig(object):
"""
Class representing a Django application and its configuration.
"""
def __init__(self, app_name, app_module):
# Full Python path to the application eg. 'django.contrib.admin'.
self.name = app_name
# Root module for the application eg. .
self.module = app_module
# Reference to the Apps registry that holds this AppConfig. Set by the
# registry when it registers the AppConfig instance.
self.apps = None
# The following attributes could be defined at the class level in a
# subclass, hence the test-and-set pattern.
# Last component of the Python path to the application eg. 'admin'.
# This value must be unique across a Django project.
if not hasattr(self, 'label'):
self.label = app_name.rpartition(".")[2]
# Human-readable name for the application eg. "Admin".
if not hasattr(self, 'verbose_name'):
self.verbose_name = self.label.title()
# Filesystem path to the application directory eg.
# u'/usr/lib/python2.7/dist-packages/django/contrib/admin'. Unicode on
# Python 2 and a str on Python 3.
if not hasattr(self, 'path'):
self.path = self._path_from_module(app_module)
# Module containing models eg. . Set by import_models().
# None if the application doesn't have a models module.
self.models_module = None
# Mapping of lower case model names to model classes. Initially set to
# None to prevent accidental access before import_models() runs.
self.models = None
def __repr__(self):
return '<%s: %s>' % (self.__class__.__name__, self.label)
def _path_from_module(self, module):
"""Attempt to determine app's filesystem path from its module."""
# See #21874 for extended discussion of the behavior of this method in
# various cases.
# Convert paths to list because Python 3's _NamespacePath does not
# support indexing.
paths = list(getattr(module, '__path__', []))
if len(paths) != 1:
filename = getattr(module, '__file__', None)
if filename is not None:
paths = [os.path.dirname(filename)]
else:
# For unknown reasons, sometimes the list returned by __path__
# contains duplicates that must be removed (#25246).
paths = list(set(paths))
if len(paths) > 1:
raise ImproperlyConfigured(
"The app module %r has multiple filesystem locations (%r); "
"you must configure this app with an AppConfig subclass "
"with a 'path' class attribute." % (module, paths))
elif not paths:
raise ImproperlyConfigured(
"The app module %r has no filesystem location, "
"you must configure this app with an AppConfig subclass "
"with a 'path' class attribute." % (module,))
return upath(paths[0])
@classmethod
def create(cls, entry):
"""
Factory that creates an app config from an entry in INSTALLED_APPS.
"""
try:
# If import_module succeeds, entry is a path to an app module,
# which may specify an app config class with default_app_config.
# Otherwise, entry is a path to an app config class or an error.
module = import_module(entry)
except ImportError:
# Track that importing as an app module failed. If importing as an
# app config class fails too, we'll trigger the ImportError again.
module = None
mod_path, _, cls_name = entry.rpartition('.')
# Raise the original exception when entry cannot be a path to an
# app config class.
if not mod_path:
raise
else:
try:
# If this works, the app module specifies an app config class.
entry = module.default_app_config
except AttributeError:
# Otherwise, it simply uses the default app config class.
return cls(entry, module)
else:
mod_path, _, cls_name = entry.rpartition('.')
# If we're reaching this point, we must attempt to load the app config
# class located at .
mod = import_module(mod_path)
try:
cls = getattr(mod, cls_name)
except AttributeError:
if module is None:
# If importing as an app module failed, that error probably
# contains the most informative traceback. Trigger it again.
import_module(entry)
else:
raise
# Check for obvious errors. (This check prevents duck typing, but
# it could be removed if it became a problem in practice.)
if not issubclass(cls, AppConfig):
raise ImproperlyConfigured(
"'%s' isn't a subclass of AppConfig." % entry)
# Obtain app name here rather than in AppClass.__init__ to keep
# all error checking for entries in INSTALLED_APPS in one place.
try:
app_name = cls.name
except AttributeError:
raise ImproperlyConfigured(
"'%s' must supply a name attribute." % entry)
# Ensure app_name points to a valid module.
try:
app_module = import_module(app_name)
except ImportError:
raise ImproperlyConfigured(
"Cannot import '%s'. Check that '%s.%s.name' is correct." % (
app_name, mod_path, cls_name,
)
)
# Entry is a path to an app config class.
return cls(app_name, app_module)
def get_model(self, model_name, require_ready=True):
"""
Returns the model with the given case-insensitive model_name.
Raises LookupError if no model exists with this name.
"""
if require_ready:
self.apps.check_models_ready()
else:
self.apps.check_apps_ready()
try:
return self.models[model_name.lower()]
except KeyError:
raise LookupError(
"App '%s' doesn't have a '%s' model." % (self.label, model_name))
def get_models(self, include_auto_created=False, include_swapped=False):
"""
Returns an iterable of models.
By default, the following models aren't included:
- auto-created models for many-to-many relations without
an explicit intermediate table,
- models that have been swapped out.
Set the corresponding keyword argument to True to include such models.
Keyword arguments aren't documented; they're a private API.
"""
self.apps.check_models_ready()
for model in self.models.values():
if model._meta.auto_created and not include_auto_created:
continue
if model._meta.swapped and not include_swapped:
continue
yield model
def import_models(self):
# Dictionary of models for this app, primarily maintained in the
# 'all_models' attribute of the Apps this AppConfig is attached to.
self.models = self.apps.all_models[self.label]
if module_has_submodule(self.module, MODELS_MODULE_NAME):
models_module_name = '%s.%s' % (self.name, MODELS_MODULE_NAME)
self.models_module = import_module(models_module_name)
def ready(self):
"""
Override this method in subclasses to run code when Django starts.
"""
Django-1.11.11/django/test/ 0000775 0001750 0001750 00000000000 13247520353 014711 5 ustar tim tim 0000000 0000000 Django-1.11.11/django/test/selenium.py 0000664 0001750 0001750 00000006600 13247520250 017102 0 ustar tim tim 0000000 0000000 from __future__ import unicode_literals
import sys
import unittest
from contextlib import contextmanager
from django.test import LiveServerTestCase, tag
from django.utils.module_loading import import_string
from django.utils.six import with_metaclass
from django.utils.text import capfirst
class SeleniumTestCaseBase(type(LiveServerTestCase)):
# List of browsers to dynamically create test classes for.
browsers = []
# Sentinel value to differentiate browser-specific instances.
browser = None
def __new__(cls, name, bases, attrs):
"""
Dynamically create new classes and add them to the test module when
multiple browsers specs are provided (e.g. --selenium=firefox,chrome).
"""
test_class = super(SeleniumTestCaseBase, cls).__new__(cls, name, bases, attrs)
# If the test class is either browser-specific or a test base, return it.
if test_class.browser or not any(name.startswith('test') and callable(value) for name, value in attrs.items()):
return test_class
elif test_class.browsers:
# Reuse the created test class to make it browser-specific.
# We can't rename it to include the browser name or create a
# subclass like we do with the remaining browsers as it would
# either duplicate tests or prevent pickling of its instances.
first_browser = test_class.browsers[0]
test_class.browser = first_browser
# Create subclasses for each of the remaining browsers and expose
# them through the test's module namespace.
module = sys.modules[test_class.__module__]
for browser in test_class.browsers[1:]:
browser_test_class = cls.__new__(
cls,
str("%s%s" % (capfirst(browser), name)),
(test_class,),
{'browser': browser, '__module__': test_class.__module__}
)
setattr(module, browser_test_class.__name__, browser_test_class)
return test_class
# If no browsers were specified, skip this class (it'll still be discovered).
return unittest.skip('No browsers specified.')(test_class)
@classmethod
def import_webdriver(cls, browser):
return import_string("selenium.webdriver.%s.webdriver.WebDriver" % browser)
def create_webdriver(self):
return self.import_webdriver(self.browser)()
@tag('selenium')
class SeleniumTestCase(with_metaclass(SeleniumTestCaseBase, LiveServerTestCase)):
implicit_wait = 10
@classmethod
def setUpClass(cls):
cls.selenium = cls.create_webdriver()
cls.selenium.implicitly_wait(cls.implicit_wait)
super(SeleniumTestCase, cls).setUpClass()
@classmethod
def _tearDownClassInternal(cls):
# quit() the WebDriver before attempting to terminate and join the
# single-threaded LiveServerThread to avoid a dead lock if the browser
# kept a connection alive.
if hasattr(cls, 'selenium'):
cls.selenium.quit()
super(SeleniumTestCase, cls)._tearDownClassInternal()
@contextmanager
def disable_implicit_wait(self):
"""Context manager that disables the default implicit wait."""
self.selenium.implicitly_wait(0)
try:
yield
finally:
self.selenium.implicitly_wait(self.implicit_wait)
Django-1.11.11/django/test/client.py 0000664 0001750 0001750 00000067064 13247520250 016552 0 ustar tim tim 0000000 0000000 from __future__ import unicode_literals
import json
import mimetypes
import os
import re
import sys
from copy import copy
from importlib import import_module
from io import BytesIO
from django.conf import settings
from django.core.handlers.base import BaseHandler
from django.core.handlers.wsgi import ISO_8859_1, UTF_8, WSGIRequest
from django.core.signals import (
got_request_exception, request_finished, request_started,
)
from django.db import close_old_connections
from django.http import HttpRequest, QueryDict, SimpleCookie
from django.template import TemplateDoesNotExist
from django.test import signals
from django.test.utils import ContextList
from django.urls import resolve
from django.utils import six
from django.utils.encoding import force_bytes, force_str, uri_to_iri
from django.utils.functional import SimpleLazyObject, curry
from django.utils.http import urlencode
from django.utils.itercompat import is_iterable
from django.utils.six.moves.urllib.parse import urljoin, urlparse, urlsplit
__all__ = ('Client', 'RedirectCycleError', 'RequestFactory', 'encode_file', 'encode_multipart')
BOUNDARY = 'BoUnDaRyStRiNg'
MULTIPART_CONTENT = 'multipart/form-data; boundary=%s' % BOUNDARY
CONTENT_TYPE_RE = re.compile(r'.*; charset=([\w\d-]+);?')
# JSON Vendor Tree spec: https://tools.ietf.org/html/rfc6838#section-3.2
JSON_CONTENT_TYPE_RE = re.compile(r'^application\/(vnd\..+\+)?json')
class RedirectCycleError(Exception):
"""
The test client has been asked to follow a redirect loop.
"""
def __init__(self, message, last_response):
super(RedirectCycleError, self).__init__(message)
self.last_response = last_response
self.redirect_chain = last_response.redirect_chain
class FakePayload(object):
"""
A wrapper around BytesIO that restricts what can be read since data from
the network can't be seeked and cannot be read outside of its content
length. This makes sure that views can't do anything under the test client
that wouldn't work in Real Life.
"""
def __init__(self, content=None):
self.__content = BytesIO()
self.__len = 0
self.read_started = False
if content is not None:
self.write(content)
def __len__(self):
return self.__len
def read(self, num_bytes=None):
if not self.read_started:
self.__content.seek(0)
self.read_started = True
if num_bytes is None:
num_bytes = self.__len or 0
assert self.__len >= num_bytes, "Cannot read more than the available bytes from the HTTP incoming data."
content = self.__content.read(num_bytes)
self.__len -= num_bytes
return content
def write(self, content):
if self.read_started:
raise ValueError("Unable to write a payload after he's been read")
content = force_bytes(content)
self.__content.write(content)
self.__len += len(content)
def closing_iterator_wrapper(iterable, close):
try:
for item in iterable:
yield item
finally:
request_finished.disconnect(close_old_connections)
close() # will fire request_finished
request_finished.connect(close_old_connections)
def conditional_content_removal(request, response):
"""
Simulate the behavior of most Web servers by removing the content of
responses for HEAD requests, 1xx, 204, and 304 responses. Ensures
compliance with RFC 7230, section 3.3.3.
"""
if 100 <= response.status_code < 200 or response.status_code in (204, 304):
if response.streaming:
response.streaming_content = []
else:
response.content = b''
response['Content-Length'] = '0'
if request.method == 'HEAD':
if response.streaming:
response.streaming_content = []
else:
response.content = b''
return response
class ClientHandler(BaseHandler):
"""
A HTTP Handler that can be used for testing purposes. Uses the WSGI
interface to compose requests, but returns the raw HttpResponse object with
the originating WSGIRequest attached to its ``wsgi_request`` attribute.
"""
def __init__(self, enforce_csrf_checks=True, *args, **kwargs):
self.enforce_csrf_checks = enforce_csrf_checks
super(ClientHandler, self).__init__(*args, **kwargs)
def __call__(self, environ):
# Set up middleware if needed. We couldn't do this earlier, because
# settings weren't available.
if self._middleware_chain is None:
self.load_middleware()
request_started.disconnect(close_old_connections)
request_started.send(sender=self.__class__, environ=environ)
request_started.connect(close_old_connections)
request = WSGIRequest(environ)
# sneaky little hack so that we can easily get round
# CsrfViewMiddleware. This makes life easier, and is probably
# required for backwards compatibility with external tests against
# admin views.
request._dont_enforce_csrf_checks = not self.enforce_csrf_checks
# Request goes through middleware.
response = self.get_response(request)
# Simulate behaviors of most Web servers.
conditional_content_removal(request, response)
# Attach the originating request to the response so that it could be
# later retrieved.
response.wsgi_request = request
# We're emulating a WSGI server; we must call the close method
# on completion.
if response.streaming:
response.streaming_content = closing_iterator_wrapper(
response.streaming_content, response.close)
else:
request_finished.disconnect(close_old_connections)
response.close() # will fire request_finished
request_finished.connect(close_old_connections)
return response
def store_rendered_templates(store, signal, sender, template, context, **kwargs):
"""
Stores templates and contexts that are rendered.
The context is copied so that it is an accurate representation at the time
of rendering.
"""
store.setdefault('templates', []).append(template)
if 'context' not in store:
store['context'] = ContextList()
store['context'].append(copy(context))
def encode_multipart(boundary, data):
"""
Encodes multipart POST data from a dictionary of form values.
The key will be used as the form data name; the value will be transmitted
as content. If the value is a file, the contents of the file will be sent
as an application/octet-stream; otherwise, str(value) will be sent.
"""
lines = []
def to_bytes(s):
return force_bytes(s, settings.DEFAULT_CHARSET)
# Not by any means perfect, but good enough for our purposes.
def is_file(thing):
return hasattr(thing, "read") and callable(thing.read)
# Each bit of the multipart form data could be either a form value or a
# file, or a *list* of form values and/or files. Remember that HTTP field
# names can be duplicated!
for (key, value) in data.items():
if is_file(value):
lines.extend(encode_file(boundary, key, value))
elif not isinstance(value, six.string_types) and is_iterable(value):
for item in value:
if is_file(item):
lines.extend(encode_file(boundary, key, item))
else:
lines.extend(to_bytes(val) for val in [
'--%s' % boundary,
'Content-Disposition: form-data; name="%s"' % key,
'',
item
])
else:
lines.extend(to_bytes(val) for val in [
'--%s' % boundary,
'Content-Disposition: form-data; name="%s"' % key,
'',
value
])
lines.extend([
to_bytes('--%s--' % boundary),
b'',
])
return b'\r\n'.join(lines)
def encode_file(boundary, key, file):
def to_bytes(s):
return force_bytes(s, settings.DEFAULT_CHARSET)
# file.name might not be a string. For example, it's an int for
# tempfile.TemporaryFile().
file_has_string_name = hasattr(file, 'name') and isinstance(file.name, six.string_types)
filename = os.path.basename(file.name) if file_has_string_name else ''
if hasattr(file, 'content_type'):
content_type = file.content_type
elif filename:
content_type = mimetypes.guess_type(filename)[0]
else:
content_type = None
if content_type is None:
content_type = 'application/octet-stream'
if not filename:
filename = key
return [
to_bytes('--%s' % boundary),
to_bytes('Content-Disposition: form-data; name="%s"; filename="%s"'
% (key, filename)),
to_bytes('Content-Type: %s' % content_type),
b'',
to_bytes(file.read())
]
class RequestFactory(object):
"""
Class that lets you create mock Request objects for use in testing.
Usage:
rf = RequestFactory()
get_request = rf.get('/hello/')
post_request = rf.post('/submit/', {'foo': 'bar'})
Once you have a request object you can pass it to any view function,
just as if that view had been hooked up using a URLconf.
"""
def __init__(self, **defaults):
self.defaults = defaults
self.cookies = SimpleCookie()
self.errors = BytesIO()
def _base_environ(self, **request):
"""
The base environment for a request.
"""
# This is a minimal valid WSGI environ dictionary, plus:
# - HTTP_COOKIE: for cookie support,
# - REMOTE_ADDR: often useful, see #8551.
# See http://www.python.org/dev/peps/pep-3333/#environ-variables
environ = {
'HTTP_COOKIE': self.cookies.output(header='', sep='; '),
'PATH_INFO': str('/'),
'REMOTE_ADDR': str('127.0.0.1'),
'REQUEST_METHOD': str('GET'),
'SCRIPT_NAME': str(''),
'SERVER_NAME': str('testserver'),
'SERVER_PORT': str('80'),
'SERVER_PROTOCOL': str('HTTP/1.1'),
'wsgi.version': (1, 0),
'wsgi.url_scheme': str('http'),
'wsgi.input': FakePayload(b''),
'wsgi.errors': self.errors,
'wsgi.multiprocess': True,
'wsgi.multithread': False,
'wsgi.run_once': False,
}
environ.update(self.defaults)
environ.update(request)
return environ
def request(self, **request):
"Construct a generic request object."
return WSGIRequest(self._base_environ(**request))
def _encode_data(self, data, content_type):
if content_type is MULTIPART_CONTENT:
return encode_multipart(BOUNDARY, data)
else:
# Encode the content so that the byte representation is correct.
match = CONTENT_TYPE_RE.match(content_type)
if match:
charset = match.group(1)
else:
charset = settings.DEFAULT_CHARSET
return force_bytes(data, encoding=charset)
def _get_path(self, parsed):
path = force_str(parsed[2])
# If there are parameters, add them
if parsed[3]:
path += str(";") + force_str(parsed[3])
path = uri_to_iri(path).encode(UTF_8)
# Under Python 3, non-ASCII values in the WSGI environ are arbitrarily
# decoded with ISO-8859-1. We replicate this behavior here.
# Refs comment in `get_bytes_from_wsgi()`.
return path.decode(ISO_8859_1) if six.PY3 else path
def get(self, path, data=None, secure=False, **extra):
"Construct a GET request."
data = {} if data is None else data
r = {
'QUERY_STRING': urlencode(data, doseq=True),
}
r.update(extra)
return self.generic('GET', path, secure=secure, **r)
def post(self, path, data=None, content_type=MULTIPART_CONTENT,
secure=False, **extra):
"Construct a POST request."
data = {} if data is None else data
post_data = self._encode_data(data, content_type)
return self.generic('POST', path, post_data, content_type,
secure=secure, **extra)
def head(self, path, data=None, secure=False, **extra):
"Construct a HEAD request."
data = {} if data is None else data
r = {
'QUERY_STRING': urlencode(data, doseq=True),
}
r.update(extra)
return self.generic('HEAD', path, secure=secure, **r)
def trace(self, path, secure=False, **extra):
"Construct a TRACE request."
return self.generic('TRACE', path, secure=secure, **extra)
def options(self, path, data='', content_type='application/octet-stream',
secure=False, **extra):
"Construct an OPTIONS request."
return self.generic('OPTIONS', path, data, content_type,
secure=secure, **extra)
def put(self, path, data='', content_type='application/octet-stream',
secure=False, **extra):
"Construct a PUT request."
return self.generic('PUT', path, data, content_type,
secure=secure, **extra)
def patch(self, path, data='', content_type='application/octet-stream',
secure=False, **extra):
"Construct a PATCH request."
return self.generic('PATCH', path, data, content_type,
secure=secure, **extra)
def delete(self, path, data='', content_type='application/octet-stream',
secure=False, **extra):
"Construct a DELETE request."
return self.generic('DELETE', path, data, content_type,
secure=secure, **extra)
def generic(self, method, path, data='',
content_type='application/octet-stream', secure=False,
**extra):
"""Constructs an arbitrary HTTP request."""
parsed = urlparse(force_str(path))
data = force_bytes(data, settings.DEFAULT_CHARSET)
r = {
'PATH_INFO': self._get_path(parsed),
'REQUEST_METHOD': str(method),
'SERVER_PORT': str('443') if secure else str('80'),
'wsgi.url_scheme': str('https') if secure else str('http'),
}
if data:
r.update({
'CONTENT_LENGTH': len(data),
'CONTENT_TYPE': str(content_type),
'wsgi.input': FakePayload(data),
})
r.update(extra)
# If QUERY_STRING is absent or empty, we want to extract it from the URL.
if not r.get('QUERY_STRING'):
query_string = force_bytes(parsed[4])
# WSGI requires latin-1 encoded strings. See get_path_info().
if six.PY3:
query_string = query_string.decode('iso-8859-1')
r['QUERY_STRING'] = query_string
return self.request(**r)
class Client(RequestFactory):
"""
A class that can act as a client for testing purposes.
It allows the user to compose GET and POST requests, and
obtain the response that the server gave to those requests.
The server Response objects are annotated with the details
of the contexts and templates that were rendered during the
process of serving the request.
Client objects are stateful - they will retain cookie (and
thus session) details for the lifetime of the Client instance.
This is not intended as a replacement for Twill/Selenium or
the like - it is here to allow testing against the
contexts and templates produced by a view, rather than the
HTML rendered to the end-user.
"""
def __init__(self, enforce_csrf_checks=False, **defaults):
super(Client, self).__init__(**defaults)
self.handler = ClientHandler(enforce_csrf_checks)
self.exc_info = None
def store_exc_info(self, **kwargs):
"""
Stores exceptions when they are generated by a view.
"""
self.exc_info = sys.exc_info()
@property
def session(self):
"""
Obtains the current session variables.
"""
engine = import_module(settings.SESSION_ENGINE)
cookie = self.cookies.get(settings.SESSION_COOKIE_NAME)
if cookie:
return engine.SessionStore(cookie.value)
session = engine.SessionStore()
session.save()
self.cookies[settings.SESSION_COOKIE_NAME] = session.session_key
return session
def request(self, **request):
"""
The master request method. Composes the environment dictionary
and passes to the handler, returning the result of the handler.
Assumes defaults for the query environment, which can be overridden
using the arguments to the request.
"""
environ = self._base_environ(**request)
# Curry a data dictionary into an instance of the template renderer
# callback function.
data = {}
on_template_render = curry(store_rendered_templates, data)
signal_uid = "template-render-%s" % id(request)
signals.template_rendered.connect(on_template_render, dispatch_uid=signal_uid)
# Capture exceptions created by the handler.
exception_uid = "request-exception-%s" % id(request)
got_request_exception.connect(self.store_exc_info, dispatch_uid=exception_uid)
try:
try:
response = self.handler(environ)
except TemplateDoesNotExist as e:
# If the view raises an exception, Django will attempt to show
# the 500.html template. If that template is not available,
# we should ignore the error in favor of re-raising the
# underlying exception that caused the 500 error. Any other
# template found to be missing during view error handling
# should be reported as-is.
if e.args != ('500.html',):
raise
# Look for a signalled exception, clear the current context
# exception data, then re-raise the signalled exception.
# Also make sure that the signalled exception is cleared from
# the local cache!
if self.exc_info:
exc_info = self.exc_info
self.exc_info = None
six.reraise(*exc_info)
# Save the client and request that stimulated the response.
response.client = self
response.request = request
# Add any rendered template detail to the response.
response.templates = data.get("templates", [])
response.context = data.get("context")
response.json = curry(self._parse_json, response)
# Attach the ResolverMatch instance to the response
response.resolver_match = SimpleLazyObject(lambda: resolve(request['PATH_INFO']))
# Flatten a single context. Not really necessary anymore thanks to
# the __getattr__ flattening in ContextList, but has some edge-case
# backwards-compatibility implications.
if response.context and len(response.context) == 1:
response.context = response.context[0]
# Update persistent cookie data.
if response.cookies:
self.cookies.update(response.cookies)
return response
finally:
signals.template_rendered.disconnect(dispatch_uid=signal_uid)
got_request_exception.disconnect(dispatch_uid=exception_uid)
def get(self, path, data=None, follow=False, secure=False, **extra):
"""
Requests a response from the server using GET.
"""
response = super(Client, self).get(path, data=data, secure=secure,
**extra)
if follow:
response = self._handle_redirects(response, **extra)
return response
def post(self, path, data=None, content_type=MULTIPART_CONTENT,
follow=False, secure=False, **extra):
"""
Requests a response from the server using POST.
"""
response = super(Client, self).post(path, data=data,
content_type=content_type,
secure=secure, **extra)
if follow:
response = self._handle_redirects(response, **extra)
return response
def head(self, path, data=None, follow=False, secure=False, **extra):
"""
Request a response from the server using HEAD.
"""
response = super(Client, self).head(path, data=data, secure=secure,
**extra)
if follow:
response = self._handle_redirects(response, **extra)
return response
def options(self, path, data='', content_type='application/octet-stream',
follow=False, secure=False, **extra):
"""
Request a response from the server using OPTIONS.
"""
response = super(Client, self).options(path, data=data,
content_type=content_type,
secure=secure, **extra)
if follow:
response = self._handle_redirects(response, **extra)
return response
def put(self, path, data='', content_type='application/octet-stream',
follow=False, secure=False, **extra):
"""
Send a resource to the server using PUT.
"""
response = super(Client, self).put(path, data=data,
content_type=content_type,
secure=secure, **extra)
if follow:
response = self._handle_redirects(response, **extra)
return response
def patch(self, path, data='', content_type='application/octet-stream',
follow=False, secure=False, **extra):
"""
Send a resource to the server using PATCH.
"""
response = super(Client, self).patch(path, data=data,
content_type=content_type,
secure=secure, **extra)
if follow:
response = self._handle_redirects(response, **extra)
return response
def delete(self, path, data='', content_type='application/octet-stream',
follow=False, secure=False, **extra):
"""
Send a DELETE request to the server.
"""
response = super(Client, self).delete(path, data=data,
content_type=content_type,
secure=secure, **extra)
if follow:
response = self._handle_redirects(response, **extra)
return response
def trace(self, path, data='', follow=False, secure=False, **extra):
"""
Send a TRACE request to the server.
"""
response = super(Client, self).trace(path, data=data, secure=secure, **extra)
if follow:
response = self._handle_redirects(response, **extra)
return response
def login(self, **credentials):
"""
Sets the Factory to appear as if it has successfully logged into a site.
Returns True if login is possible; False if the provided credentials
are incorrect.
"""
from django.contrib.auth import authenticate
user = authenticate(**credentials)
if user:
self._login(user)
return True
else:
return False
def force_login(self, user, backend=None):
def get_backend():
from django.contrib.auth import load_backend
for backend_path in settings.AUTHENTICATION_BACKENDS:
backend = load_backend(backend_path)
if hasattr(backend, 'get_user'):
return backend_path
if backend is None:
backend = get_backend()
user.backend = backend
self._login(user, backend)
def _login(self, user, backend=None):
from django.contrib.auth import login
engine = import_module(settings.SESSION_ENGINE)
# Create a fake request to store login details.
request = HttpRequest()
if self.session:
request.session = self.session
else:
request.session = engine.SessionStore()
login(request, user, backend)
# Save the session values.
request.session.save()
# Set the cookie to represent the session.
session_cookie = settings.SESSION_COOKIE_NAME
self.cookies[session_cookie] = request.session.session_key
cookie_data = {
'max-age': None,
'path': '/',
'domain': settings.SESSION_COOKIE_DOMAIN,
'secure': settings.SESSION_COOKIE_SECURE or None,
'expires': None,
}
self.cookies[session_cookie].update(cookie_data)
def logout(self):
"""
Removes the authenticated user's cookies and session object.
Causes the authenticated user to be logged out.
"""
from django.contrib.auth import get_user, logout
request = HttpRequest()
engine = import_module(settings.SESSION_ENGINE)
if self.session:
request.session = self.session
request.user = get_user(request)
else:
request.session = engine.SessionStore()
logout(request)
self.cookies = SimpleCookie()
def _parse_json(self, response, **extra):
if not hasattr(response, '_json'):
if not JSON_CONTENT_TYPE_RE.match(response.get('Content-Type')):
raise ValueError(
'Content-Type header is "{0}", not "application/json"'
.format(response.get('Content-Type'))
)
response._json = json.loads(response.content.decode(), **extra)
return response._json
def _handle_redirects(self, response, **extra):
"Follows any redirects by requesting responses from the server using GET."
response.redirect_chain = []
while response.status_code in (301, 302, 303, 307):
response_url = response.url
redirect_chain = response.redirect_chain
redirect_chain.append((response_url, response.status_code))
url = urlsplit(response_url)
if url.scheme:
extra['wsgi.url_scheme'] = url.scheme
if url.hostname:
extra['SERVER_NAME'] = url.hostname
if url.port:
extra['SERVER_PORT'] = str(url.port)
# Prepend the request path to handle relative path redirects
path = url.path
if not path.startswith('/'):
path = urljoin(response.request['PATH_INFO'], path)
response = self.get(path, QueryDict(url.query), follow=False, **extra)
response.redirect_chain = redirect_chain
if redirect_chain[-1] in redirect_chain[:-1]:
# Check that we're not redirecting to somewhere we've already
# been to, to prevent loops.
raise RedirectCycleError("Redirect loop detected.", last_response=response)
if len(redirect_chain) > 20:
# Such a lengthy chain likely also means a loop, but one with
# a growing path, changing view, or changing query argument;
# 20 is the value of "network.http.redirection-limit" from Firefox.
raise RedirectCycleError("Too many redirects.", last_response=response)
return response
Django-1.11.11/django/test/utils.py 0000664 0001750 0001750 00000072162 13247520250 016427 0 ustar tim tim 0000000 0000000 import collections
import logging
import re
import sys
import time
import warnings
from contextlib import contextmanager
from functools import wraps
from unittest import TestCase, skipIf, skipUnless
from xml.dom.minidom import Node, parseString
from django.apps import apps
from django.apps.registry import Apps
from django.conf import UserSettingsHolder, settings
from django.core import mail
from django.core.exceptions import ImproperlyConfigured
from django.core.signals import request_started
from django.db import DEFAULT_DB_ALIAS, connections, reset_queries
from django.db.models.options import Options
from django.template import Template
from django.test.signals import setting_changed, template_rendered
from django.urls import get_script_prefix, set_script_prefix
from django.utils import six
from django.utils.decorators import available_attrs
from django.utils.encoding import force_str
from django.utils.translation import deactivate
if six.PY3:
from types import SimpleNamespace
else:
class SimpleNamespace(object):
pass
try:
import jinja2
except ImportError:
jinja2 = None
__all__ = (
'Approximate', 'ContextList', 'isolate_lru_cache', 'get_runner',
'modify_settings', 'override_settings',
'requires_tz_support',
'setup_test_environment', 'teardown_test_environment',
)
TZ_SUPPORT = hasattr(time, 'tzset')
class Approximate(object):
def __init__(self, val, places=7):
self.val = val
self.places = places
def __repr__(self):
return repr(self.val)
def __eq__(self, other):
if self.val == other:
return True
return round(abs(self.val - other), self.places) == 0
class ContextList(list):
"""A wrapper that provides direct key access to context items contained
in a list of context objects.
"""
def __getitem__(self, key):
if isinstance(key, six.string_types):
for subcontext in self:
if key in subcontext:
return subcontext[key]
raise KeyError(key)
else:
return super(ContextList, self).__getitem__(key)
def get(self, key, default=None):
try:
return self.__getitem__(key)
except KeyError:
return default
def __contains__(self, key):
try:
self[key]
except KeyError:
return False
return True
def keys(self):
"""
Flattened keys of subcontexts.
"""
keys = set()
for subcontext in self:
for dict in subcontext:
keys |= set(dict.keys())
return keys
def instrumented_test_render(self, context):
"""
An instrumented Template render method, providing a signal
that can be intercepted by the test system Client
"""
template_rendered.send(sender=self, template=self, context=context)
return self.nodelist.render(context)
class _TestState(object):
pass
def setup_test_environment(debug=None):
"""
Perform global pre-test setup, such as installing the instrumented template
renderer and setting the email backend to the locmem email backend.
"""
if hasattr(_TestState, 'saved_data'):
# Executing this function twice would overwrite the saved values.
raise RuntimeError(
"setup_test_environment() was already called and can't be called "
"again without first calling teardown_test_environment()."
)
if debug is None:
debug = settings.DEBUG
saved_data = SimpleNamespace()
_TestState.saved_data = saved_data
saved_data.allowed_hosts = settings.ALLOWED_HOSTS
# Add the default host of the test client.
settings.ALLOWED_HOSTS = list(settings.ALLOWED_HOSTS) + ['testserver']
saved_data.debug = settings.DEBUG
settings.DEBUG = debug
saved_data.email_backend = settings.EMAIL_BACKEND
settings.EMAIL_BACKEND = 'django.core.mail.backends.locmem.EmailBackend'
saved_data.template_render = Template._render
Template._render = instrumented_test_render
mail.outbox = []
deactivate()
def teardown_test_environment():
"""
Perform any global post-test teardown, such as restoring the original
template renderer and restoring the email sending functions.
"""
saved_data = _TestState.saved_data
settings.ALLOWED_HOSTS = saved_data.allowed_hosts
settings.DEBUG = saved_data.debug
settings.EMAIL_BACKEND = saved_data.email_backend
Template._render = saved_data.template_render
del _TestState.saved_data
del mail.outbox
def setup_databases(verbosity, interactive, keepdb=False, debug_sql=False, parallel=0, **kwargs):
"""
Create the test databases.
"""
test_databases, mirrored_aliases = get_unique_databases_and_mirrors()
old_names = []
for signature, (db_name, aliases) in test_databases.items():
first_alias = None
for alias in aliases:
connection = connections[alias]
old_names.append((connection, db_name, first_alias is None))
# Actually create the database for the first connection
if first_alias is None:
first_alias = alias
connection.creation.create_test_db(
verbosity=verbosity,
autoclobber=not interactive,
keepdb=keepdb,
serialize=connection.settings_dict.get('TEST', {}).get('SERIALIZE', True),
)
if parallel > 1:
for index in range(parallel):
connection.creation.clone_test_db(
number=index + 1,
verbosity=verbosity,
keepdb=keepdb,
)
# Configure all other connections as mirrors of the first one
else:
connections[alias].creation.set_as_test_mirror(connections[first_alias].settings_dict)
# Configure the test mirrors.
for alias, mirror_alias in mirrored_aliases.items():
connections[alias].creation.set_as_test_mirror(
connections[mirror_alias].settings_dict)
if debug_sql:
for alias in connections:
connections[alias].force_debug_cursor = True
return old_names
def dependency_ordered(test_databases, dependencies):
"""
Reorder test_databases into an order that honors the dependencies
described in TEST[DEPENDENCIES].
"""
ordered_test_databases = []
resolved_databases = set()
# Maps db signature to dependencies of all its aliases
dependencies_map = {}
# Check that no database depends on its own alias
for sig, (_, aliases) in test_databases:
all_deps = set()
for alias in aliases:
all_deps.update(dependencies.get(alias, []))
if not all_deps.isdisjoint(aliases):
raise ImproperlyConfigured(
"Circular dependency: databases %r depend on each other, "
"but are aliases." % aliases
)
dependencies_map[sig] = all_deps
while test_databases:
changed = False
deferred = []
# Try to find a DB that has all its dependencies met
for signature, (db_name, aliases) in test_databases:
if dependencies_map[signature].issubset(resolved_databases):
resolved_databases.update(aliases)
ordered_test_databases.append((signature, (db_name, aliases)))
changed = True
else:
deferred.append((signature, (db_name, aliases)))
if not changed:
raise ImproperlyConfigured("Circular dependency in TEST[DEPENDENCIES]")
test_databases = deferred
return ordered_test_databases
def get_unique_databases_and_mirrors():
"""
Figure out which databases actually need to be created.
Deduplicate entries in DATABASES that correspond the same database or are
configured as test mirrors.
Return two values:
- test_databases: ordered mapping of signatures to (name, list of aliases)
where all aliases share the same underlying database.
- mirrored_aliases: mapping of mirror aliases to original aliases.
"""
mirrored_aliases = {}
test_databases = {}
dependencies = {}
default_sig = connections[DEFAULT_DB_ALIAS].creation.test_db_signature()
for alias in connections:
connection = connections[alias]
test_settings = connection.settings_dict['TEST']
if test_settings['MIRROR']:
# If the database is marked as a test mirror, save the alias.
mirrored_aliases[alias] = test_settings['MIRROR']
else:
# Store a tuple with DB parameters that uniquely identify it.
# If we have two aliases with the same values for that tuple,
# we only need to create the test database once.
item = test_databases.setdefault(
connection.creation.test_db_signature(),
(connection.settings_dict['NAME'], set())
)
item[1].add(alias)
if 'DEPENDENCIES' in test_settings:
dependencies[alias] = test_settings['DEPENDENCIES']
else:
if alias != DEFAULT_DB_ALIAS and connection.creation.test_db_signature() != default_sig:
dependencies[alias] = test_settings.get('DEPENDENCIES', [DEFAULT_DB_ALIAS])
test_databases = dependency_ordered(test_databases.items(), dependencies)
test_databases = collections.OrderedDict(test_databases)
return test_databases, mirrored_aliases
def teardown_databases(old_config, verbosity, parallel=0, keepdb=False):
"""
Destroy all the non-mirror databases.
"""
for connection, old_name, destroy in old_config:
if destroy:
if parallel > 1:
for index in range(parallel):
connection.creation.destroy_test_db(
number=index + 1,
verbosity=verbosity,
keepdb=keepdb,
)
connection.creation.destroy_test_db(old_name, verbosity, keepdb)
def get_runner(settings, test_runner_class=None):
if not test_runner_class:
test_runner_class = settings.TEST_RUNNER
test_path = test_runner_class.split('.')
# Allow for Python 2.5 relative paths
if len(test_path) > 1:
test_module_name = '.'.join(test_path[:-1])
else:
test_module_name = '.'
test_module = __import__(test_module_name, {}, {}, force_str(test_path[-1]))
test_runner = getattr(test_module, test_path[-1])
return test_runner
class TestContextDecorator(object):
"""
A base class that can either be used as a context manager during tests
or as a test function or unittest.TestCase subclass decorator to perform
temporary alterations.
`attr_name`: attribute assigned the return value of enable() if used as
a class decorator.
`kwarg_name`: keyword argument passing the return value of enable() if
used as a function decorator.
"""
def __init__(self, attr_name=None, kwarg_name=None):
self.attr_name = attr_name
self.kwarg_name = kwarg_name
def enable(self):
raise NotImplementedError
def disable(self):
raise NotImplementedError
def __enter__(self):
return self.enable()
def __exit__(self, exc_type, exc_value, traceback):
self.disable()
def decorate_class(self, cls):
if issubclass(cls, TestCase):
decorated_setUp = cls.setUp
decorated_tearDown = cls.tearDown
def setUp(inner_self):
context = self.enable()
if self.attr_name:
setattr(inner_self, self.attr_name, context)
decorated_setUp(inner_self)
def tearDown(inner_self):
decorated_tearDown(inner_self)
self.disable()
cls.setUp = setUp
cls.tearDown = tearDown
return cls
raise TypeError('Can only decorate subclasses of unittest.TestCase')
def decorate_callable(self, func):
@wraps(func, assigned=available_attrs(func))
def inner(*args, **kwargs):
with self as context:
if self.kwarg_name:
kwargs[self.kwarg_name] = context
return func(*args, **kwargs)
return inner
def __call__(self, decorated):
if isinstance(decorated, type):
return self.decorate_class(decorated)
elif callable(decorated):
return self.decorate_callable(decorated)
raise TypeError('Cannot decorate object of type %s' % type(decorated))
class override_settings(TestContextDecorator):
"""
Acts as either a decorator or a context manager. If it's a decorator it
takes a function and returns a wrapped function. If it's a contextmanager
it's used with the ``with`` statement. In either event entering/exiting
are called before and after, respectively, the function/block is executed.
"""
def __init__(self, **kwargs):
self.options = kwargs
super(override_settings, self).__init__()
def enable(self):
# Keep this code at the beginning to leave the settings unchanged
# in case it raises an exception because INSTALLED_APPS is invalid.
if 'INSTALLED_APPS' in self.options:
try:
apps.set_installed_apps(self.options['INSTALLED_APPS'])
except Exception:
apps.unset_installed_apps()
raise
override = UserSettingsHolder(settings._wrapped)
for key, new_value in self.options.items():
setattr(override, key, new_value)
self.wrapped = settings._wrapped
settings._wrapped = override
for key, new_value in self.options.items():
setting_changed.send(sender=settings._wrapped.__class__,
setting=key, value=new_value, enter=True)
def disable(self):
if 'INSTALLED_APPS' in self.options:
apps.unset_installed_apps()
settings._wrapped = self.wrapped
del self.wrapped
for key in self.options:
new_value = getattr(settings, key, None)
setting_changed.send(sender=settings._wrapped.__class__,
setting=key, value=new_value, enter=False)
def save_options(self, test_func):
if test_func._overridden_settings is None:
test_func._overridden_settings = self.options
else:
# Duplicate dict to prevent subclasses from altering their parent.
test_func._overridden_settings = dict(
test_func._overridden_settings, **self.options)
def decorate_class(self, cls):
from django.test import SimpleTestCase
if not issubclass(cls, SimpleTestCase):
raise ValueError(
"Only subclasses of Django SimpleTestCase can be decorated "
"with override_settings")
self.save_options(cls)
return cls
class modify_settings(override_settings):
"""
Like override_settings, but makes it possible to append, prepend or remove
items instead of redefining the entire list.
"""
def __init__(self, *args, **kwargs):
if args:
# Hack used when instantiating from SimpleTestCase.setUpClass.
assert not kwargs
self.operations = args[0]
else:
assert not args
self.operations = list(kwargs.items())
super(override_settings, self).__init__()
def save_options(self, test_func):
if test_func._modified_settings is None:
test_func._modified_settings = self.operations
else:
# Duplicate list to prevent subclasses from altering their parent.
test_func._modified_settings = list(
test_func._modified_settings) + self.operations
def enable(self):
self.options = {}
for name, operations in self.operations:
try:
# When called from SimpleTestCase.setUpClass, values may be
# overridden several times; cumulate changes.
value = self.options[name]
except KeyError:
value = list(getattr(settings, name, []))
for action, items in operations.items():
# items my be a single value or an iterable.
if isinstance(items, six.string_types):
items = [items]
if action == 'append':
value = value + [item for item in items if item not in value]
elif action == 'prepend':
value = [item for item in items if item not in value] + value
elif action == 'remove':
value = [item for item in value if item not in items]
else:
raise ValueError("Unsupported action: %s" % action)
self.options[name] = value
super(modify_settings, self).enable()
class override_system_checks(TestContextDecorator):
"""
Acts as a decorator. Overrides list of registered system checks.
Useful when you override `INSTALLED_APPS`, e.g. if you exclude `auth` app,
you also need to exclude its system checks.
"""
def __init__(self, new_checks, deployment_checks=None):
from django.core.checks.registry import registry
self.registry = registry
self.new_checks = new_checks
self.deployment_checks = deployment_checks
super(override_system_checks, self).__init__()
def enable(self):
self.old_checks = self.registry.registered_checks
self.registry.registered_checks = self.new_checks
self.old_deployment_checks = self.registry.deployment_checks
if self.deployment_checks is not None:
self.registry.deployment_checks = self.deployment_checks
def disable(self):
self.registry.registered_checks = self.old_checks
self.registry.deployment_checks = self.old_deployment_checks
def compare_xml(want, got):
"""Tries to do a 'xml-comparison' of want and got. Plain string
comparison doesn't always work because, for example, attribute
ordering should not be important. Comment nodes are not considered in the
comparison. Leading and trailing whitespace is ignored on both chunks.
Based on https://github.com/lxml/lxml/blob/master/src/lxml/doctestcompare.py
"""
_norm_whitespace_re = re.compile(r'[ \t\n][ \t\n]+')
def norm_whitespace(v):
return _norm_whitespace_re.sub(' ', v)
def child_text(element):
return ''.join(c.data for c in element.childNodes
if c.nodeType == Node.TEXT_NODE)
def children(element):
return [c for c in element.childNodes
if c.nodeType == Node.ELEMENT_NODE]
def norm_child_text(element):
return norm_whitespace(child_text(element))
def attrs_dict(element):
return dict(element.attributes.items())
def check_element(want_element, got_element):
if want_element.tagName != got_element.tagName:
return False
if norm_child_text(want_element) != norm_child_text(got_element):
return False
if attrs_dict(want_element) != attrs_dict(got_element):
return False
want_children = children(want_element)
got_children = children(got_element)
if len(want_children) != len(got_children):
return False
for want, got in zip(want_children, got_children):
if not check_element(want, got):
return False
return True
def first_node(document):
for node in document.childNodes:
if node.nodeType != Node.COMMENT_NODE:
return node
want, got = strip_quotes(want, got)
want = want.strip().replace('\\n', '\n')
got = got.strip().replace('\\n', '\n')
# If the string is not a complete xml document, we may need to add a
# root element. This allow us to compare fragments, like ""
if not want.startswith('%s'
want = wrapper % want
got = wrapper % got
# Parse the want and got strings, and compare the parsings.
want_root = first_node(parseString(want))
got_root = first_node(parseString(got))
return check_element(want_root, got_root)
def strip_quotes(want, got):
"""
Strip quotes of doctests output values:
>>> strip_quotes("'foo'")
"foo"
>>> strip_quotes('"foo"')
"foo"
"""
def is_quoted_string(s):
s = s.strip()
return len(s) >= 2 and s[0] == s[-1] and s[0] in ('"', "'")
def is_quoted_unicode(s):
s = s.strip()
return len(s) >= 3 and s[0] == 'u' and s[1] == s[-1] and s[1] in ('"', "'")
if is_quoted_string(want) and is_quoted_string(got):
want = want.strip()[1:-1]
got = got.strip()[1:-1]
elif is_quoted_unicode(want) and is_quoted_unicode(got):
want = want.strip()[2:-1]
got = got.strip()[2:-1]
return want, got
def str_prefix(s):
return s % {'_': '' if six.PY3 else 'u'}
class CaptureQueriesContext(object):
"""
Context manager that captures queries executed by the specified connection.
"""
def __init__(self, connection):
self.connection = connection
def __iter__(self):
return iter(self.captured_queries)
def __getitem__(self, index):
return self.captured_queries[index]
def __len__(self):
return len(self.captured_queries)
@property
def captured_queries(self):
return self.connection.queries[self.initial_queries:self.final_queries]
def __enter__(self):
self.force_debug_cursor = self.connection.force_debug_cursor
self.connection.force_debug_cursor = True
self.initial_queries = len(self.connection.queries_log)
self.final_queries = None
request_started.disconnect(reset_queries)
return self
def __exit__(self, exc_type, exc_value, traceback):
self.connection.force_debug_cursor = self.force_debug_cursor
request_started.connect(reset_queries)
if exc_type is not None:
return
self.final_queries = len(self.connection.queries_log)
class ignore_warnings(TestContextDecorator):
def __init__(self, **kwargs):
self.ignore_kwargs = kwargs
if 'message' in self.ignore_kwargs or 'module' in self.ignore_kwargs:
self.filter_func = warnings.filterwarnings
else:
self.filter_func = warnings.simplefilter
super(ignore_warnings, self).__init__()
def enable(self):
self.catch_warnings = warnings.catch_warnings()
self.catch_warnings.__enter__()
self.filter_func('ignore', **self.ignore_kwargs)
def disable(self):
self.catch_warnings.__exit__(*sys.exc_info())
@contextmanager
def patch_logger(logger_name, log_level, log_kwargs=False):
"""
Context manager that takes a named logger and the logging level
and provides a simple mock-like list of messages received
"""
calls = []
def replacement(msg, *args, **kwargs):
call = msg % args
calls.append((call, kwargs) if log_kwargs else call)
logger = logging.getLogger(logger_name)
orig = getattr(logger, log_level)
setattr(logger, log_level, replacement)
try:
yield calls
finally:
setattr(logger, log_level, orig)
# On OSes that don't provide tzset (Windows), we can't set the timezone
# in which the program runs. As a consequence, we must skip tests that
# don't enforce a specific timezone (with timezone.override or equivalent),
# or attempt to interpret naive datetimes in the default timezone.
requires_tz_support = skipUnless(
TZ_SUPPORT,
"This test relies on the ability to run a program in an arbitrary "
"time zone, but your operating system isn't able to do that."
)
@contextmanager
def extend_sys_path(*paths):
"""Context manager to temporarily add paths to sys.path."""
_orig_sys_path = sys.path[:]
sys.path.extend(paths)
try:
yield
finally:
sys.path = _orig_sys_path
@contextmanager
def isolate_lru_cache(lru_cache_object):
"""Clear the cache of an LRU cache object on entering and exiting."""
lru_cache_object.cache_clear()
try:
yield
finally:
lru_cache_object.cache_clear()
@contextmanager
def captured_output(stream_name):
"""Return a context manager used by captured_stdout/stdin/stderr
that temporarily replaces the sys stream *stream_name* with a StringIO.
Note: This function and the following ``captured_std*`` are copied
from CPython's ``test.support`` module."""
orig_stdout = getattr(sys, stream_name)
setattr(sys, stream_name, six.StringIO())
try:
yield getattr(sys, stream_name)
finally:
setattr(sys, stream_name, orig_stdout)
def captured_stdout():
"""Capture the output of sys.stdout:
with captured_stdout() as stdout:
print("hello")
self.assertEqual(stdout.getvalue(), "hello\n")
"""
return captured_output("stdout")
def captured_stderr():
"""Capture the output of sys.stderr:
with captured_stderr() as stderr:
print("hello", file=sys.stderr)
self.assertEqual(stderr.getvalue(), "hello\n")
"""
return captured_output("stderr")
def captured_stdin():
"""Capture the input to sys.stdin:
with captured_stdin() as stdin:
stdin.write('hello\n')
stdin.seek(0)
# call test code that consumes from sys.stdin
captured = input()
self.assertEqual(captured, "hello")
"""
return captured_output("stdin")
def reset_warning_registry():
"""
Clear warning registry for all modules. This is required in some tests
because of a bug in Python that prevents warnings.simplefilter("always")
from always making warnings appear: http://bugs.python.org/issue4180
The bug was fixed in Python 3.4.2.
"""
key = "__warningregistry__"
for mod in sys.modules.values():
if hasattr(mod, key):
getattr(mod, key).clear()
@contextmanager
def freeze_time(t):
"""
Context manager to temporarily freeze time.time(). This temporarily
modifies the time function of the time module. Modules which import the
time function directly (e.g. `from time import time`) won't be affected
This isn't meant as a public API, but helps reduce some repetitive code in
Django's test suite.
"""
_real_time = time.time
time.time = lambda: t
try:
yield
finally:
time.time = _real_time
def require_jinja2(test_func):
"""
Decorator to enable a Jinja2 template engine in addition to the regular
Django template engine for a test or skip it if Jinja2 isn't available.
"""
test_func = skipIf(jinja2 is None, "this test requires jinja2")(test_func)
test_func = override_settings(TEMPLATES=[{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'APP_DIRS': True,
}, {
'BACKEND': 'django.template.backends.jinja2.Jinja2',
'APP_DIRS': True,
'OPTIONS': {'keep_trailing_newline': True},
}])(test_func)
return test_func
class override_script_prefix(TestContextDecorator):
"""
Decorator or context manager to temporary override the script prefix.
"""
def __init__(self, prefix):
self.prefix = prefix
super(override_script_prefix, self).__init__()
def enable(self):
self.old_prefix = get_script_prefix()
set_script_prefix(self.prefix)
def disable(self):
set_script_prefix(self.old_prefix)
class LoggingCaptureMixin(object):
"""
Capture the output from the 'django' logger and store it on the class's
logger_output attribute.
"""
def setUp(self):
self.logger = logging.getLogger('django')
self.old_stream = self.logger.handlers[0].stream
self.logger_output = six.StringIO()
self.logger.handlers[0].stream = self.logger_output
def tearDown(self):
self.logger.handlers[0].stream = self.old_stream
class isolate_apps(TestContextDecorator):
"""
Act as either a decorator or a context manager to register models defined
in its wrapped context to an isolated registry.
The list of installed apps the isolated registry should contain must be
passed as arguments.
Two optional keyword arguments can be specified:
`attr_name`: attribute assigned the isolated registry if used as a class
decorator.
`kwarg_name`: keyword argument passing the isolated registry if used as a
function decorator.
"""
def __init__(self, *installed_apps, **kwargs):
self.installed_apps = installed_apps
super(isolate_apps, self).__init__(**kwargs)
def enable(self):
self.old_apps = Options.default_apps
apps = Apps(self.installed_apps)
setattr(Options, 'default_apps', apps)
return apps
def disable(self):
setattr(Options, 'default_apps', self.old_apps)
def tag(*tags):
"""
Decorator to add tags to a test class or method.
"""
def decorator(obj):
setattr(obj, 'tags', set(tags))
return obj
return decorator
Django-1.11.11/django/test/html.py 0000664 0001750 0001750 00000017600 13247520250 016227 0 ustar tim tim 0000000 0000000 """
Comparing two html documents.
"""
from __future__ import unicode_literals
import re
from django.utils import six
from django.utils.encoding import force_text, python_2_unicode_compatible
from django.utils.html_parser import HTMLParseError, HTMLParser
WHITESPACE = re.compile(r'\s+')
def normalize_whitespace(string):
return WHITESPACE.sub(' ', string)
@python_2_unicode_compatible
class Element(object):
def __init__(self, name, attributes):
self.name = name
self.attributes = sorted(attributes)
self.children = []
def append(self, element):
if isinstance(element, six.string_types):
element = force_text(element)
element = normalize_whitespace(element)
if self.children:
if isinstance(self.children[-1], six.string_types):
self.children[-1] += element
self.children[-1] = normalize_whitespace(self.children[-1])
return
elif self.children:
# removing last children if it is only whitespace
# this can result in incorrect dom representations since
# whitespace between inline tags like is significant
if isinstance(self.children[-1], six.string_types):
if self.children[-1].isspace():
self.children.pop()
if element:
self.children.append(element)
def finalize(self):
def rstrip_last_element(children):
if children:
if isinstance(children[-1], six.string_types):
children[-1] = children[-1].rstrip()
if not children[-1]:
children.pop()
children = rstrip_last_element(children)
return children
rstrip_last_element(self.children)
for i, child in enumerate(self.children):
if isinstance(child, six.string_types):
self.children[i] = child.strip()
elif hasattr(child, 'finalize'):
child.finalize()
def __eq__(self, element):
if not hasattr(element, 'name'):
return False
if hasattr(element, 'name') and self.name != element.name:
return False
if len(self.attributes) != len(element.attributes):
return False
if self.attributes != element.attributes:
# attributes without a value is same as attribute with value that
# equals the attributes name:
# ==
for i in range(len(self.attributes)):
attr, value = self.attributes[i]
other_attr, other_value = element.attributes[i]
if value is None:
value = attr
if other_value is None:
other_value = other_attr
if attr != other_attr or value != other_value:
return False
if self.children != element.children:
return False
return True
def __hash__(self):
return hash((self.name,) + tuple(a for a in self.attributes))
def __ne__(self, element):
return not self.__eq__(element)
def _count(self, element, count=True):
if not isinstance(element, six.string_types):
if self == element:
return 1
if isinstance(element, RootElement):
if self.children == element.children:
return 1
i = 0
for child in self.children:
# child is text content and element is also text content, then
# make a simple "text" in "text"
if isinstance(child, six.string_types):
if isinstance(element, six.string_types):
if count:
i += child.count(element)
elif element in child:
return 1
else:
i += child._count(element, count=count)
if not count and i:
return i
return i
def __contains__(self, element):
return self._count(element, count=False) > 0
def count(self, element):
return self._count(element, count=True)
def __getitem__(self, key):
return self.children[key]
def __str__(self):
output = '<%s' % self.name
for key, value in self.attributes:
if value:
output += ' %s="%s"' % (key, value)
else:
output += ' %s' % key
if self.children:
output += '>\n'
output += ''.join(six.text_type(c) for c in self.children)
output += '\n%s>' % self.name
else:
output += ' />'
return output
def __repr__(self):
return six.text_type(self)
@python_2_unicode_compatible
class RootElement(Element):
def __init__(self):
super(RootElement, self).__init__(None, ())
def __str__(self):
return ''.join(six.text_type(c) for c in self.children)
class Parser(HTMLParser):
SELF_CLOSING_TAGS = (
'br', 'hr', 'input', 'img', 'meta', 'spacer', 'link', 'frame', 'base',
'col',
)
def __init__(self):
HTMLParser.__init__(self)
self.root = RootElement()
self.open_tags = []
self.element_positions = {}
def error(self, msg):
raise HTMLParseError(msg, self.getpos())
def format_position(self, position=None, element=None):
if not position and element:
position = self.element_positions[element]
if position is None:
position = self.getpos()
if hasattr(position, 'lineno'):
position = position.lineno, position.offset
return 'Line %d, Column %d' % position
@property
def current(self):
if self.open_tags:
return self.open_tags[-1]
else:
return self.root
def handle_startendtag(self, tag, attrs):
self.handle_starttag(tag, attrs)
if tag not in self.SELF_CLOSING_TAGS:
self.handle_endtag(tag)
def handle_starttag(self, tag, attrs):
# Special case handling of 'class' attribute, so that comparisons of DOM
# instances are not sensitive to ordering of classes.
attrs = [
(name, " ".join(sorted(value.split(" "))))
if name == "class"
else (name, value)
for name, value in attrs
]
element = Element(tag, attrs)
self.current.append(element)
if tag not in self.SELF_CLOSING_TAGS:
self.open_tags.append(element)
self.element_positions[element] = self.getpos()
def handle_endtag(self, tag):
if not self.open_tags:
self.error("Unexpected end tag `%s` (%s)" % (
tag, self.format_position()))
element = self.open_tags.pop()
while element.name != tag:
if not self.open_tags:
self.error("Unexpected end tag `%s` (%s)" % (
tag, self.format_position()))
element = self.open_tags.pop()
def handle_data(self, data):
self.current.append(data)
def handle_charref(self, name):
self.current.append('&%s;' % name)
def handle_entityref(self, name):
self.current.append('&%s;' % name)
def parse_html(html):
"""
Takes a string that contains *valid* HTML and turns it into a Python object
structure that can be easily compared against other HTML on semantic
equivalence. Syntactical differences like which quotation is used on
arguments will be ignored.
"""
parser = Parser()
parser.feed(html)
parser.close()
document = parser.root
document.finalize()
# Removing ROOT element if it's not necessary
if len(document.children) == 1:
if not isinstance(document.children[0], six.string_types):
document = document.children[0]
return document
Django-1.11.11/django/test/runner.py 0000664 0001750 0001750 00000061451 13247520250 016577 0 ustar tim tim 0000000 0000000 import ctypes
import itertools
import logging
import multiprocessing
import os
import pickle
import textwrap
import unittest
import warnings
from importlib import import_module
from django.core.management import call_command
from django.db import connections
from django.test import SimpleTestCase, TestCase
from django.test.utils import (
setup_databases as _setup_databases, setup_test_environment,
teardown_databases as _teardown_databases, teardown_test_environment,
)
from django.utils.datastructures import OrderedSet
from django.utils.deprecation import RemovedInDjango21Warning
from django.utils.six import StringIO
try:
import tblib.pickling_support
except ImportError:
tblib = None
class DebugSQLTextTestResult(unittest.TextTestResult):
def __init__(self, stream, descriptions, verbosity):
self.logger = logging.getLogger('django.db.backends')
self.logger.setLevel(logging.DEBUG)
super(DebugSQLTextTestResult, self).__init__(stream, descriptions, verbosity)
def startTest(self, test):
self.debug_sql_stream = StringIO()
self.handler = logging.StreamHandler(self.debug_sql_stream)
self.logger.addHandler(self.handler)
super(DebugSQLTextTestResult, self).startTest(test)
def stopTest(self, test):
super(DebugSQLTextTestResult, self).stopTest(test)
self.logger.removeHandler(self.handler)
if self.showAll:
self.debug_sql_stream.seek(0)
self.stream.write(self.debug_sql_stream.read())
self.stream.writeln(self.separator2)
def addError(self, test, err):
super(DebugSQLTextTestResult, self).addError(test, err)
self.debug_sql_stream.seek(0)
self.errors[-1] = self.errors[-1] + (self.debug_sql_stream.read(),)
def addFailure(self, test, err):
super(DebugSQLTextTestResult, self).addFailure(test, err)
self.debug_sql_stream.seek(0)
self.failures[-1] = self.failures[-1] + (self.debug_sql_stream.read(),)
def printErrorList(self, flavour, errors):
for test, err, sql_debug in errors:
self.stream.writeln(self.separator1)
self.stream.writeln("%s: %s" % (flavour, self.getDescription(test)))
self.stream.writeln(self.separator2)
self.stream.writeln("%s" % err)
self.stream.writeln(self.separator2)
self.stream.writeln("%s" % sql_debug)
class RemoteTestResult(object):
"""
Record information about which tests have succeeded and which have failed.
The sole purpose of this class is to record events in the child processes
so they can be replayed in the master process. As a consequence it doesn't
inherit unittest.TestResult and doesn't attempt to implement all its API.
The implementation matches the unpythonic coding style of unittest2.
"""
def __init__(self):
if tblib is not None:
tblib.pickling_support.install()
self.events = []
self.failfast = False
self.shouldStop = False
self.testsRun = 0
@property
def test_index(self):
return self.testsRun - 1
def _confirm_picklable(self, obj):
"""
Confirm that obj can be pickled and unpickled as multiprocessing will
need to pickle the exception in the child process and unpickle it in
the parent process. Let the exception rise, if not.
"""
pickle.loads(pickle.dumps(obj))
def _print_unpicklable_subtest(self, test, subtest, pickle_exc):
print("""
Subtest failed:
test: {}
subtest: {}
Unfortunately, the subtest that failed cannot be pickled, so the parallel
test runner cannot handle it cleanly. Here is the pickling error:
> {}
You should re-run this test with --parallel=1 to reproduce the failure
with a cleaner failure message.
""".format(test, subtest, pickle_exc))
def check_picklable(self, test, err):
# Ensure that sys.exc_info() tuples are picklable. This displays a
# clear multiprocessing.pool.RemoteTraceback generated in the child
# process instead of a multiprocessing.pool.MaybeEncodingError, making
# the root cause easier to figure out for users who aren't familiar
# with the multiprocessing module. Since we're in a forked process,
# our best chance to communicate with them is to print to stdout.
try:
self._confirm_picklable(err)
except Exception as exc:
original_exc_txt = repr(err[1])
original_exc_txt = textwrap.fill(original_exc_txt, 75, initial_indent=' ', subsequent_indent=' ')
pickle_exc_txt = repr(exc)
pickle_exc_txt = textwrap.fill(pickle_exc_txt, 75, initial_indent=' ', subsequent_indent=' ')
if tblib is None:
print("""
{} failed:
{}
Unfortunately, tracebacks cannot be pickled, making it impossible for the
parallel test runner to handle this exception cleanly.
In order to see the traceback, you should install tblib:
pip install tblib
""".format(test, original_exc_txt))
else:
print("""
{} failed:
{}
Unfortunately, the exception it raised cannot be pickled, making it impossible
for the parallel test runner to handle it cleanly.
Here's the error encountered while trying to pickle the exception:
{}
You should re-run this test with the --parallel=1 option to reproduce the
failure and get a correct traceback.
""".format(test, original_exc_txt, pickle_exc_txt))
raise
def check_subtest_picklable(self, test, subtest):
try:
self._confirm_picklable(subtest)
except Exception as exc:
self._print_unpicklable_subtest(test, subtest, exc)
raise
def stop_if_failfast(self):
if self.failfast:
self.stop()
def stop(self):
self.shouldStop = True
def startTestRun(self):
self.events.append(('startTestRun',))
def stopTestRun(self):
self.events.append(('stopTestRun',))
def startTest(self, test):
self.testsRun += 1
self.events.append(('startTest', self.test_index))
def stopTest(self, test):
self.events.append(('stopTest', self.test_index))
def addError(self, test, err):
self.check_picklable(test, err)
self.events.append(('addError', self.test_index, err))
self.stop_if_failfast()
def addFailure(self, test, err):
self.check_picklable(test, err)
self.events.append(('addFailure', self.test_index, err))
self.stop_if_failfast()
def addSubTest(self, test, subtest, err):
# Follow Python 3.5's implementation of unittest.TestResult.addSubTest()
# by not doing anything when a subtest is successful.
if err is not None:
# Call check_picklable() before check_subtest_picklable() since
# check_picklable() performs the tblib check.
self.check_picklable(test, err)
self.check_subtest_picklable(test, subtest)
self.events.append(('addSubTest', self.test_index, subtest, err))
self.stop_if_failfast()
def addSuccess(self, test):
self.events.append(('addSuccess', self.test_index))
def addSkip(self, test, reason):
self.events.append(('addSkip', self.test_index, reason))
def addExpectedFailure(self, test, err):
# If tblib isn't installed, pickling the traceback will always fail.
# However we don't want tblib to be required for running the tests
# when they pass or fail as expected. Drop the traceback when an
# expected failure occurs.
if tblib is None:
err = err[0], err[1], None
self.check_picklable(test, err)
self.events.append(('addExpectedFailure', self.test_index, err))
def addUnexpectedSuccess(self, test):
self.events.append(('addUnexpectedSuccess', self.test_index))
self.stop_if_failfast()
class RemoteTestRunner(object):
"""
Run tests and record everything but don't display anything.
The implementation matches the unpythonic coding style of unittest2.
"""
resultclass = RemoteTestResult
def __init__(self, failfast=False, resultclass=None):
self.failfast = failfast
if resultclass is not None:
self.resultclass = resultclass
def run(self, test):
result = self.resultclass()
unittest.registerResult(result)
result.failfast = self.failfast
test(result)
return result
def default_test_processes():
"""
Default number of test processes when using the --parallel option.
"""
# The current implementation of the parallel test runner requires
# multiprocessing to start subprocesses with fork().
# On Python 3.4+: if multiprocessing.get_start_method() != 'fork':
if not hasattr(os, 'fork'):
return 1
try:
return int(os.environ['DJANGO_TEST_PROCESSES'])
except KeyError:
return multiprocessing.cpu_count()
_worker_id = 0
def _init_worker(counter):
"""
Switch to databases dedicated to this worker.
This helper lives at module-level because of the multiprocessing module's
requirements.
"""
global _worker_id
with counter.get_lock():
counter.value += 1
_worker_id = counter.value
for alias in connections:
connection = connections[alias]
settings_dict = connection.creation.get_test_db_clone_settings(_worker_id)
# connection.settings_dict must be updated in place for changes to be
# reflected in django.db.connections. If the following line assigned
# connection.settings_dict = settings_dict, new threads would connect
# to the default database instead of the appropriate clone.
connection.settings_dict.update(settings_dict)
connection.close()
def _run_subsuite(args):
"""
Run a suite of tests with a RemoteTestRunner and return a RemoteTestResult.
This helper lives at module-level and its arguments are wrapped in a tuple
because of the multiprocessing module's requirements.
"""
runner_class, subsuite_index, subsuite, failfast = args
runner = runner_class(failfast=failfast)
result = runner.run(subsuite)
return subsuite_index, result.events
class ParallelTestSuite(unittest.TestSuite):
"""
Run a series of tests in parallel in several processes.
While the unittest module's documentation implies that orchestrating the
execution of tests is the responsibility of the test runner, in practice,
it appears that TestRunner classes are more concerned with formatting and
displaying test results.
Since there are fewer use cases for customizing TestSuite than TestRunner,
implementing parallelization at the level of the TestSuite improves
interoperability with existing custom test runners. A single instance of a
test runner can still collect results from all tests without being aware
that they have been run in parallel.
"""
# In case someone wants to modify these in a subclass.
init_worker = _init_worker
run_subsuite = _run_subsuite
runner_class = RemoteTestRunner
def __init__(self, suite, processes, failfast=False):
self.subsuites = partition_suite_by_case(suite)
self.processes = processes
self.failfast = failfast
super(ParallelTestSuite, self).__init__()
def run(self, result):
"""
Distribute test cases across workers.
Return an identifier of each test case with its result in order to use
imap_unordered to show results as soon as they're available.
To minimize pickling errors when getting results from workers:
- pass back numeric indexes in self.subsuites instead of tests
- make tracebacks picklable with tblib, if available
Even with tblib, errors may still occur for dynamically created
exception classes such Model.DoesNotExist which cannot be unpickled.
"""
counter = multiprocessing.Value(ctypes.c_int, 0)
pool = multiprocessing.Pool(
processes=self.processes,
initializer=self.init_worker.__func__,
initargs=[counter])
args = [
(self.runner_class, index, subsuite, self.failfast)
for index, subsuite in enumerate(self.subsuites)
]
test_results = pool.imap_unordered(self.run_subsuite.__func__, args)
while True:
if result.shouldStop:
pool.terminate()
break
try:
subsuite_index, events = test_results.next(timeout=0.1)
except multiprocessing.TimeoutError:
continue
except StopIteration:
pool.close()
break
tests = list(self.subsuites[subsuite_index])
for event in events:
event_name = event[0]
handler = getattr(result, event_name, None)
if handler is None:
continue
test = tests[event[1]]
args = event[2:]
handler(test, *args)
pool.join()
return result
class DiscoverRunner(object):
"""
A Django test runner that uses unittest2 test discovery.
"""
test_suite = unittest.TestSuite
parallel_test_suite = ParallelTestSuite
test_runner = unittest.TextTestRunner
test_loader = unittest.defaultTestLoader
reorder_by = (TestCase, SimpleTestCase)
def __init__(self, pattern=None, top_level=None, verbosity=1,
interactive=True, failfast=False, keepdb=False,
reverse=False, debug_mode=False, debug_sql=False, parallel=0,
tags=None, exclude_tags=None, **kwargs):
self.pattern = pattern
self.top_level = top_level
self.verbosity = verbosity
self.interactive = interactive
self.failfast = failfast
self.keepdb = keepdb
self.reverse = reverse
self.debug_mode = debug_mode
self.debug_sql = debug_sql
self.parallel = parallel
self.tags = set(tags or [])
self.exclude_tags = set(exclude_tags or [])
@classmethod
def add_arguments(cls, parser):
parser.add_argument(
'-t', '--top-level-directory', action='store', dest='top_level', default=None,
help='Top level of project for unittest discovery.',
)
parser.add_argument(
'-p', '--pattern', action='store', dest='pattern', default="test*.py",
help='The test matching pattern. Defaults to test*.py.',
)
parser.add_argument(
'-k', '--keepdb', action='store_true', dest='keepdb', default=False,
help='Preserves the test DB between runs.'
)
parser.add_argument(
'-r', '--reverse', action='store_true', dest='reverse', default=False,
help='Reverses test cases order.',
)
parser.add_argument(
'--debug-mode', action='store_true', dest='debug_mode', default=False,
help='Sets settings.DEBUG to True.',
)
parser.add_argument(
'-d', '--debug-sql', action='store_true', dest='debug_sql', default=False,
help='Prints logged SQL queries on failure.',
)
parser.add_argument(
'--parallel', dest='parallel', nargs='?', default=1, type=int,
const=default_test_processes(), metavar='N',
help='Run tests using up to N parallel processes.',
)
parser.add_argument(
'--tag', action='append', dest='tags',
help='Run only tests with the specified tag. Can be used multiple times.',
)
parser.add_argument(
'--exclude-tag', action='append', dest='exclude_tags',
help='Do not run tests with the specified tag. Can be used multiple times.',
)
def setup_test_environment(self, **kwargs):
setup_test_environment(debug=self.debug_mode)
unittest.installHandler()
def build_suite(self, test_labels=None, extra_tests=None, **kwargs):
suite = self.test_suite()
test_labels = test_labels or ['.']
extra_tests = extra_tests or []
discover_kwargs = {}
if self.pattern is not None:
discover_kwargs['pattern'] = self.pattern
if self.top_level is not None:
discover_kwargs['top_level_dir'] = self.top_level
for label in test_labels:
kwargs = discover_kwargs.copy()
tests = None
label_as_path = os.path.abspath(label)
# if a module, or "module.ClassName[.method_name]", just run those
if not os.path.exists(label_as_path):
tests = self.test_loader.loadTestsFromName(label)
elif os.path.isdir(label_as_path) and not self.top_level:
# Try to be a bit smarter than unittest about finding the
# default top-level for a given directory path, to avoid
# breaking relative imports. (Unittest's default is to set
# top-level equal to the path, which means relative imports
# will result in "Attempted relative import in non-package.").
# We'd be happy to skip this and require dotted module paths
# (which don't cause this problem) instead of file paths (which
# do), but in the case of a directory in the cwd, which would
# be equally valid if considered as a top-level module or as a
# directory path, unittest unfortunately prefers the latter.
top_level = label_as_path
while True:
init_py = os.path.join(top_level, '__init__.py')
if os.path.exists(init_py):
try_next = os.path.dirname(top_level)
if try_next == top_level:
# __init__.py all the way down? give up.
break
top_level = try_next
continue
break
kwargs['top_level_dir'] = top_level
if not (tests and tests.countTestCases()) and is_discoverable(label):
# Try discovery if path is a package or directory
tests = self.test_loader.discover(start_dir=label, **kwargs)
# Make unittest forget the top-level dir it calculated from this
# run, to support running tests from two different top-levels.
self.test_loader._top_level_dir = None
suite.addTests(tests)
for test in extra_tests:
suite.addTest(test)
if self.tags or self.exclude_tags:
suite = filter_tests_by_tags(suite, self.tags, self.exclude_tags)
suite = reorder_suite(suite, self.reorder_by, self.reverse)
if self.parallel > 1:
parallel_suite = self.parallel_test_suite(suite, self.parallel, self.failfast)
# Since tests are distributed across processes on a per-TestCase
# basis, there's no need for more processes than TestCases.
parallel_units = len(parallel_suite.subsuites)
if self.parallel > parallel_units:
self.parallel = parallel_units
# If there's only one TestCase, parallelization isn't needed.
if self.parallel > 1:
suite = parallel_suite
return suite
def setup_databases(self, **kwargs):
return _setup_databases(
self.verbosity, self.interactive, self.keepdb, self.debug_sql,
self.parallel, **kwargs
)
def get_resultclass(self):
return DebugSQLTextTestResult if self.debug_sql else None
def get_test_runner_kwargs(self):
return {
'failfast': self.failfast,
'resultclass': self.get_resultclass(),
'verbosity': self.verbosity,
}
def run_checks(self):
# Checks are run after database creation since some checks require
# database access.
call_command('check', verbosity=self.verbosity)
def run_suite(self, suite, **kwargs):
kwargs = self.get_test_runner_kwargs()
runner = self.test_runner(**kwargs)
return runner.run(suite)
def teardown_databases(self, old_config, **kwargs):
"""
Destroys all the non-mirror databases.
"""
_teardown_databases(
old_config,
verbosity=self.verbosity,
parallel=self.parallel,
keepdb=self.keepdb,
)
def teardown_test_environment(self, **kwargs):
unittest.removeHandler()
teardown_test_environment()
def suite_result(self, suite, result, **kwargs):
return len(result.failures) + len(result.errors)
def run_tests(self, test_labels, extra_tests=None, **kwargs):
"""
Run the unit tests for all the test labels in the provided list.
Test labels should be dotted Python paths to test modules, test
classes, or test methods.
A list of 'extra' tests may also be provided; these tests
will be added to the test suite.
Returns the number of tests that failed.
"""
self.setup_test_environment()
suite = self.build_suite(test_labels, extra_tests)
old_config = self.setup_databases()
self.run_checks()
result = self.run_suite(suite)
self.teardown_databases(old_config)
self.teardown_test_environment()
return self.suite_result(suite, result)
def is_discoverable(label):
"""
Check if a test label points to a python package or file directory.
Relative labels like "." and ".." are seen as directories.
"""
try:
mod = import_module(label)
except (ImportError, TypeError):
pass
else:
return hasattr(mod, '__path__')
return os.path.isdir(os.path.abspath(label))
def reorder_suite(suite, classes, reverse=False):
"""
Reorders a test suite by test type.
`classes` is a sequence of types
All tests of type classes[0] are placed first, then tests of type
classes[1], etc. Tests with no match in classes are placed last.
If `reverse` is True, tests within classes are sorted in opposite order,
but test classes are not reversed.
"""
class_count = len(classes)
suite_class = type(suite)
bins = [OrderedSet() for i in range(class_count + 1)]
partition_suite_by_type(suite, classes, bins, reverse=reverse)
reordered_suite = suite_class()
for i in range(class_count + 1):
reordered_suite.addTests(bins[i])
return reordered_suite
def partition_suite_by_type(suite, classes, bins, reverse=False):
"""
Partitions a test suite by test type. Also prevents duplicated tests.
classes is a sequence of types
bins is a sequence of TestSuites, one more than classes
reverse changes the ordering of tests within bins
Tests of type classes[i] are added to bins[i],
tests with no match found in classes are place in bins[-1]
"""
suite_class = type(suite)
if reverse:
suite = reversed(tuple(suite))
for test in suite:
if isinstance(test, suite_class):
partition_suite_by_type(test, classes, bins, reverse=reverse)
else:
for i in range(len(classes)):
if isinstance(test, classes[i]):
bins[i].add(test)
break
else:
bins[-1].add(test)
def partition_suite_by_case(suite):
"""
Partitions a test suite by test case, preserving the order of tests.
"""
groups = []
suite_class = type(suite)
for test_type, test_group in itertools.groupby(suite, type):
if issubclass(test_type, unittest.TestCase):
groups.append(suite_class(test_group))
else:
for item in test_group:
groups.extend(partition_suite_by_case(item))
return groups
def setup_databases(*args, **kwargs):
warnings.warn(
'`django.test.runner.setup_databases()` has moved to '
'`django.test.utils.setup_databases()`.',
RemovedInDjango21Warning,
stacklevel=2,
)
return _setup_databases(*args, **kwargs)
def filter_tests_by_tags(suite, tags, exclude_tags):
suite_class = type(suite)
filtered_suite = suite_class()
for test in suite:
if isinstance(test, suite_class):
filtered_suite.addTests(filter_tests_by_tags(test, tags, exclude_tags))
else:
test_tags = set(getattr(test, 'tags', set()))
test_fn_name = getattr(test, '_testMethodName', str(test))
test_fn = getattr(test, test_fn_name, test)
test_fn_tags = set(getattr(test_fn, 'tags', set()))
all_tags = test_tags.union(test_fn_tags)
matched_tags = all_tags.intersection(tags)
if (matched_tags or not tags) and not all_tags.intersection(exclude_tags):
filtered_suite.addTest(test)
return filtered_suite
Django-1.11.11/django/test/__init__.py 0000664 0001750 0001750 00000001577 13247520250 017030 0 ustar tim tim 0000000 0000000 """
Django Unit Test and Doctest framework.
"""
from django.test.client import Client, RequestFactory
from django.test.testcases import (
LiveServerTestCase, SimpleTestCase, TestCase, TransactionTestCase,
skipIfDBFeature, skipUnlessAnyDBFeature, skipUnlessDBFeature,
)
from django.test.utils import (
ignore_warnings, modify_settings, override_settings,
override_system_checks, tag,
)
__all__ = [
'Client', 'RequestFactory', 'TestCase', 'TransactionTestCase',
'SimpleTestCase', 'LiveServerTestCase', 'skipIfDBFeature',
'skipUnlessAnyDBFeature', 'skipUnlessDBFeature', 'ignore_warnings',
'modify_settings', 'override_settings', 'override_system_checks', 'tag',
]
# To simplify Django's test suite; not meant as a public API
try:
from unittest import mock # NOQA
except ImportError:
try:
import mock # NOQA
except ImportError:
pass
Django-1.11.11/django/test/signals.py 0000664 0001750 0001750 00000015140 13247520250 016720 0 ustar tim tim 0000000 0000000 import os
import threading
import time
import warnings
from django.apps import apps
from django.core.exceptions import ImproperlyConfigured
from django.core.signals import setting_changed
from django.db import connections, router
from django.db.utils import ConnectionRouter
from django.dispatch import Signal, receiver
from django.utils import six, timezone
from django.utils.formats import FORMAT_SETTINGS, reset_format_cache
from django.utils.functional import empty
template_rendered = Signal(providing_args=["template", "context"])
# Most setting_changed receivers are supposed to be added below,
# except for cases where the receiver is related to a contrib app.
# Settings that may not work well when using 'override_settings' (#19031)
COMPLEX_OVERRIDE_SETTINGS = {'DATABASES'}
@receiver(setting_changed)
def clear_cache_handlers(**kwargs):
if kwargs['setting'] == 'CACHES':
from django.core.cache import caches
caches._caches = threading.local()
@receiver(setting_changed)
def update_installed_apps(**kwargs):
if kwargs['setting'] == 'INSTALLED_APPS':
# Rebuild any AppDirectoriesFinder instance.
from django.contrib.staticfiles.finders import get_finder
get_finder.cache_clear()
# Rebuild management commands cache
from django.core.management import get_commands
get_commands.cache_clear()
# Rebuild get_app_template_dirs cache.
from django.template.utils import get_app_template_dirs
get_app_template_dirs.cache_clear()
# Rebuild translations cache.
from django.utils.translation import trans_real
trans_real._translations = {}
@receiver(setting_changed)
def update_connections_time_zone(**kwargs):
if kwargs['setting'] == 'TIME_ZONE':
# Reset process time zone
if hasattr(time, 'tzset'):
if kwargs['value']:
os.environ['TZ'] = kwargs['value']
else:
os.environ.pop('TZ', None)
time.tzset()
# Reset local time zone cache
timezone.get_default_timezone.cache_clear()
# Reset the database connections' time zone
if kwargs['setting'] in {'TIME_ZONE', 'USE_TZ'}:
for conn in connections.all():
try:
del conn.timezone
except AttributeError:
pass
try:
del conn.timezone_name
except AttributeError:
pass
conn.ensure_timezone()
@receiver(setting_changed)
def clear_routers_cache(**kwargs):
if kwargs['setting'] == 'DATABASE_ROUTERS':
router.routers = ConnectionRouter().routers
@receiver(setting_changed)
def reset_template_engines(**kwargs):
if kwargs['setting'] in {
'TEMPLATES',
'DEBUG',
'FILE_CHARSET',
'INSTALLED_APPS',
}:
from django.template import engines
try:
del engines.templates
except AttributeError:
pass
engines._templates = None
engines._engines = {}
from django.template.engine import Engine
Engine.get_default.cache_clear()
from django.forms.renderers import get_default_renderer
get_default_renderer.cache_clear()
@receiver(setting_changed)
def clear_serializers_cache(**kwargs):
if kwargs['setting'] == 'SERIALIZATION_MODULES':
from django.core import serializers
serializers._serializers = {}
@receiver(setting_changed)
def language_changed(**kwargs):
if kwargs['setting'] in {'LANGUAGES', 'LANGUAGE_CODE', 'LOCALE_PATHS'}:
from django.utils.translation import trans_real
trans_real._default = None
trans_real._active = threading.local()
if kwargs['setting'] in {'LANGUAGES', 'LOCALE_PATHS'}:
from django.utils.translation import trans_real
trans_real._translations = {}
trans_real.check_for_language.cache_clear()
@receiver(setting_changed)
def localize_settings_changed(**kwargs):
if kwargs['setting'] in FORMAT_SETTINGS or kwargs['setting'] == 'USE_THOUSAND_SEPARATOR':
reset_format_cache()
@receiver(setting_changed)
def file_storage_changed(**kwargs):
if kwargs['setting'] == 'DEFAULT_FILE_STORAGE':
from django.core.files.storage import default_storage
default_storage._wrapped = empty
@receiver(setting_changed)
def complex_setting_changed(**kwargs):
if kwargs['enter'] and kwargs['setting'] in COMPLEX_OVERRIDE_SETTINGS:
# Considering the current implementation of the signals framework,
# this stacklevel shows the line containing the override_settings call.
warnings.warn("Overriding setting %s can lead to unexpected behavior."
% kwargs['setting'], stacklevel=5 if six.PY2 else 6)
@receiver(setting_changed)
def root_urlconf_changed(**kwargs):
if kwargs['setting'] == 'ROOT_URLCONF':
from django.urls import clear_url_caches, set_urlconf
clear_url_caches()
set_urlconf(None)
@receiver(setting_changed)
def static_storage_changed(**kwargs):
if kwargs['setting'] in {
'STATICFILES_STORAGE',
'STATIC_ROOT',
'STATIC_URL',
}:
from django.contrib.staticfiles.storage import staticfiles_storage
staticfiles_storage._wrapped = empty
@receiver(setting_changed)
def static_finders_changed(**kwargs):
if kwargs['setting'] in {
'STATICFILES_DIRS',
'STATIC_ROOT',
}:
from django.contrib.staticfiles.finders import get_finder
get_finder.cache_clear()
@receiver(setting_changed)
def auth_password_validators_changed(**kwargs):
if kwargs['setting'] == 'AUTH_PASSWORD_VALIDATORS':
from django.contrib.auth.password_validation import get_default_password_validators
get_default_password_validators.cache_clear()
@receiver(setting_changed)
def user_model_swapped(**kwargs):
if kwargs['setting'] == 'AUTH_USER_MODEL':
apps.clear_cache()
try:
from django.contrib.auth import get_user_model
UserModel = get_user_model()
except ImproperlyConfigured:
# Some tests set an invalid AUTH_USER_MODEL.
pass
else:
from django.contrib.auth import backends
backends.UserModel = UserModel
from django.contrib.auth import forms
forms.UserModel = UserModel
from django.contrib.auth.handlers import modwsgi
modwsgi.UserModel = UserModel
from django.contrib.auth.management.commands import changepassword
changepassword.UserModel = UserModel
from django.contrib.auth import views
views.UserModel = UserModel
Django-1.11.11/django/test/testcases.py 0000664 0001750 0001750 00000160221 13247520250 017257 0 ustar tim tim 0000000 0000000 from __future__ import unicode_literals
import difflib
import json
import posixpath
import sys
import threading
import unittest
import warnings
from collections import Counter
from contextlib import contextmanager
from copy import copy
from functools import wraps
from unittest.util import safe_repr
from django.apps import apps
from django.conf import settings
from django.core import mail
from django.core.exceptions import ValidationError
from django.core.files import locks
from django.core.handlers.wsgi import WSGIHandler, get_path_info
from django.core.management import call_command
from django.core.management.color import no_style
from django.core.management.sql import emit_post_migrate_signal
from django.core.servers.basehttp import WSGIRequestHandler, WSGIServer
from django.db import DEFAULT_DB_ALIAS, connection, connections, transaction
from django.forms.fields import CharField
from django.http import QueryDict
from django.http.request import split_domain_port, validate_host
from django.test.client import Client
from django.test.html import HTMLParseError, parse_html
from django.test.signals import setting_changed, template_rendered
from django.test.utils import (
CaptureQueriesContext, ContextList, compare_xml, modify_settings,
override_settings,
)
from django.utils import six
from django.utils.decorators import classproperty
from django.utils.deprecation import RemovedInDjango20Warning
from django.utils.encoding import force_text
from django.utils.six.moves.urllib.parse import (
unquote, urljoin, urlparse, urlsplit, urlunsplit,
)
from django.utils.six.moves.urllib.request import url2pathname
from django.views.static import serve
__all__ = ('TestCase', 'TransactionTestCase',
'SimpleTestCase', 'skipIfDBFeature', 'skipUnlessDBFeature')
def to_list(value):
"""
Puts value into a list if it's not already one.
Returns an empty list if value is None.
"""
if value is None:
value = []
elif not isinstance(value, list):
value = [value]
return value
def assert_and_parse_html(self, html, user_msg, msg):
try:
dom = parse_html(html)
except HTMLParseError as e:
standardMsg = '%s\n%s' % (msg, e)
self.fail(self._formatMessage(user_msg, standardMsg))
return dom
class _AssertNumQueriesContext(CaptureQueriesContext):
def __init__(self, test_case, num, connection):
self.test_case = test_case
self.num = num
super(_AssertNumQueriesContext, self).__init__(connection)
def __exit__(self, exc_type, exc_value, traceback):
super(_AssertNumQueriesContext, self).__exit__(exc_type, exc_value, traceback)
if exc_type is not None:
return
executed = len(self)
self.test_case.assertEqual(
executed, self.num,
"%d queries executed, %d expected\nCaptured queries were:\n%s" % (
executed, self.num,
'\n'.join(
query['sql'] for query in self.captured_queries
)
)
)
class _AssertTemplateUsedContext(object):
def __init__(self, test_case, template_name):
self.test_case = test_case
self.template_name = template_name
self.rendered_templates = []
self.rendered_template_names = []
self.context = ContextList()
def on_template_render(self, sender, signal, template, context, **kwargs):
self.rendered_templates.append(template)
self.rendered_template_names.append(template.name)
self.context.append(copy(context))
def test(self):
return self.template_name in self.rendered_template_names
def message(self):
return '%s was not rendered.' % self.template_name
def __enter__(self):
template_rendered.connect(self.on_template_render)
return self
def __exit__(self, exc_type, exc_value, traceback):
template_rendered.disconnect(self.on_template_render)
if exc_type is not None:
return
if not self.test():
message = self.message()
if len(self.rendered_templates) == 0:
message += ' No template was rendered.'
else:
message += ' Following templates were rendered: %s' % (
', '.join(self.rendered_template_names))
self.test_case.fail(message)
class _AssertTemplateNotUsedContext(_AssertTemplateUsedContext):
def test(self):
return self.template_name not in self.rendered_template_names
def message(self):
return '%s was rendered.' % self.template_name
class _CursorFailure(object):
def __init__(self, cls_name, wrapped):
self.cls_name = cls_name
self.wrapped = wrapped
def __call__(self):
raise AssertionError(
"Database queries aren't allowed in SimpleTestCase. "
"Either use TestCase or TransactionTestCase to ensure proper test isolation or "
"set %s.allow_database_queries to True to silence this failure." % self.cls_name
)
class SimpleTestCase(unittest.TestCase):
# The class we'll use for the test client self.client.
# Can be overridden in derived classes.
client_class = Client
_overridden_settings = None
_modified_settings = None
# Tests shouldn't be allowed to query the database since
# this base class doesn't enforce any isolation.
allow_database_queries = False
@classmethod
def setUpClass(cls):
super(SimpleTestCase, cls).setUpClass()
if cls._overridden_settings:
cls._cls_overridden_context = override_settings(**cls._overridden_settings)
cls._cls_overridden_context.enable()
if cls._modified_settings:
cls._cls_modified_context = modify_settings(cls._modified_settings)
cls._cls_modified_context.enable()
if not cls.allow_database_queries:
for alias in connections:
connection = connections[alias]
connection.cursor = _CursorFailure(cls.__name__, connection.cursor)
connection.chunked_cursor = _CursorFailure(cls.__name__, connection.chunked_cursor)
@classmethod
def tearDownClass(cls):
if not cls.allow_database_queries:
for alias in connections:
connection = connections[alias]
connection.cursor = connection.cursor.wrapped
connection.chunked_cursor = connection.chunked_cursor.wrapped
if hasattr(cls, '_cls_modified_context'):
cls._cls_modified_context.disable()
delattr(cls, '_cls_modified_context')
if hasattr(cls, '_cls_overridden_context'):
cls._cls_overridden_context.disable()
delattr(cls, '_cls_overridden_context')
super(SimpleTestCase, cls).tearDownClass()
def __call__(self, result=None):
"""
Wrapper around default __call__ method to perform common Django test
set up. This means that user-defined Test Cases aren't required to
include a call to super().setUp().
"""
testMethod = getattr(self, self._testMethodName)
skipped = (
getattr(self.__class__, "__unittest_skip__", False) or
getattr(testMethod, "__unittest_skip__", False)
)
if not skipped:
try:
self._pre_setup()
except Exception:
result.addError(self, sys.exc_info())
return
super(SimpleTestCase, self).__call__(result)
if not skipped:
try:
self._post_teardown()
except Exception:
result.addError(self, sys.exc_info())
return
def _pre_setup(self):
"""Performs any pre-test setup. This includes:
* Creating a test client.
* Clearing the mail test outbox.
"""
self.client = self.client_class()
mail.outbox = []
def _post_teardown(self):
"""Perform any post-test things."""
pass
def settings(self, **kwargs):
"""
A context manager that temporarily sets a setting and reverts to the original value when exiting the context.
"""
return override_settings(**kwargs)
def modify_settings(self, **kwargs):
"""
A context manager that temporarily applies changes a list setting and
reverts back to the original value when exiting the context.
"""
return modify_settings(**kwargs)
def assertRedirects(self, response, expected_url, status_code=302,
target_status_code=200, host=None, msg_prefix='',
fetch_redirect_response=True):
"""Asserts that a response redirected to a specific URL, and that the
redirect URL can be loaded.
Note that assertRedirects won't work for external links since it uses
TestClient to do a request (use fetch_redirect_response=False to check
such links without fetching them).
"""
if host is not None:
warnings.warn(
"The host argument is deprecated and no longer used by assertRedirects",
RemovedInDjango20Warning, stacklevel=2
)
if msg_prefix:
msg_prefix += ": "
if hasattr(response, 'redirect_chain'):
# The request was a followed redirect
self.assertTrue(
len(response.redirect_chain) > 0,
msg_prefix + "Response didn't redirect as expected: Response code was %d (expected %d)"
% (response.status_code, status_code)
)
self.assertEqual(
response.redirect_chain[0][1], status_code,
msg_prefix + "Initial response didn't redirect as expected: Response code was %d (expected %d)"
% (response.redirect_chain[0][1], status_code)
)
url, status_code = response.redirect_chain[-1]
scheme, netloc, path, query, fragment = urlsplit(url)
self.assertEqual(
response.status_code, target_status_code,
msg_prefix + "Response didn't redirect as expected: Final Response code was %d (expected %d)"
% (response.status_code, target_status_code)
)
else:
# Not a followed redirect
self.assertEqual(
response.status_code, status_code,
msg_prefix + "Response didn't redirect as expected: Response code was %d (expected %d)"
% (response.status_code, status_code)
)
url = response.url
scheme, netloc, path, query, fragment = urlsplit(url)
# Prepend the request path to handle relative path redirects.
if not path.startswith('/'):
url = urljoin(response.request['PATH_INFO'], url)
path = urljoin(response.request['PATH_INFO'], path)
if fetch_redirect_response:
# netloc might be empty, or in cases where Django tests the
# HTTP scheme, the convention is for netloc to be 'testserver'.
# Trust both as "internal" URLs here.
domain, port = split_domain_port(netloc)
if domain and not validate_host(domain, settings.ALLOWED_HOSTS):
raise ValueError(
"The test client is unable to fetch remote URLs (got %s). "
"If the host is served by Django, add '%s' to ALLOWED_HOSTS. "
"Otherwise, use assertRedirects(..., fetch_redirect_response=False)."
% (url, domain)
)
redirect_response = response.client.get(path, QueryDict(query), secure=(scheme == 'https'))
# Get the redirection page, using the same client that was used
# to obtain the original response.
self.assertEqual(
redirect_response.status_code, target_status_code,
msg_prefix + "Couldn't retrieve redirection page '%s': response code was %d (expected %d)"
% (path, redirect_response.status_code, target_status_code)
)
if url != expected_url:
# For temporary backwards compatibility, try to compare with a relative url
e_scheme, e_netloc, e_path, e_query, e_fragment = urlsplit(expected_url)
relative_url = urlunsplit(('', '', e_path, e_query, e_fragment))
if url == relative_url:
warnings.warn(
"assertRedirects had to strip the scheme and domain from the "
"expected URL, as it was always added automatically to URLs "
"before Django 1.9. Please update your expected URLs by "
"removing the scheme and domain.",
RemovedInDjango20Warning, stacklevel=2)
expected_url = relative_url
self.assertEqual(
url, expected_url,
msg_prefix + "Response redirected to '%s', expected '%s'" % (url, expected_url)
)
def _assert_contains(self, response, text, status_code, msg_prefix, html):
# If the response supports deferred rendering and hasn't been rendered
# yet, then ensure that it does get rendered before proceeding further.
if hasattr(response, 'render') and callable(response.render) and not response.is_rendered:
response.render()
if msg_prefix:
msg_prefix += ": "
self.assertEqual(
response.status_code, status_code,
msg_prefix + "Couldn't retrieve content: Response code was %d"
" (expected %d)" % (response.status_code, status_code)
)
if response.streaming:
content = b''.join(response.streaming_content)
else:
content = response.content
if not isinstance(text, bytes) or html:
text = force_text(text, encoding=response.charset)
content = content.decode(response.charset)
text_repr = "'%s'" % text
else:
text_repr = repr(text)
if html:
content = assert_and_parse_html(self, content, None, "Response's content is not valid HTML:")
text = assert_and_parse_html(self, text, None, "Second argument is not valid HTML:")
real_count = content.count(text)
return (text_repr, real_count, msg_prefix)
def assertContains(self, response, text, count=None, status_code=200, msg_prefix='', html=False):
"""
Asserts that a response indicates that some content was retrieved
successfully, (i.e., the HTTP status code was as expected), and that
``text`` occurs ``count`` times in the content of the response.
If ``count`` is None, the count doesn't matter - the assertion is true
if the text occurs at least once in the response.
"""
text_repr, real_count, msg_prefix = self._assert_contains(
response, text, status_code, msg_prefix, html)
if count is not None:
self.assertEqual(
real_count, count,
msg_prefix + "Found %d instances of %s in response (expected %d)" % (real_count, text_repr, count)
)
else:
self.assertTrue(real_count != 0, msg_prefix + "Couldn't find %s in response" % text_repr)
def assertNotContains(self, response, text, status_code=200, msg_prefix='', html=False):
"""
Asserts that a response indicates that some content was retrieved
successfully, (i.e., the HTTP status code was as expected), and that
``text`` doesn't occurs in the content of the response.
"""
text_repr, real_count, msg_prefix = self._assert_contains(
response, text, status_code, msg_prefix, html)
self.assertEqual(real_count, 0, msg_prefix + "Response should not contain %s" % text_repr)
def assertFormError(self, response, form, field, errors, msg_prefix=''):
"""
Asserts that a form used to render the response has a specific field
error.
"""
if msg_prefix:
msg_prefix += ": "
# Put context(s) into a list to simplify processing.
contexts = to_list(response.context)
if not contexts:
self.fail(msg_prefix + "Response did not use any contexts to render the response")
# Put error(s) into a list to simplify processing.
errors = to_list(errors)
# Search all contexts for the error.
found_form = False
for i, context in enumerate(contexts):
if form not in context:
continue
found_form = True
for err in errors:
if field:
if field in context[form].errors:
field_errors = context[form].errors[field]
self.assertTrue(
err in field_errors,
msg_prefix + "The field '%s' on form '%s' in"
" context %d does not contain the error '%s'"
" (actual errors: %s)" %
(field, form, i, err, repr(field_errors))
)
elif field in context[form].fields:
self.fail(
msg_prefix + "The field '%s' on form '%s' in context %d contains no errors" %
(field, form, i)
)
else:
self.fail(
msg_prefix + "The form '%s' in context %d does not contain the field '%s'" %
(form, i, field)
)
else:
non_field_errors = context[form].non_field_errors()
self.assertTrue(
err in non_field_errors,
msg_prefix + "The form '%s' in context %d does not"
" contain the non-field error '%s'"
" (actual errors: %s)" %
(form, i, err, non_field_errors)
)
if not found_form:
self.fail(msg_prefix + "The form '%s' was not used to render the response" % form)
def assertFormsetError(self, response, formset, form_index, field, errors,
msg_prefix=''):
"""
Asserts that a formset used to render the response has a specific error.
For field errors, specify the ``form_index`` and the ``field``.
For non-field errors, specify the ``form_index`` and the ``field`` as
None.
For non-form errors, specify ``form_index`` as None and the ``field``
as None.
"""
# Add punctuation to msg_prefix
if msg_prefix:
msg_prefix += ": "
# Put context(s) into a list to simplify processing.
contexts = to_list(response.context)
if not contexts:
self.fail(msg_prefix + 'Response did not use any contexts to '
'render the response')
# Put error(s) into a list to simplify processing.
errors = to_list(errors)
# Search all contexts for the error.
found_formset = False
for i, context in enumerate(contexts):
if formset not in context:
continue
found_formset = True
for err in errors:
if field is not None:
if field in context[formset].forms[form_index].errors:
field_errors = context[formset].forms[form_index].errors[field]
self.assertTrue(
err in field_errors,
msg_prefix + "The field '%s' on formset '%s', "
"form %d in context %d does not contain the "
"error '%s' (actual errors: %s)" %
(field, formset, form_index, i, err, repr(field_errors))
)
elif field in context[formset].forms[form_index].fields:
self.fail(
msg_prefix + "The field '%s' on formset '%s', form %d in context %d contains no errors"
% (field, formset, form_index, i)
)
else:
self.fail(
msg_prefix + "The formset '%s', form %d in context %d does not contain the field '%s'"
% (formset, form_index, i, field)
)
elif form_index is not None:
non_field_errors = context[formset].forms[form_index].non_field_errors()
self.assertFalse(
len(non_field_errors) == 0,
msg_prefix + "The formset '%s', form %d in context %d "
"does not contain any non-field errors." % (formset, form_index, i)
)
self.assertTrue(
err in non_field_errors,
msg_prefix + "The formset '%s', form %d in context %d "
"does not contain the non-field error '%s' (actual errors: %s)"
% (formset, form_index, i, err, repr(non_field_errors))
)
else:
non_form_errors = context[formset].non_form_errors()
self.assertFalse(
len(non_form_errors) == 0,
msg_prefix + "The formset '%s' in context %d does not "
"contain any non-form errors." % (formset, i)
)
self.assertTrue(
err in non_form_errors,
msg_prefix + "The formset '%s' in context %d does not "
"contain the non-form error '%s' (actual errors: %s)"
% (formset, i, err, repr(non_form_errors))
)
if not found_formset:
self.fail(msg_prefix + "The formset '%s' was not used to render the response" % formset)
def _assert_template_used(self, response, template_name, msg_prefix):
if response is None and template_name is None:
raise TypeError('response and/or template_name argument must be provided')
if msg_prefix:
msg_prefix += ": "
if template_name is not None and response is not None and not hasattr(response, 'templates'):
raise ValueError(
"assertTemplateUsed() and assertTemplateNotUsed() are only "
"usable on responses fetched using the Django test Client."
)
if not hasattr(response, 'templates') or (response is None and template_name):
if response:
template_name = response
response = None
# use this template with context manager
return template_name, None, msg_prefix
template_names = [t.name for t in response.templates if t.name is not None]
return None, template_names, msg_prefix
def assertTemplateUsed(self, response=None, template_name=None, msg_prefix='', count=None):
"""
Asserts that the template with the provided name was used in rendering
the response. Also usable as context manager.
"""
context_mgr_template, template_names, msg_prefix = self._assert_template_used(
response, template_name, msg_prefix)
if context_mgr_template:
# Use assertTemplateUsed as context manager.
return _AssertTemplateUsedContext(self, context_mgr_template)
if not template_names:
self.fail(msg_prefix + "No templates used to render the response")
self.assertTrue(
template_name in template_names,
msg_prefix + "Template '%s' was not a template used to render"
" the response. Actual template(s) used: %s"
% (template_name, ', '.join(template_names))
)
if count is not None:
self.assertEqual(
template_names.count(template_name), count,
msg_prefix + "Template '%s' was expected to be rendered %d "
"time(s) but was actually rendered %d time(s)."
% (template_name, count, template_names.count(template_name))
)
def assertTemplateNotUsed(self, response=None, template_name=None, msg_prefix=''):
"""
Asserts that the template with the provided name was NOT used in
rendering the response. Also usable as context manager.
"""
context_mgr_template, template_names, msg_prefix = self._assert_template_used(
response, template_name, msg_prefix
)
if context_mgr_template:
# Use assertTemplateNotUsed as context manager.
return _AssertTemplateNotUsedContext(self, context_mgr_template)
self.assertFalse(
template_name in template_names,
msg_prefix + "Template '%s' was used unexpectedly in rendering the response" % template_name
)
@contextmanager
def _assert_raises_message_cm(self, expected_exception, expected_message):
with self.assertRaises(expected_exception) as cm:
yield cm
self.assertIn(expected_message, str(cm.exception))
def assertRaisesMessage(self, expected_exception, expected_message, *args, **kwargs):
"""
Asserts that expected_message is found in the the message of a raised
exception.
Args:
expected_exception: Exception class expected to be raised.
expected_message: expected error message string value.
args: Function to be called and extra positional args.
kwargs: Extra kwargs.
"""
# callable_obj was a documented kwarg in Django 1.8 and older.
callable_obj = kwargs.pop('callable_obj', None)
if callable_obj:
warnings.warn(
'The callable_obj kwarg is deprecated. Pass the callable '
'as a positional argument instead.', RemovedInDjango20Warning
)
elif len(args):
callable_obj = args[0]
args = args[1:]
cm = self._assert_raises_message_cm(expected_exception, expected_message)
# Assertion used in context manager fashion.
if callable_obj is None:
return cm
# Assertion was passed a callable.
with cm:
callable_obj(*args, **kwargs)
def assertFieldOutput(self, fieldclass, valid, invalid, field_args=None,
field_kwargs=None, empty_value=''):
"""
Asserts that a form field behaves correctly with various inputs.
Args:
fieldclass: the class of the field to be tested.
valid: a dictionary mapping valid inputs to their expected
cleaned values.
invalid: a dictionary mapping invalid inputs to one or more
raised error messages.
field_args: the args passed to instantiate the field
field_kwargs: the kwargs passed to instantiate the field
empty_value: the expected clean output for inputs in empty_values
"""
if field_args is None:
field_args = []
if field_kwargs is None:
field_kwargs = {}
required = fieldclass(*field_args, **field_kwargs)
optional = fieldclass(*field_args, **dict(field_kwargs, required=False))
# test valid inputs
for input, output in valid.items():
self.assertEqual(required.clean(input), output)
self.assertEqual(optional.clean(input), output)
# test invalid inputs
for input, errors in invalid.items():
with self.assertRaises(ValidationError) as context_manager:
required.clean(input)
self.assertEqual(context_manager.exception.messages, errors)
with self.assertRaises(ValidationError) as context_manager:
optional.clean(input)
self.assertEqual(context_manager.exception.messages, errors)
# test required inputs
error_required = [force_text(required.error_messages['required'])]
for e in required.empty_values:
with self.assertRaises(ValidationError) as context_manager:
required.clean(e)
self.assertEqual(context_manager.exception.messages, error_required)
self.assertEqual(optional.clean(e), empty_value)
# test that max_length and min_length are always accepted
if issubclass(fieldclass, CharField):
field_kwargs.update({'min_length': 2, 'max_length': 20})
self.assertIsInstance(fieldclass(*field_args, **field_kwargs), fieldclass)
def assertHTMLEqual(self, html1, html2, msg=None):
"""
Asserts that two HTML snippets are semantically the same.
Whitespace in most cases is ignored, and attribute ordering is not
significant. The passed-in arguments must be valid HTML.
"""
dom1 = assert_and_parse_html(self, html1, msg, 'First argument is not valid HTML:')
dom2 = assert_and_parse_html(self, html2, msg, 'Second argument is not valid HTML:')
if dom1 != dom2:
standardMsg = '%s != %s' % (
safe_repr(dom1, True), safe_repr(dom2, True))
diff = ('\n' + '\n'.join(difflib.ndiff(
six.text_type(dom1).splitlines(),
six.text_type(dom2).splitlines(),
)))
standardMsg = self._truncateMessage(standardMsg, diff)
self.fail(self._formatMessage(msg, standardMsg))
def assertHTMLNotEqual(self, html1, html2, msg=None):
"""Asserts that two HTML snippets are not semantically equivalent."""
dom1 = assert_and_parse_html(self, html1, msg, 'First argument is not valid HTML:')
dom2 = assert_and_parse_html(self, html2, msg, 'Second argument is not valid HTML:')
if dom1 == dom2:
standardMsg = '%s == %s' % (
safe_repr(dom1, True), safe_repr(dom2, True))
self.fail(self._formatMessage(msg, standardMsg))
def assertInHTML(self, needle, haystack, count=None, msg_prefix=''):
needle = assert_and_parse_html(self, needle, None, 'First argument is not valid HTML:')
haystack = assert_and_parse_html(self, haystack, None, 'Second argument is not valid HTML:')
real_count = haystack.count(needle)
if count is not None:
self.assertEqual(
real_count, count,
msg_prefix + "Found %d instances of '%s' in response (expected %d)" % (real_count, needle, count)
)
else:
self.assertTrue(real_count != 0, msg_prefix + "Couldn't find '%s' in response" % needle)
def assertJSONEqual(self, raw, expected_data, msg=None):
"""
Asserts that the JSON fragments raw and expected_data are equal.
Usual JSON non-significant whitespace rules apply as the heavyweight
is delegated to the json library.
"""
try:
data = json.loads(raw)
except ValueError:
self.fail("First argument is not valid JSON: %r" % raw)
if isinstance(expected_data, six.string_types):
try:
expected_data = json.loads(expected_data)
except ValueError:
self.fail("Second argument is not valid JSON: %r" % expected_data)
self.assertEqual(data, expected_data, msg=msg)
def assertJSONNotEqual(self, raw, expected_data, msg=None):
"""
Asserts that the JSON fragments raw and expected_data are not equal.
Usual JSON non-significant whitespace rules apply as the heavyweight
is delegated to the json library.
"""
try:
data = json.loads(raw)
except ValueError:
self.fail("First argument is not valid JSON: %r" % raw)
if isinstance(expected_data, six.string_types):
try:
expected_data = json.loads(expected_data)
except ValueError:
self.fail("Second argument is not valid JSON: %r" % expected_data)
self.assertNotEqual(data, expected_data, msg=msg)
def assertXMLEqual(self, xml1, xml2, msg=None):
"""
Asserts that two XML snippets are semantically the same.
Whitespace in most cases is ignored, and attribute ordering is not
significant. The passed-in arguments must be valid XML.
"""
try:
result = compare_xml(xml1, xml2)
except Exception as e:
standardMsg = 'First or second argument is not valid XML\n%s' % e
self.fail(self._formatMessage(msg, standardMsg))
else:
if not result:
standardMsg = '%s != %s' % (safe_repr(xml1, True), safe_repr(xml2, True))
diff = ('\n' + '\n'.join(
difflib.ndiff(
six.text_type(xml1).splitlines(),
six.text_type(xml2).splitlines(),
)
))
standardMsg = self._truncateMessage(standardMsg, diff)
self.fail(self._formatMessage(msg, standardMsg))
def assertXMLNotEqual(self, xml1, xml2, msg=None):
"""
Asserts that two XML snippets are not semantically equivalent.
Whitespace in most cases is ignored, and attribute ordering is not
significant. The passed-in arguments must be valid XML.
"""
try:
result = compare_xml(xml1, xml2)
except Exception as e:
standardMsg = 'First or second argument is not valid XML\n%s' % e
self.fail(self._formatMessage(msg, standardMsg))
else:
if result:
standardMsg = '%s == %s' % (safe_repr(xml1, True), safe_repr(xml2, True))
self.fail(self._formatMessage(msg, standardMsg))
if six.PY2:
assertCountEqual = unittest.TestCase.assertItemsEqual
assertNotRegex = unittest.TestCase.assertNotRegexpMatches
assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
assertRegex = unittest.TestCase.assertRegexpMatches
class TransactionTestCase(SimpleTestCase):
# Subclasses can ask for resetting of auto increment sequence before each
# test case
reset_sequences = False
# Subclasses can enable only a subset of apps for faster tests
available_apps = None
# Subclasses can define fixtures which will be automatically installed.
fixtures = None
# If transactions aren't available, Django will serialize the database
# contents into a fixture during setup and flush and reload them
# during teardown (as flush does not restore data from migrations).
# This can be slow; this flag allows enabling on a per-case basis.
serialized_rollback = False
# Since tests will be wrapped in a transaction, or serialized if they
# are not available, we allow queries to be run.
allow_database_queries = True
def _pre_setup(self):
"""Performs any pre-test setup. This includes:
* If the class has an 'available_apps' attribute, restricting the app
registry to these applications, then firing post_migrate -- it must
run with the correct set of applications for the test case.
* If the class has a 'fixtures' attribute, installing these fixtures.
"""
super(TransactionTestCase, self)._pre_setup()
if self.available_apps is not None:
apps.set_available_apps(self.available_apps)
setting_changed.send(
sender=settings._wrapped.__class__,
setting='INSTALLED_APPS',
value=self.available_apps,
enter=True,
)
for db_name in self._databases_names(include_mirrors=False):
emit_post_migrate_signal(verbosity=0, interactive=False, db=db_name)
try:
self._fixture_setup()
except Exception:
if self.available_apps is not None:
apps.unset_available_apps()
setting_changed.send(
sender=settings._wrapped.__class__,
setting='INSTALLED_APPS',
value=settings.INSTALLED_APPS,
enter=False,
)
raise
@classmethod
def _databases_names(cls, include_mirrors=True):
# If the test case has a multi_db=True flag, act on all databases,
# including mirrors or not. Otherwise, just on the default DB.
if getattr(cls, 'multi_db', False):
return [
alias for alias in connections
if include_mirrors or not connections[alias].settings_dict['TEST']['MIRROR']
]
else:
return [DEFAULT_DB_ALIAS]
def _reset_sequences(self, db_name):
conn = connections[db_name]
if conn.features.supports_sequence_reset:
sql_list = conn.ops.sequence_reset_by_name_sql(
no_style(), conn.introspection.sequence_list())
if sql_list:
with transaction.atomic(using=db_name):
cursor = conn.cursor()
for sql in sql_list:
cursor.execute(sql)
def _fixture_setup(self):
for db_name in self._databases_names(include_mirrors=False):
# Reset sequences
if self.reset_sequences:
self._reset_sequences(db_name)
# If we need to provide replica initial data from migrated apps,
# then do so.
if self.serialized_rollback and hasattr(connections[db_name], "_test_serialized_contents"):
if self.available_apps is not None:
apps.unset_available_apps()
connections[db_name].creation.deserialize_db_from_string(
connections[db_name]._test_serialized_contents
)
if self.available_apps is not None:
apps.set_available_apps(self.available_apps)
if self.fixtures:
# We have to use this slightly awkward syntax due to the fact
# that we're using *args and **kwargs together.
call_command('loaddata', *self.fixtures,
**{'verbosity': 0, 'database': db_name})
def _should_reload_connections(self):
return True
def _post_teardown(self):
"""Performs any post-test things. This includes:
* Flushing the contents of the database, to leave a clean slate. If
the class has an 'available_apps' attribute, post_migrate isn't fired.
* Force-closing the connection, so the next test gets a clean cursor.
"""
try:
self._fixture_teardown()
super(TransactionTestCase, self)._post_teardown()
if self._should_reload_connections():
# Some DB cursors include SQL statements as part of cursor
# creation. If you have a test that does a rollback, the effect
# of these statements is lost, which can affect the operation of
# tests (e.g., losing a timezone setting causing objects to be
# created with the wrong time). To make sure this doesn't
# happen, get a clean connection at the start of every test.
for conn in connections.all():
conn.close()
finally:
if self.available_apps is not None:
apps.unset_available_apps()
setting_changed.send(sender=settings._wrapped.__class__,
setting='INSTALLED_APPS',
value=settings.INSTALLED_APPS,
enter=False)
def _fixture_teardown(self):
# Allow TRUNCATE ... CASCADE and don't emit the post_migrate signal
# when flushing only a subset of the apps
for db_name in self._databases_names(include_mirrors=False):
# Flush the database
inhibit_post_migrate = (
self.available_apps is not None or
( # Inhibit the post_migrate signal when using serialized
# rollback to avoid trying to recreate the serialized data.
self.serialized_rollback and
hasattr(connections[db_name], '_test_serialized_contents')
)
)
call_command('flush', verbosity=0, interactive=False,
database=db_name, reset_sequences=False,
allow_cascade=self.available_apps is not None,
inhibit_post_migrate=inhibit_post_migrate)
def assertQuerysetEqual(self, qs, values, transform=repr, ordered=True, msg=None):
items = six.moves.map(transform, qs)
if not ordered:
return self.assertEqual(Counter(items), Counter(values), msg=msg)
values = list(values)
# For example qs.iterator() could be passed as qs, but it does not
# have 'ordered' attribute.
if len(values) > 1 and hasattr(qs, 'ordered') and not qs.ordered:
raise ValueError("Trying to compare non-ordered queryset "
"against more than one ordered values")
return self.assertEqual(list(items), values, msg=msg)
def assertNumQueries(self, num, func=None, *args, **kwargs):
using = kwargs.pop("using", DEFAULT_DB_ALIAS)
conn = connections[using]
context = _AssertNumQueriesContext(self, num, conn)
if func is None:
return context
with context:
func(*args, **kwargs)
def connections_support_transactions():
"""
Returns True if all connections support transactions.
"""
return all(conn.features.supports_transactions
for conn in connections.all())
class TestCase(TransactionTestCase):
"""
Similar to TransactionTestCase, but uses `transaction.atomic()` to achieve
test isolation.
In most situations, TestCase should be preferred to TransactionTestCase as
it allows faster execution. However, there are some situations where using
TransactionTestCase might be necessary (e.g. testing some transactional
behavior).
On database backends with no transaction support, TestCase behaves as
TransactionTestCase.
"""
@classmethod
def _enter_atomics(cls):
"""Helper method to open atomic blocks for multiple databases"""
atomics = {}
for db_name in cls._databases_names():
atomics[db_name] = transaction.atomic(using=db_name)
atomics[db_name].__enter__()
return atomics
@classmethod
def _rollback_atomics(cls, atomics):
"""Rollback atomic blocks opened through the previous method"""
for db_name in reversed(cls._databases_names()):
transaction.set_rollback(True, using=db_name)
atomics[db_name].__exit__(None, None, None)
@classmethod
def setUpClass(cls):
super(TestCase, cls).setUpClass()
if not connections_support_transactions():
return
cls.cls_atomics = cls._enter_atomics()
if cls.fixtures:
for db_name in cls._databases_names(include_mirrors=False):
try:
call_command('loaddata', *cls.fixtures, **{
'verbosity': 0,
'commit': False,
'database': db_name,
})
except Exception:
cls._rollback_atomics(cls.cls_atomics)
raise
try:
cls.setUpTestData()
except Exception:
cls._rollback_atomics(cls.cls_atomics)
raise
@classmethod
def tearDownClass(cls):
if connections_support_transactions():
cls._rollback_atomics(cls.cls_atomics)
for conn in connections.all():
conn.close()
super(TestCase, cls).tearDownClass()
@classmethod
def setUpTestData(cls):
"""Load initial data for the TestCase"""
pass
def _should_reload_connections(self):
if connections_support_transactions():
return False
return super(TestCase, self)._should_reload_connections()
def _fixture_setup(self):
if not connections_support_transactions():
# If the backend does not support transactions, we should reload
# class data before each test
self.setUpTestData()
return super(TestCase, self)._fixture_setup()
assert not self.reset_sequences, 'reset_sequences cannot be used on TestCase instances'
self.atomics = self._enter_atomics()
def _fixture_teardown(self):
if not connections_support_transactions():
return super(TestCase, self)._fixture_teardown()
try:
for db_name in reversed(self._databases_names()):
if self._should_check_constraints(connections[db_name]):
connections[db_name].check_constraints()
finally:
self._rollback_atomics(self.atomics)
def _should_check_constraints(self, connection):
return (
connection.features.can_defer_constraint_checks and
not connection.needs_rollback and connection.is_usable()
)
class CheckCondition(object):
"""Descriptor class for deferred condition checking"""
def __init__(self, *conditions):
self.conditions = conditions
def add_condition(self, condition, reason):
return self.__class__(*self.conditions + ((condition, reason),))
def __get__(self, instance, cls=None):
# Trigger access for all bases.
if any(getattr(base, '__unittest_skip__', False) for base in cls.__bases__):
return True
for condition, reason in self.conditions:
if condition():
# Override this descriptor's value and set the skip reason.
cls.__unittest_skip__ = True
cls.__unittest_skip_why__ = reason
return True
return False
def _deferredSkip(condition, reason):
def decorator(test_func):
if not (isinstance(test_func, type) and
issubclass(test_func, unittest.TestCase)):
@wraps(test_func)
def skip_wrapper(*args, **kwargs):
if condition():
raise unittest.SkipTest(reason)
return test_func(*args, **kwargs)
test_item = skip_wrapper
else:
# Assume a class is decorated
test_item = test_func
# Retrieve the possibly existing value from the class's dict to
# avoid triggering the descriptor.
skip = test_func.__dict__.get('__unittest_skip__')
if isinstance(skip, CheckCondition):
test_item.__unittest_skip__ = skip.add_condition(condition, reason)
elif skip is not True:
test_item.__unittest_skip__ = CheckCondition((condition, reason))
return test_item
return decorator
def skipIfDBFeature(*features):
"""
Skip a test if a database has at least one of the named features.
"""
return _deferredSkip(
lambda: any(getattr(connection.features, feature, False) for feature in features),
"Database has feature(s) %s" % ", ".join(features)
)
def skipUnlessDBFeature(*features):
"""
Skip a test unless a database has all the named features.
"""
return _deferredSkip(
lambda: not all(getattr(connection.features, feature, False) for feature in features),
"Database doesn't support feature(s): %s" % ", ".join(features)
)
def skipUnlessAnyDBFeature(*features):
"""
Skip a test unless a database has any of the named features.
"""
return _deferredSkip(
lambda: not any(getattr(connection.features, feature, False) for feature in features),
"Database doesn't support any of the feature(s): %s" % ", ".join(features)
)
class QuietWSGIRequestHandler(WSGIRequestHandler):
"""
Just a regular WSGIRequestHandler except it doesn't log to the standard
output any of the requests received, so as to not clutter the output for
the tests' results.
"""
def log_message(*args):
pass
class FSFilesHandler(WSGIHandler):
"""
WSGI middleware that intercepts calls to a directory, as defined by one of
the *_ROOT settings, and serves those files, publishing them under *_URL.
"""
def __init__(self, application):
self.application = application
self.base_url = urlparse(self.get_base_url())
super(FSFilesHandler, self).__init__()
def _should_handle(self, path):
"""
Checks if the path should be handled. Ignores the path if:
* the host is provided as part of the base_url
* the request's path isn't under the media path (or equal)
"""
return path.startswith(self.base_url[2]) and not self.base_url[1]
def file_path(self, url):
"""
Returns the relative path to the file on disk for the given URL.
"""
relative_url = url[len(self.base_url[2]):]
return url2pathname(relative_url)
def get_response(self, request):
from django.http import Http404
if self._should_handle(request.path):
try:
return self.serve(request)
except Http404:
pass
return super(FSFilesHandler, self).get_response(request)
def serve(self, request):
os_rel_path = self.file_path(request.path)
os_rel_path = posixpath.normpath(unquote(os_rel_path))
# Emulate behavior of django.contrib.staticfiles.views.serve() when it
# invokes staticfiles' finders functionality.
# TODO: Modify if/when that internal API is refactored
final_rel_path = os_rel_path.replace('\\', '/').lstrip('/')
return serve(request, final_rel_path, document_root=self.get_base_dir())
def __call__(self, environ, start_response):
if not self._should_handle(get_path_info(environ)):
return self.application(environ, start_response)
return super(FSFilesHandler, self).__call__(environ, start_response)
class _StaticFilesHandler(FSFilesHandler):
"""
Handler for serving static files. A private class that is meant to be used
solely as a convenience by LiveServerThread.
"""
def get_base_dir(self):
return settings.STATIC_ROOT
def get_base_url(self):
return settings.STATIC_URL
class _MediaFilesHandler(FSFilesHandler):
"""
Handler for serving the media files. A private class that is meant to be
used solely as a convenience by LiveServerThread.
"""
def get_base_dir(self):
return settings.MEDIA_ROOT
def get_base_url(self):
return settings.MEDIA_URL
class LiveServerThread(threading.Thread):
"""
Thread for running a live http server while the tests are running.
"""
def __init__(self, host, static_handler, connections_override=None, port=0):
self.host = host
self.port = port
self.is_ready = threading.Event()
self.error = None
self.static_handler = static_handler
self.connections_override = connections_override
super(LiveServerThread, self).__init__()
def run(self):
"""
Sets up the live server and databases, and then loops over handling
http requests.
"""
if self.connections_override:
# Override this thread's database connections with the ones
# provided by the main thread.
for alias, conn in self.connections_override.items():
connections[alias] = conn
try:
# Create the handler for serving static and media files
handler = self.static_handler(_MediaFilesHandler(WSGIHandler()))
self.httpd = self._create_server()
# If binding to port zero, assign the port allocated by the OS.
if self.port == 0:
self.port = self.httpd.server_address[1]
self.httpd.set_app(handler)
self.is_ready.set()
self.httpd.serve_forever()
except Exception as e:
self.error = e
self.is_ready.set()
finally:
connections.close_all()
def _create_server(self):
return WSGIServer((self.host, self.port), QuietWSGIRequestHandler, allow_reuse_address=False)
def terminate(self):
if hasattr(self, 'httpd'):
# Stop the WSGI server
self.httpd.shutdown()
self.httpd.server_close()
self.join()
class LiveServerTestCase(TransactionTestCase):
"""
Does basically the same as TransactionTestCase but also launches a live
http server in a separate thread so that the tests may use another testing
framework, such as Selenium for example, instead of the built-in dummy
client.
Note that it inherits from TransactionTestCase instead of TestCase because
the threads do not share the same transactions (unless if using in-memory
sqlite) and each thread needs to commit all their transactions so that the
other thread can see the changes.
"""
host = 'localhost'
port = 0
server_thread_class = LiveServerThread
static_handler = _StaticFilesHandler
@classproperty
def live_server_url(cls):
return 'http://%s:%s' % (cls.host, cls.server_thread.port)
@classmethod
def setUpClass(cls):
super(LiveServerTestCase, cls).setUpClass()
connections_override = {}
for conn in connections.all():
# If using in-memory sqlite databases, pass the connections to
# the server thread.
if conn.vendor == 'sqlite' and conn.is_in_memory_db():
# Explicitly enable thread-shareability for this connection
conn.allow_thread_sharing = True
connections_override[conn.alias] = conn
cls._live_server_modified_settings = modify_settings(
ALLOWED_HOSTS={'append': cls.host},
)
cls._live_server_modified_settings.enable()
cls.server_thread = cls._create_server_thread(connections_override)
cls.server_thread.daemon = True
cls.server_thread.start()
# Wait for the live server to be ready
cls.server_thread.is_ready.wait()
if cls.server_thread.error:
# Clean up behind ourselves, since tearDownClass won't get called in
# case of errors.
cls._tearDownClassInternal()
raise cls.server_thread.error
@classmethod
def _create_server_thread(cls, connections_override):
return cls.server_thread_class(
cls.host,
cls.static_handler,
connections_override=connections_override,
port=cls.port,
)
@classmethod
def _tearDownClassInternal(cls):
# There may not be a 'server_thread' attribute if setUpClass() for some
# reasons has raised an exception.
if hasattr(cls, 'server_thread'):
# Terminate the live server's thread
cls.server_thread.terminate()
# Restore sqlite in-memory database connections' non-shareability
for conn in connections.all():
if conn.vendor == 'sqlite' and conn.is_in_memory_db():
conn.allow_thread_sharing = False
@classmethod
def tearDownClass(cls):
cls._tearDownClassInternal()
cls._live_server_modified_settings.disable()
super(LiveServerTestCase, cls).tearDownClass()
class SerializeMixin(object):
"""
Mixin to enforce serialization of TestCases that share a common resource.
Define a common 'lockfile' for each set of TestCases to serialize. This
file must exist on the filesystem.
Place it early in the MRO in order to isolate setUpClass / tearDownClass.
"""
lockfile = None
@classmethod
def setUpClass(cls):
if cls.lockfile is None:
raise ValueError(
"{}.lockfile isn't set. Set it to a unique value "
"in the base class.".format(cls.__name__))
cls._lockfile = open(cls.lockfile)
locks.lock(cls._lockfile, locks.LOCK_EX)
super(SerializeMixin, cls).setUpClass()
@classmethod
def tearDownClass(cls):
super(SerializeMixin, cls).tearDownClass()
cls._lockfile.close()
Django-1.11.11/django/dispatch/ 0000775 0001750 0001750 00000000000 13247520353 015531 5 ustar tim tim 0000000 0000000 Django-1.11.11/django/dispatch/weakref_backports.py 0000664 0001750 0001750 00000004143 13247520250 021575 0 ustar tim tim 0000000 0000000 """
weakref_backports is a partial backport of the weakref module for python
versions below 3.4.
Copyright (C) 2013 Python Software Foundation, see LICENSE.python for details.
The following changes were made to the original sources during backporting:
* Added `self` to `super` calls.
* Removed `from None` when raising exceptions.
"""
from weakref import ref
class WeakMethod(ref):
"""
A custom `weakref.ref` subclass which simulates a weak reference to
a bound method, working around the lifetime problem of bound methods.
"""
__slots__ = "_func_ref", "_meth_type", "_alive", "__weakref__"
def __new__(cls, meth, callback=None):
try:
obj = meth.__self__
func = meth.__func__
except AttributeError:
raise TypeError("argument should be a bound method, not {}"
.format(type(meth)))
def _cb(arg):
# The self-weakref trick is needed to avoid creating a reference
# cycle.
self = self_wr()
if self._alive:
self._alive = False
if callback is not None:
callback(self)
self = ref.__new__(cls, obj, _cb)
self._func_ref = ref(func, _cb)
self._meth_type = type(meth)
self._alive = True
self_wr = ref(self)
return self
def __call__(self):
obj = super(WeakMethod, self).__call__()
func = self._func_ref()
if obj is None or func is None:
return None
return self._meth_type(func, obj)
def __eq__(self, other):
if isinstance(other, WeakMethod):
if not self._alive or not other._alive:
return self is other
return ref.__eq__(self, other) and self._func_ref == other._func_ref
return False
def __ne__(self, other):
if isinstance(other, WeakMethod):
if not self._alive or not other._alive:
return self is not other
return ref.__ne__(self, other) or self._func_ref != other._func_ref
return True
__hash__ = ref.__hash__
Django-1.11.11/django/dispatch/dispatcher.py 0000664 0001750 0001750 00000026535 13247520250 020240 0 ustar tim tim 0000000 0000000 import sys
import threading
import warnings
import weakref
from django.utils import six
from django.utils.deprecation import RemovedInDjango20Warning
from django.utils.inspect import func_accepts_kwargs
from django.utils.six.moves import range
if six.PY2:
from .weakref_backports import WeakMethod
else:
from weakref import WeakMethod
def _make_id(target):
if hasattr(target, '__func__'):
return (id(target.__self__), id(target.__func__))
return id(target)
NONE_ID = _make_id(None)
# A marker for caching
NO_RECEIVERS = object()
class Signal(object):
"""
Base class for all signals
Internal attributes:
receivers
{ receiverkey (id) : weakref(receiver) }
"""
def __init__(self, providing_args=None, use_caching=False):
"""
Create a new signal.
providing_args
A list of the arguments this signal can pass along in a send() call.
"""
self.receivers = []
if providing_args is None:
providing_args = []
self.providing_args = set(providing_args)
self.lock = threading.Lock()
self.use_caching = use_caching
# For convenience we create empty caches even if they are not used.
# A note about caching: if use_caching is defined, then for each
# distinct sender we cache the receivers that sender has in
# 'sender_receivers_cache'. The cache is cleaned when .connect() or
# .disconnect() is called and populated on send().
self.sender_receivers_cache = weakref.WeakKeyDictionary() if use_caching else {}
self._dead_receivers = False
def connect(self, receiver, sender=None, weak=True, dispatch_uid=None):
"""
Connect receiver to sender for signal.
Arguments:
receiver
A function or an instance method which is to receive signals.
Receivers must be hashable objects.
If weak is True, then receiver must be weak referenceable.
Receivers must be able to accept keyword arguments.
If a receiver is connected with a dispatch_uid argument, it
will not be added if another receiver was already connected
with that dispatch_uid.
sender
The sender to which the receiver should respond. Must either be
a Python object, or None to receive events from any sender.
weak
Whether to use weak references to the receiver. By default, the
module will attempt to use weak references to the receiver
objects. If this parameter is false, then strong references will
be used.
dispatch_uid
An identifier used to uniquely identify a particular instance of
a receiver. This will usually be a string, though it may be
anything hashable.
"""
from django.conf import settings
# If DEBUG is on, check that we got a good receiver
if settings.configured and settings.DEBUG:
assert callable(receiver), "Signal receivers must be callable."
# Check for **kwargs
if not func_accepts_kwargs(receiver):
raise ValueError("Signal receivers must accept keyword arguments (**kwargs).")
if dispatch_uid:
lookup_key = (dispatch_uid, _make_id(sender))
else:
lookup_key = (_make_id(receiver), _make_id(sender))
if weak:
ref = weakref.ref
receiver_object = receiver
# Check for bound methods
if hasattr(receiver, '__self__') and hasattr(receiver, '__func__'):
ref = WeakMethod
receiver_object = receiver.__self__
if six.PY3:
receiver = ref(receiver)
weakref.finalize(receiver_object, self._remove_receiver)
else:
receiver = ref(receiver, self._remove_receiver)
with self.lock:
self._clear_dead_receivers()
for r_key, _ in self.receivers:
if r_key == lookup_key:
break
else:
self.receivers.append((lookup_key, receiver))
self.sender_receivers_cache.clear()
def disconnect(self, receiver=None, sender=None, weak=None, dispatch_uid=None):
"""
Disconnect receiver from sender for signal.
If weak references are used, disconnect need not be called. The receiver
will be remove from dispatch automatically.
Arguments:
receiver
The registered receiver to disconnect. May be none if
dispatch_uid is specified.
sender
The registered sender to disconnect
dispatch_uid
the unique identifier of the receiver to disconnect
"""
if weak is not None:
warnings.warn("Passing `weak` to disconnect has no effect.", RemovedInDjango20Warning, stacklevel=2)
if dispatch_uid:
lookup_key = (dispatch_uid, _make_id(sender))
else:
lookup_key = (_make_id(receiver), _make_id(sender))
disconnected = False
with self.lock:
self._clear_dead_receivers()
for index in range(len(self.receivers)):
(r_key, _) = self.receivers[index]
if r_key == lookup_key:
disconnected = True
del self.receivers[index]
break
self.sender_receivers_cache.clear()
return disconnected
def has_listeners(self, sender=None):
return bool(self._live_receivers(sender))
def send(self, sender, **named):
"""
Send signal from sender to all connected receivers.
If any receiver raises an error, the error propagates back through send,
terminating the dispatch loop. So it's possible that all receivers
won't be called if an error is raised.
Arguments:
sender
The sender of the signal. Either a specific object or None.
named
Named arguments which will be passed to receivers.
Returns a list of tuple pairs [(receiver, response), ... ].
"""
if not self.receivers or self.sender_receivers_cache.get(sender) is NO_RECEIVERS:
return []
return [
(receiver, receiver(signal=self, sender=sender, **named))
for receiver in self._live_receivers(sender)
]
def send_robust(self, sender, **named):
"""
Send signal from sender to all connected receivers catching errors.
Arguments:
sender
The sender of the signal. Can be any python object (normally one
registered with a connect if you actually want something to
occur).
named
Named arguments which will be passed to receivers. These
arguments must be a subset of the argument names defined in
providing_args.
Return a list of tuple pairs [(receiver, response), ... ]. May raise
DispatcherKeyError.
If any receiver raises an error (specifically any subclass of
Exception), the error instance is returned as the result for that
receiver. The traceback is always attached to the error at
``__traceback__``.
"""
if not self.receivers or self.sender_receivers_cache.get(sender) is NO_RECEIVERS:
return []
# Call each receiver with whatever arguments it can accept.
# Return a list of tuple pairs [(receiver, response), ... ].
responses = []
for receiver in self._live_receivers(sender):
try:
response = receiver(signal=self, sender=sender, **named)
except Exception as err:
if not hasattr(err, '__traceback__'):
err.__traceback__ = sys.exc_info()[2]
responses.append((receiver, err))
else:
responses.append((receiver, response))
return responses
def _clear_dead_receivers(self):
# Note: caller is assumed to hold self.lock.
if self._dead_receivers:
self._dead_receivers = False
new_receivers = []
for r in self.receivers:
if isinstance(r[1], weakref.ReferenceType) and r[1]() is None:
continue
new_receivers.append(r)
self.receivers = new_receivers
def _live_receivers(self, sender):
"""
Filter sequence of receivers to get resolved, live receivers.
This checks for weak references and resolves them, then returning only
live receivers.
"""
receivers = None
if self.use_caching and not self._dead_receivers:
receivers = self.sender_receivers_cache.get(sender)
# We could end up here with NO_RECEIVERS even if we do check this case in
# .send() prior to calling _live_receivers() due to concurrent .send() call.
if receivers is NO_RECEIVERS:
return []
if receivers is None:
with self.lock:
self._clear_dead_receivers()
senderkey = _make_id(sender)
receivers = []
for (receiverkey, r_senderkey), receiver in self.receivers:
if r_senderkey == NONE_ID or r_senderkey == senderkey:
receivers.append(receiver)
if self.use_caching:
if not receivers:
self.sender_receivers_cache[sender] = NO_RECEIVERS
else:
# Note, we must cache the weakref versions.
self.sender_receivers_cache[sender] = receivers
non_weak_receivers = []
for receiver in receivers:
if isinstance(receiver, weakref.ReferenceType):
# Dereference the weak reference.
receiver = receiver()
if receiver is not None:
non_weak_receivers.append(receiver)
else:
non_weak_receivers.append(receiver)
return non_weak_receivers
def _remove_receiver(self, receiver=None):
# Mark that the self.receivers list has dead weakrefs. If so, we will
# clean those up in connect, disconnect and _live_receivers while
# holding self.lock. Note that doing the cleanup here isn't a good
# idea, _remove_receiver() will be called as side effect of garbage
# collection, and so the call can happen while we are already holding
# self.lock.
self._dead_receivers = True
def receiver(signal, **kwargs):
"""
A decorator for connecting receivers to signals. Used by passing in the
signal (or list of signals) and keyword arguments to connect::
@receiver(post_save, sender=MyModel)
def signal_receiver(sender, **kwargs):
...
@receiver([post_save, post_delete], sender=MyModel)
def signals_receiver(sender, **kwargs):
...
"""
def _decorator(func):
if isinstance(signal, (list, tuple)):
for s in signal:
s.connect(func, **kwargs)
else:
signal.connect(func, **kwargs)
return func
return _decorator
Django-1.11.11/django/dispatch/license.txt 0000664 0001750 0001750 00000003317 12746716542 017732 0 ustar tim tim 0000000 0000000 django.dispatch was originally forked from PyDispatcher.
PyDispatcher License:
Copyright (c) 2001-2003, Patrick K. O'Brien and 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:
Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
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.
The name of Patrick K. O'Brien, or the name of any Contributor,
may not 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 HOLDERS AND 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.
Django-1.11.11/django/dispatch/__init__.py 0000664 0001750 0001750 00000000440 13214151775 017642 0 ustar tim tim 0000000 0000000 """Multi-consumer multi-producer dispatching mechanism
Originally based on pydispatch (BSD) http://pypi.python.org/pypi/PyDispatcher/2.0.1
See license.txt for original license.
Heavily modified for Django's purposes.
"""
from django.dispatch.dispatcher import Signal, receiver # NOQA
Django-1.11.11/django/http/ 0000775 0001750 0001750 00000000000 13247520353 014711 5 ustar tim tim 0000000 0000000 Django-1.11.11/django/http/response.py 0000664 0001750 0001750 00000044137 13247520250 017126 0 ustar tim tim 0000000 0000000 from __future__ import unicode_literals
import datetime
import json
import re
import sys
import time
from email.header import Header
from django.conf import settings
from django.core import signals, signing
from django.core.exceptions import DisallowedRedirect
from django.core.serializers.json import DjangoJSONEncoder
from django.http.cookie import SimpleCookie
from django.utils import six, timezone
from django.utils.encoding import (
force_bytes, force_str, force_text, iri_to_uri,
)
from django.utils.http import cookie_date
from django.utils.six.moves import map
from django.utils.six.moves.http_client import responses
from django.utils.six.moves.urllib.parse import urlparse
_charset_from_content_type_re = re.compile(r';\s*charset=(?P[^\s;]+)', re.I)
class BadHeaderError(ValueError):
pass
class HttpResponseBase(six.Iterator):
"""
An HTTP response base class with dictionary-accessed headers.
This class doesn't handle content. It should not be used directly.
Use the HttpResponse and StreamingHttpResponse subclasses instead.
"""
status_code = 200
def __init__(self, content_type=None, status=None, reason=None, charset=None):
# _headers is a mapping of the lower-case name to the original case of
# the header (required for working with legacy systems) and the header
# value. Both the name of the header and its value are ASCII strings.
self._headers = {}
self._closable_objects = []
# This parameter is set by the handler. It's necessary to preserve the
# historical behavior of request_finished.
self._handler_class = None
self.cookies = SimpleCookie()
self.closed = False
if status is not None:
try:
self.status_code = int(status)
except (ValueError, TypeError):
raise TypeError('HTTP status code must be an integer.')
if not 100 <= self.status_code <= 599:
raise ValueError('HTTP status code must be an integer from 100 to 599.')
self._reason_phrase = reason
self._charset = charset
if content_type is None:
content_type = '%s; charset=%s' % (settings.DEFAULT_CONTENT_TYPE,
self.charset)
self['Content-Type'] = content_type
@property
def reason_phrase(self):
if self._reason_phrase is not None:
return self._reason_phrase
# Leave self._reason_phrase unset in order to use the default
# reason phrase for status code.
return responses.get(self.status_code, 'Unknown Status Code')
@reason_phrase.setter
def reason_phrase(self, value):
self._reason_phrase = value
@property
def charset(self):
if self._charset is not None:
return self._charset
content_type = self.get('Content-Type', '')
matched = _charset_from_content_type_re.search(content_type)
if matched:
# Extract the charset and strip its double quotes
return matched.group('charset').replace('"', '')
return settings.DEFAULT_CHARSET
@charset.setter
def charset(self, value):
self._charset = value
def serialize_headers(self):
"""HTTP headers as a bytestring."""
def to_bytes(val, encoding):
return val if isinstance(val, bytes) else val.encode(encoding)
headers = [
(b': '.join([to_bytes(key, 'ascii'), to_bytes(value, 'latin-1')]))
for key, value in self._headers.values()
]
return b'\r\n'.join(headers)
if six.PY3:
__bytes__ = serialize_headers
else:
__str__ = serialize_headers
@property
def _content_type_for_repr(self):
return ', "%s"' % self['Content-Type'] if 'Content-Type' in self else ''
def _convert_to_charset(self, value, charset, mime_encode=False):
"""Converts headers key/value to ascii/latin-1 native strings.
`charset` must be 'ascii' or 'latin-1'. If `mime_encode` is True and
`value` can't be represented in the given charset, MIME-encoding
is applied.
"""
if not isinstance(value, (bytes, six.text_type)):
value = str(value)
if ((isinstance(value, bytes) and (b'\n' in value or b'\r' in value)) or
isinstance(value, six.text_type) and ('\n' in value or '\r' in value)):
raise BadHeaderError("Header values can't contain newlines (got %r)" % value)
try:
if six.PY3:
if isinstance(value, str):
# Ensure string is valid in given charset
value.encode(charset)
else:
# Convert bytestring using given charset
value = value.decode(charset)
else:
if isinstance(value, str):
# Ensure string is valid in given charset
value.decode(charset)
else:
# Convert unicode string to given charset
value = value.encode(charset)
except UnicodeError as e:
if mime_encode:
# Wrapping in str() is a workaround for #12422 under Python 2.
value = str(Header(value, 'utf-8', maxlinelen=sys.maxsize).encode())
else:
e.reason += ', HTTP response headers must be in %s format' % charset
raise
return value
def __setitem__(self, header, value):
header = self._convert_to_charset(header, 'ascii')
value = self._convert_to_charset(value, 'latin-1', mime_encode=True)
self._headers[header.lower()] = (header, value)
def __delitem__(self, header):
try:
del self._headers[header.lower()]
except KeyError:
pass
def __getitem__(self, header):
return self._headers[header.lower()][1]
def has_header(self, header):
"""Case-insensitive check for a header."""
return header.lower() in self._headers
__contains__ = has_header
def items(self):
return self._headers.values()
def get(self, header, alternate=None):
return self._headers.get(header.lower(), (None, alternate))[1]
def set_cookie(self, key, value='', max_age=None, expires=None, path='/',
domain=None, secure=False, httponly=False):
"""
Sets a cookie.
``expires`` can be:
- a string in the correct format,
- a naive ``datetime.datetime`` object in UTC,
- an aware ``datetime.datetime`` object in any time zone.
If it is a ``datetime.datetime`` object then ``max_age`` will be calculated.
"""
value = force_str(value)
self.cookies[key] = value
if expires is not None:
if isinstance(expires, datetime.datetime):
if timezone.is_aware(expires):
expires = timezone.make_naive(expires, timezone.utc)
delta = expires - expires.utcnow()
# Add one second so the date matches exactly (a fraction of
# time gets lost between converting to a timedelta and
# then the date string).
delta = delta + datetime.timedelta(seconds=1)
# Just set max_age - the max_age logic will set expires.
expires = None
max_age = max(0, delta.days * 86400 + delta.seconds)
else:
self.cookies[key]['expires'] = expires
else:
self.cookies[key]['expires'] = ''
if max_age is not None:
self.cookies[key]['max-age'] = max_age
# IE requires expires, so set it if hasn't been already.
if not expires:
self.cookies[key]['expires'] = cookie_date(time.time() +
max_age)
if path is not None:
self.cookies[key]['path'] = path
if domain is not None:
self.cookies[key]['domain'] = domain
if secure:
self.cookies[key]['secure'] = True
if httponly:
self.cookies[key]['httponly'] = True
def setdefault(self, key, value):
"""Sets a header unless it has already been set."""
if key not in self:
self[key] = value
def set_signed_cookie(self, key, value, salt='', **kwargs):
value = signing.get_cookie_signer(salt=key + salt).sign(value)
return self.set_cookie(key, value, **kwargs)
def delete_cookie(self, key, path='/', domain=None):
self.set_cookie(key, max_age=0, path=path, domain=domain,
expires='Thu, 01-Jan-1970 00:00:00 GMT')
# Common methods used by subclasses
def make_bytes(self, value):
"""Turn a value into a bytestring encoded in the output charset."""
# Per PEP 3333, this response body must be bytes. To avoid returning
# an instance of a subclass, this function returns `bytes(value)`.
# This doesn't make a copy when `value` already contains bytes.
# Handle string types -- we can't rely on force_bytes here because:
# - under Python 3 it attempts str conversion first
# - when self._charset != 'utf-8' it re-encodes the content
if isinstance(value, bytes):
return bytes(value)
if isinstance(value, six.text_type):
return bytes(value.encode(self.charset))
# Handle non-string types (#16494)
return force_bytes(value, self.charset)
# These methods partially implement the file-like object interface.
# See https://docs.python.org/3/library/io.html#io.IOBase
# The WSGI server must call this method upon completion of the request.
# See http://blog.dscpl.com.au/2012/10/obligations-for-calling-close-on.html
def close(self):
for closable in self._closable_objects:
try:
closable.close()
except Exception:
pass
self.closed = True
signals.request_finished.send(sender=self._handler_class)
def write(self, content):
raise IOError("This %s instance is not writable" % self.__class__.__name__)
def flush(self):
pass
def tell(self):
raise IOError("This %s instance cannot tell its position" % self.__class__.__name__)
# These methods partially implement a stream-like object interface.
# See https://docs.python.org/library/io.html#io.IOBase
def readable(self):
return False
def seekable(self):
return False
def writable(self):
return False
def writelines(self, lines):
raise IOError("This %s instance is not writable" % self.__class__.__name__)
class HttpResponse(HttpResponseBase):
"""
An HTTP response class with a string as content.
This content that can be read, appended to or replaced.
"""
streaming = False
def __init__(self, content=b'', *args, **kwargs):
super(HttpResponse, self).__init__(*args, **kwargs)
# Content is a bytestring. See the `content` property methods.
self.content = content
def __repr__(self):
return '<%(cls)s status_code=%(status_code)d%(content_type)s>' % {
'cls': self.__class__.__name__,
'status_code': self.status_code,
'content_type': self._content_type_for_repr,
}
def serialize(self):
"""Full HTTP message, including headers, as a bytestring."""
return self.serialize_headers() + b'\r\n\r\n' + self.content
if six.PY3:
__bytes__ = serialize
else:
__str__ = serialize
@property
def content(self):
return b''.join(self._container)
@content.setter
def content(self, value):
# Consume iterators upon assignment to allow repeated iteration.
if hasattr(value, '__iter__') and not isinstance(value, (bytes, six.string_types)):
content = b''.join(self.make_bytes(chunk) for chunk in value)
if hasattr(value, 'close'):
try:
value.close()
except Exception:
pass
else:
content = self.make_bytes(value)
# Create a list of properly encoded bytestrings to support write().
self._container = [content]
def __iter__(self):
return iter(self._container)
def write(self, content):
self._container.append(self.make_bytes(content))
def tell(self):
return len(self.content)
def getvalue(self):
return self.content
def writable(self):
return True
def writelines(self, lines):
for line in lines:
self.write(line)
class StreamingHttpResponse(HttpResponseBase):
"""
A streaming HTTP response class with an iterator as content.
This should only be iterated once, when the response is streamed to the
client. However, it can be appended to or replaced with a new iterator
that wraps the original content (or yields entirely new content).
"""
streaming = True
def __init__(self, streaming_content=(), *args, **kwargs):
super(StreamingHttpResponse, self).__init__(*args, **kwargs)
# `streaming_content` should be an iterable of bytestrings.
# See the `streaming_content` property methods.
self.streaming_content = streaming_content
@property
def content(self):
raise AttributeError(
"This %s instance has no `content` attribute. Use "
"`streaming_content` instead." % self.__class__.__name__
)
@property
def streaming_content(self):
return map(self.make_bytes, self._iterator)
@streaming_content.setter
def streaming_content(self, value):
self._set_streaming_content(value)
def _set_streaming_content(self, value):
# Ensure we can never iterate on "value" more than once.
self._iterator = iter(value)
if hasattr(value, 'close'):
self._closable_objects.append(value)
def __iter__(self):
return self.streaming_content
def getvalue(self):
return b''.join(self.streaming_content)
class FileResponse(StreamingHttpResponse):
"""
A streaming HTTP response class optimized for files.
"""
block_size = 4096
def _set_streaming_content(self, value):
if hasattr(value, 'read'):
self.file_to_stream = value
filelike = value
if hasattr(filelike, 'close'):
self._closable_objects.append(filelike)
value = iter(lambda: filelike.read(self.block_size), b'')
else:
self.file_to_stream = None
super(FileResponse, self)._set_streaming_content(value)
class HttpResponseRedirectBase(HttpResponse):
allowed_schemes = ['http', 'https', 'ftp']
def __init__(self, redirect_to, *args, **kwargs):
super(HttpResponseRedirectBase, self).__init__(*args, **kwargs)
self['Location'] = iri_to_uri(redirect_to)
parsed = urlparse(force_text(redirect_to))
if parsed.scheme and parsed.scheme not in self.allowed_schemes:
raise DisallowedRedirect("Unsafe redirect to URL with protocol '%s'" % parsed.scheme)
url = property(lambda self: self['Location'])
def __repr__(self):
return '<%(cls)s status_code=%(status_code)d%(content_type)s, url="%(url)s">' % {
'cls': self.__class__.__name__,
'status_code': self.status_code,
'content_type': self._content_type_for_repr,
'url': self.url,
}
class HttpResponseRedirect(HttpResponseRedirectBase):
status_code = 302
class HttpResponsePermanentRedirect(HttpResponseRedirectBase):
status_code = 301
class HttpResponseNotModified(HttpResponse):
status_code = 304
def __init__(self, *args, **kwargs):
super(HttpResponseNotModified, self).__init__(*args, **kwargs)
del self['content-type']
@HttpResponse.content.setter
def content(self, value):
if value:
raise AttributeError("You cannot set content to a 304 (Not Modified) response")
self._container = []
class HttpResponseBadRequest(HttpResponse):
status_code = 400
class HttpResponseNotFound(HttpResponse):
status_code = 404
class HttpResponseForbidden(HttpResponse):
status_code = 403
class HttpResponseNotAllowed(HttpResponse):
status_code = 405
def __init__(self, permitted_methods, *args, **kwargs):
super(HttpResponseNotAllowed, self).__init__(*args, **kwargs)
self['Allow'] = ', '.join(permitted_methods)
def __repr__(self):
return '<%(cls)s [%(methods)s] status_code=%(status_code)d%(content_type)s>' % {
'cls': self.__class__.__name__,
'status_code': self.status_code,
'content_type': self._content_type_for_repr,
'methods': self['Allow'],
}
class HttpResponseGone(HttpResponse):
status_code = 410
class HttpResponseServerError(HttpResponse):
status_code = 500
class Http404(Exception):
pass
class JsonResponse(HttpResponse):
"""
An HTTP response class that consumes data to be serialized to JSON.
:param data: Data to be dumped into json. By default only ``dict`` objects
are allowed to be passed due to a security flaw before EcmaScript 5. See
the ``safe`` parameter for more information.
:param encoder: Should be an json encoder class. Defaults to
``django.core.serializers.json.DjangoJSONEncoder``.
:param safe: Controls if only ``dict`` objects may be serialized. Defaults
to ``True``.
:param json_dumps_params: A dictionary of kwargs passed to json.dumps().
"""
def __init__(self, data, encoder=DjangoJSONEncoder, safe=True,
json_dumps_params=None, **kwargs):
if safe and not isinstance(data, dict):
raise TypeError(
'In order to allow non-dict objects to be serialized set the '
'safe parameter to False.'
)
if json_dumps_params is None:
json_dumps_params = {}
kwargs.setdefault('content_type', 'application/json')
data = json.dumps(data, cls=encoder, **json_dumps_params)
super(JsonResponse, self).__init__(content=data, **kwargs)
Django-1.11.11/django/http/cookie.py 0000664 0001750 0001750 00000005517 13247520250 016540 0 ustar tim tim 0000000 0000000 from __future__ import unicode_literals
import sys
from django.utils import six
from django.utils.encoding import force_str
from django.utils.six.moves import http_cookies
# http://bugs.python.org/issue2193 is fixed in Python 3.3+.
_cookie_allows_colon_in_names = six.PY3
# Cookie pickling bug is fixed in Python 2.7.9 and Python 3.4.3+
# http://bugs.python.org/issue22775
cookie_pickles_properly = (
(sys.version_info[:2] == (2, 7) and sys.version_info >= (2, 7, 9)) or
sys.version_info >= (3, 4, 3)
)
if _cookie_allows_colon_in_names and cookie_pickles_properly:
SimpleCookie = http_cookies.SimpleCookie
else:
Morsel = http_cookies.Morsel
class SimpleCookie(http_cookies.SimpleCookie):
if not cookie_pickles_properly:
def __setitem__(self, key, value):
# Apply the fix from http://bugs.python.org/issue22775 where
# it's not fixed in Python itself
if isinstance(value, Morsel):
# allow assignment of constructed Morsels (e.g. for pickling)
dict.__setitem__(self, key, value)
else:
super(SimpleCookie, self).__setitem__(key, value)
if not _cookie_allows_colon_in_names:
def load(self, rawdata):
self.bad_cookies = set()
if isinstance(rawdata, six.text_type):
rawdata = force_str(rawdata)
super(SimpleCookie, self).load(rawdata)
for key in self.bad_cookies:
del self[key]
# override private __set() method:
# (needed for using our Morsel, and for laxness with CookieError
def _BaseCookie__set(self, key, real_value, coded_value):
key = force_str(key)
try:
M = self.get(key, Morsel())
M.set(key, real_value, coded_value)
dict.__setitem__(self, key, M)
except http_cookies.CookieError:
if not hasattr(self, 'bad_cookies'):
self.bad_cookies = set()
self.bad_cookies.add(key)
dict.__setitem__(self, key, http_cookies.Morsel())
def parse_cookie(cookie):
"""
Return a dictionary parsed from a `Cookie:` header string.
"""
cookiedict = {}
if six.PY2:
cookie = force_str(cookie)
for chunk in cookie.split(str(';')):
if str('=') in chunk:
key, val = chunk.split(str('='), 1)
else:
# Assume an empty name per
# https://bugzilla.mozilla.org/show_bug.cgi?id=169091
key, val = str(''), chunk
key, val = key.strip(), val.strip()
if key or val:
# unquote using Python's algorithm.
cookiedict[key] = http_cookies._unquote(val)
return cookiedict
Django-1.11.11/django/http/multipartparser.py 0000664 0001750 0001750 00000061516 13247520250 020526 0 ustar tim tim 0000000 0000000 """
Multi-part parsing for file uploads.
Exposes one class, ``MultiPartParser``, which feeds chunks of uploaded data to
file upload handlers for processing.
"""
from __future__ import unicode_literals
import base64
import binascii
import cgi
import sys
from django.conf import settings
from django.core.exceptions import (
RequestDataTooBig, SuspiciousMultipartForm, TooManyFieldsSent,
)
from django.core.files.uploadhandler import (
SkipFile, StopFutureHandlers, StopUpload,
)
from django.utils import six
from django.utils.datastructures import MultiValueDict
from django.utils.encoding import force_text
from django.utils.six.moves.urllib.parse import unquote
from django.utils.text import unescape_entities
__all__ = ('MultiPartParser', 'MultiPartParserError', 'InputStreamExhausted')
class MultiPartParserError(Exception):
pass
class InputStreamExhausted(Exception):
"""
No more reads are allowed from this device.
"""
pass
RAW = "raw"
FILE = "file"
FIELD = "field"
_BASE64_DECODE_ERROR = TypeError if six.PY2 else binascii.Error
class MultiPartParser(object):
"""
A rfc2388 multipart/form-data parser.
``MultiValueDict.parse()`` reads the input stream in ``chunk_size`` chunks
and returns a tuple of ``(MultiValueDict(POST), MultiValueDict(FILES))``.
"""
def __init__(self, META, input_data, upload_handlers, encoding=None):
"""
Initialize the MultiPartParser object.
:META:
The standard ``META`` dictionary in Django request objects.
:input_data:
The raw post data, as a file-like object.
:upload_handlers:
A list of UploadHandler instances that perform operations on the
uploaded data.
:encoding:
The encoding with which to treat the incoming data.
"""
# Content-Type should contain multipart and the boundary information.
content_type = META.get('CONTENT_TYPE', '')
if not content_type.startswith('multipart/'):
raise MultiPartParserError('Invalid Content-Type: %s' % content_type)
# Parse the header to get the boundary to split the parts.
ctypes, opts = parse_header(content_type.encode('ascii'))
boundary = opts.get('boundary')
if not boundary or not cgi.valid_boundary(boundary):
raise MultiPartParserError('Invalid boundary in multipart: %s' % boundary)
# Content-Length should contain the length of the body we are about
# to receive.
try:
content_length = int(META.get('CONTENT_LENGTH', 0))
except (ValueError, TypeError):
content_length = 0
if content_length < 0:
# This means we shouldn't continue...raise an error.
raise MultiPartParserError("Invalid content length: %r" % content_length)
if isinstance(boundary, six.text_type):
boundary = boundary.encode('ascii')
self._boundary = boundary
self._input_data = input_data
# For compatibility with low-level network APIs (with 32-bit integers),
# the chunk size should be < 2^31, but still divisible by 4.
possible_sizes = [x.chunk_size for x in upload_handlers if x.chunk_size]
self._chunk_size = min([2 ** 31 - 4] + possible_sizes)
self._meta = META
self._encoding = encoding or settings.DEFAULT_CHARSET
self._content_length = content_length
self._upload_handlers = upload_handlers
def parse(self):
"""
Parse the POST data and break it into a FILES MultiValueDict and a POST
MultiValueDict.
Return a tuple containing the POST and FILES dictionary, respectively.
"""
from django.http import QueryDict
encoding = self._encoding
handlers = self._upload_handlers
# HTTP spec says that Content-Length >= 0 is valid
# handling content-length == 0 before continuing
if self._content_length == 0:
return QueryDict(encoding=self._encoding), MultiValueDict()
# See if any of the handlers take care of the parsing.
# This allows overriding everything if need be.
for handler in handlers:
result = handler.handle_raw_input(
self._input_data,
self._meta,
self._content_length,
self._boundary,
encoding,
)
# Check to see if it was handled
if result is not None:
return result[0], result[1]
# Create the data structures to be used later.
self._post = QueryDict(mutable=True)
self._files = MultiValueDict()
# Instantiate the parser and stream:
stream = LazyStream(ChunkIter(self._input_data, self._chunk_size))
# Whether or not to signal a file-completion at the beginning of the loop.
old_field_name = None
counters = [0] * len(handlers)
# Number of bytes that have been read.
num_bytes_read = 0
# To count the number of keys in the request.
num_post_keys = 0
# To limit the amount of data read from the request.
read_size = None
try:
for item_type, meta_data, field_stream in Parser(stream, self._boundary):
if old_field_name:
# We run this at the beginning of the next loop
# since we cannot be sure a file is complete until
# we hit the next boundary/part of the multipart content.
self.handle_file_complete(old_field_name, counters)
old_field_name = None
try:
disposition = meta_data['content-disposition'][1]
field_name = disposition['name'].strip()
except (KeyError, IndexError, AttributeError):
continue
transfer_encoding = meta_data.get('content-transfer-encoding')
if transfer_encoding is not None:
transfer_encoding = transfer_encoding[0].strip()
field_name = force_text(field_name, encoding, errors='replace')
if item_type == FIELD:
# Avoid storing more than DATA_UPLOAD_MAX_NUMBER_FIELDS.
num_post_keys += 1
if (settings.DATA_UPLOAD_MAX_NUMBER_FIELDS is not None and
settings.DATA_UPLOAD_MAX_NUMBER_FIELDS < num_post_keys):
raise TooManyFieldsSent(
'The number of GET/POST parameters exceeded '
'settings.DATA_UPLOAD_MAX_NUMBER_FIELDS.'
)
# Avoid reading more than DATA_UPLOAD_MAX_MEMORY_SIZE.
if settings.DATA_UPLOAD_MAX_MEMORY_SIZE is not None:
read_size = settings.DATA_UPLOAD_MAX_MEMORY_SIZE - num_bytes_read
# This is a post field, we can just set it in the post
if transfer_encoding == 'base64':
raw_data = field_stream.read(size=read_size)
num_bytes_read += len(raw_data)
try:
data = base64.b64decode(raw_data)
except _BASE64_DECODE_ERROR:
data = raw_data
else:
data = field_stream.read(size=read_size)
num_bytes_read += len(data)
# Add two here to make the check consistent with the
# x-www-form-urlencoded check that includes '&='.
num_bytes_read += len(field_name) + 2
if (settings.DATA_UPLOAD_MAX_MEMORY_SIZE is not None and
num_bytes_read > settings.DATA_UPLOAD_MAX_MEMORY_SIZE):
raise RequestDataTooBig('Request body exceeded settings.DATA_UPLOAD_MAX_MEMORY_SIZE.')
self._post.appendlist(field_name, force_text(data, encoding, errors='replace'))
elif item_type == FILE:
# This is a file, use the handler...
file_name = disposition.get('filename')
if file_name:
file_name = force_text(file_name, encoding, errors='replace')
file_name = self.IE_sanitize(unescape_entities(file_name))
if not file_name:
continue
content_type, content_type_extra = meta_data.get('content-type', ('', {}))
content_type = content_type.strip()
charset = content_type_extra.get('charset')
try:
content_length = int(meta_data.get('content-length')[0])
except (IndexError, TypeError, ValueError):
content_length = None
counters = [0] * len(handlers)
try:
for handler in handlers:
try:
handler.new_file(
field_name, file_name, content_type,
content_length, charset, content_type_extra,
)
except StopFutureHandlers:
break
for chunk in field_stream:
if transfer_encoding == 'base64':
# We only special-case base64 transfer encoding
# We should always decode base64 chunks by multiple of 4,
# ignoring whitespace.
stripped_chunk = b"".join(chunk.split())
remaining = len(stripped_chunk) % 4
while remaining != 0:
over_chunk = field_stream.read(4 - remaining)
stripped_chunk += b"".join(over_chunk.split())
remaining = len(stripped_chunk) % 4
try:
chunk = base64.b64decode(stripped_chunk)
except Exception as e:
# Since this is only a chunk, any error is an unfixable error.
msg = "Could not decode base64 data: %r" % e
six.reraise(MultiPartParserError, MultiPartParserError(msg), sys.exc_info()[2])
for i, handler in enumerate(handlers):
chunk_length = len(chunk)
chunk = handler.receive_data_chunk(chunk, counters[i])
counters[i] += chunk_length
if chunk is None:
# Don't continue if the chunk received by
# the handler is None.
break
except SkipFile:
self._close_files()
# Just use up the rest of this file...
exhaust(field_stream)
else:
# Handle file upload completions on next iteration.
old_field_name = field_name
else:
# If this is neither a FIELD or a FILE, just exhaust the stream.
exhaust(stream)
except StopUpload as e:
self._close_files()
if not e.connection_reset:
exhaust(self._input_data)
else:
# Make sure that the request data is all fed
exhaust(self._input_data)
# Signal that the upload has completed.
for handler in handlers:
retval = handler.upload_complete()
if retval:
break
self._post._mutable = False
return self._post, self._files
def handle_file_complete(self, old_field_name, counters):
"""
Handle all the signaling that takes place when a file is complete.
"""
for i, handler in enumerate(self._upload_handlers):
file_obj = handler.file_complete(counters[i])
if file_obj:
# If it returns a file object, then set the files dict.
self._files.appendlist(force_text(old_field_name, self._encoding, errors='replace'), file_obj)
break
def IE_sanitize(self, filename):
"""Cleanup filename from Internet Explorer full paths."""
return filename and filename[filename.rfind("\\") + 1:].strip()
def _close_files(self):
# Free up all file handles.
# FIXME: this currently assumes that upload handlers store the file as 'file'
# We should document that... (Maybe add handler.free_file to complement new_file)
for handler in self._upload_handlers:
if hasattr(handler, 'file'):
handler.file.close()
class LazyStream(six.Iterator):
"""
The LazyStream wrapper allows one to get and "unget" bytes from a stream.
Given a producer object (an iterator that yields bytestrings), the
LazyStream object will support iteration, reading, and keeping a "look-back"
variable in case you need to "unget" some bytes.
"""
def __init__(self, producer, length=None):
"""
Every LazyStream must have a producer when instantiated.
A producer is an iterable that returns a string each time it
is called.
"""
self._producer = producer
self._empty = False
self._leftover = b''
self.length = length
self.position = 0
self._remaining = length
self._unget_history = []
def tell(self):
return self.position
def read(self, size=None):
def parts():
remaining = self._remaining if size is None else size
# do the whole thing in one shot if no limit was provided.
if remaining is None:
yield b''.join(self)
return
# otherwise do some bookkeeping to return exactly enough
# of the stream and stashing any extra content we get from
# the producer
while remaining != 0:
assert remaining > 0, 'remaining bytes to read should never go negative'
try:
chunk = next(self)
except StopIteration:
return
else:
emitting = chunk[:remaining]
self.unget(chunk[remaining:])
remaining -= len(emitting)
yield emitting
out = b''.join(parts())
return out
def __next__(self):
"""
Used when the exact number of bytes to read is unimportant.
This procedure just returns whatever is chunk is conveniently returned
from the iterator instead. Useful to avoid unnecessary bookkeeping if
performance is an issue.
"""
if self._leftover:
output = self._leftover
self._leftover = b''
else:
output = next(self._producer)
self._unget_history = []
self.position += len(output)
return output
def close(self):
"""
Used to invalidate/disable this lazy stream.
Replaces the producer with an empty list. Any leftover bytes that have
already been read will still be reported upon read() and/or next().
"""
self._producer = []
def __iter__(self):
return self
def unget(self, bytes):
"""
Places bytes back onto the front of the lazy stream.
Future calls to read() will return those bytes first. The
stream position and thus tell() will be rewound.
"""
if not bytes:
return
self._update_unget_history(len(bytes))
self.position -= len(bytes)
self._leftover = b''.join([bytes, self._leftover])
def _update_unget_history(self, num_bytes):
"""
Updates the unget history as a sanity check to see if we've pushed
back the same number of bytes in one chunk. If we keep ungetting the
same number of bytes many times (here, 50), we're mostly likely in an
infinite loop of some sort. This is usually caused by a
maliciously-malformed MIME request.
"""
self._unget_history = [num_bytes] + self._unget_history[:49]
number_equal = len([
current_number for current_number in self._unget_history
if current_number == num_bytes
])
if number_equal > 40:
raise SuspiciousMultipartForm(
"The multipart parser got stuck, which shouldn't happen with"
" normal uploaded files. Check for malicious upload activity;"
" if there is none, report this to the Django developers."
)
class ChunkIter(six.Iterator):
"""
An iterable that will yield chunks of data. Given a file-like object as the
constructor, this object will yield chunks of read operations from that
object.
"""
def __init__(self, flo, chunk_size=64 * 1024):
self.flo = flo
self.chunk_size = chunk_size
def __next__(self):
try:
data = self.flo.read(self.chunk_size)
except InputStreamExhausted:
raise StopIteration()
if data:
return data
else:
raise StopIteration()
def __iter__(self):
return self
class InterBoundaryIter(six.Iterator):
"""
A Producer that will iterate over boundaries.
"""
def __init__(self, stream, boundary):
self._stream = stream
self._boundary = boundary
def __iter__(self):
return self
def __next__(self):
try:
return LazyStream(BoundaryIter(self._stream, self._boundary))
except InputStreamExhausted:
raise StopIteration()
class BoundaryIter(six.Iterator):
"""
A Producer that is sensitive to boundaries.
Will happily yield bytes until a boundary is found. Will yield the bytes
before the boundary, throw away the boundary bytes themselves, and push the
post-boundary bytes back on the stream.
The future calls to next() after locating the boundary will raise a
StopIteration exception.
"""
def __init__(self, stream, boundary):
self._stream = stream
self._boundary = boundary
self._done = False
# rollback an additional six bytes because the format is like
# this: CRLF[--CRLF]
self._rollback = len(boundary) + 6
# Try to use mx fast string search if available. Otherwise
# use Python find. Wrap the latter for consistency.
unused_char = self._stream.read(1)
if not unused_char:
raise InputStreamExhausted()
self._stream.unget(unused_char)
def __iter__(self):
return self
def __next__(self):
if self._done:
raise StopIteration()
stream = self._stream
rollback = self._rollback
bytes_read = 0
chunks = []
for bytes in stream:
bytes_read += len(bytes)
chunks.append(bytes)
if bytes_read > rollback:
break
if not bytes:
break
else:
self._done = True
if not chunks:
raise StopIteration()
chunk = b''.join(chunks)
boundary = self._find_boundary(chunk, len(chunk) < self._rollback)
if boundary:
end, next = boundary
stream.unget(chunk[next:])
self._done = True
return chunk[:end]
else:
# make sure we don't treat a partial boundary (and
# its separators) as data
if not chunk[:-rollback]: # and len(chunk) >= (len(self._boundary) + 6):
# There's nothing left, we should just return and mark as done.
self._done = True
return chunk
else:
stream.unget(chunk[-rollback:])
return chunk[:-rollback]
def _find_boundary(self, data, eof=False):
"""
Finds a multipart boundary in data.
Should no boundary exist in the data None is returned instead. Otherwise
a tuple containing the indices of the following are returned:
* the end of current encapsulation
* the start of the next encapsulation
"""
index = data.find(self._boundary)
if index < 0:
return None
else:
end = index
next = index + len(self._boundary)
# backup over CRLF
last = max(0, end - 1)
if data[last:last + 1] == b'\n':
end -= 1
last = max(0, end - 1)
if data[last:last + 1] == b'\r':
end -= 1
return end, next
def exhaust(stream_or_iterable):
"""Exhaust an iterator or stream."""
try:
iterator = iter(stream_or_iterable)
except TypeError:
iterator = ChunkIter(stream_or_iterable, 16384)
for __ in iterator:
pass
def parse_boundary_stream(stream, max_header_size):
"""
Parses one and exactly one stream that encapsulates a boundary.
"""
# Stream at beginning of header, look for end of header
# and parse it if found. The header must fit within one
# chunk.
chunk = stream.read(max_header_size)
# 'find' returns the top of these four bytes, so we'll
# need to munch them later to prevent them from polluting
# the payload.
header_end = chunk.find(b'\r\n\r\n')
def _parse_header(line):
main_value_pair, params = parse_header(line)
try:
name, value = main_value_pair.split(':', 1)
except ValueError:
raise ValueError("Invalid header: %r" % line)
return name, (value, params)
if header_end == -1:
# we find no header, so we just mark this fact and pass on
# the stream verbatim
stream.unget(chunk)
return (RAW, {}, stream)
header = chunk[:header_end]
# here we place any excess chunk back onto the stream, as
# well as throwing away the CRLFCRLF bytes from above.
stream.unget(chunk[header_end + 4:])
TYPE = RAW
outdict = {}
# Eliminate blank lines
for line in header.split(b'\r\n'):
# This terminology ("main value" and "dictionary of
# parameters") is from the Python docs.
try:
name, (value, params) = _parse_header(line)
except ValueError:
continue
if name == 'content-disposition':
TYPE = FIELD
if params.get('filename'):
TYPE = FILE
outdict[name] = value, params
if TYPE == RAW:
stream.unget(chunk)
return (TYPE, outdict, stream)
class Parser(object):
def __init__(self, stream, boundary):
self._stream = stream
self._separator = b'--' + boundary
def __iter__(self):
boundarystream = InterBoundaryIter(self._stream, self._separator)
for sub_stream in boundarystream:
# Iterate over each part
yield parse_boundary_stream(sub_stream, 1024)
def parse_header(line):
"""
Parse the header into a key-value.
Input (line): bytes, output: unicode for key/name, bytes for value which
will be decoded later.
"""
plist = _parse_header_params(b';' + line)
key = plist.pop(0).lower().decode('ascii')
pdict = {}
for p in plist:
i = p.find(b'=')
if i >= 0:
has_encoding = False
name = p[:i].strip().lower().decode('ascii')
if name.endswith('*'):
# Lang/encoding embedded in the value (like "filename*=UTF-8''file.ext")
# http://tools.ietf.org/html/rfc2231#section-4
name = name[:-1]
if p.count(b"'") == 2:
has_encoding = True
value = p[i + 1:].strip()
if has_encoding:
encoding, lang, value = value.split(b"'")
if six.PY3:
value = unquote(value.decode(), encoding=encoding.decode())
else:
value = unquote(value).decode(encoding)
if len(value) >= 2 and value[:1] == value[-1:] == b'"':
value = value[1:-1]
value = value.replace(b'\\\\', b'\\').replace(b'\\"', b'"')
pdict[name] = value
return key, pdict
def _parse_header_params(s):
plist = []
while s[:1] == b';':
s = s[1:]
end = s.find(b';')
while end > 0 and s.count(b'"', 0, end) % 2:
end = s.find(b';', end + 1)
if end < 0:
end = len(s)
f = s[:end]
plist.append(f.strip())
s = s[end:]
return plist
Django-1.11.11/django/http/__init__.py 0000664 0001750 0001750 00000001762 13247517144 017034 0 ustar tim tim 0000000 0000000 from django.http.cookie import SimpleCookie, parse_cookie
from django.http.request import (
HttpRequest, QueryDict, RawPostDataException, UnreadablePostError,
)
from django.http.response import (
BadHeaderError, FileResponse, Http404, HttpResponse,
HttpResponseBadRequest, HttpResponseForbidden, HttpResponseGone,
HttpResponseNotAllowed, HttpResponseNotFound, HttpResponseNotModified,
HttpResponsePermanentRedirect, HttpResponseRedirect,
HttpResponseServerError, JsonResponse, StreamingHttpResponse,
)
__all__ = [
'SimpleCookie', 'parse_cookie', 'HttpRequest', 'QueryDict',
'RawPostDataException', 'UnreadablePostError',
'HttpResponse', 'StreamingHttpResponse', 'HttpResponseRedirect',
'HttpResponsePermanentRedirect', 'HttpResponseNotModified',
'HttpResponseBadRequest', 'HttpResponseForbidden', 'HttpResponseNotFound',
'HttpResponseNotAllowed', 'HttpResponseGone', 'HttpResponseServerError',
'Http404', 'BadHeaderError', 'JsonResponse', 'FileResponse',
]
Django-1.11.11/django/http/request.py 0000664 0001750 0001750 00000051607 13247520250 016760 0 ustar tim tim 0000000 0000000 from __future__ import unicode_literals
import copy
import re
import sys
from io import BytesIO
from itertools import chain
from django.conf import settings
from django.core import signing
from django.core.exceptions import (
DisallowedHost, ImproperlyConfigured, RequestDataTooBig,
)
from django.core.files import uploadhandler
from django.http.multipartparser import MultiPartParser, MultiPartParserError
from django.utils import six
from django.utils.datastructures import ImmutableList, MultiValueDict
from django.utils.encoding import (
escape_uri_path, force_bytes, force_str, force_text, iri_to_uri,
)
from django.utils.http import is_same_domain, limited_parse_qsl
from django.utils.six.moves.urllib.parse import (
quote, urlencode, urljoin, urlsplit,
)
RAISE_ERROR = object()
host_validation_re = re.compile(r"^([a-z0-9.-]+|\[[a-f0-9]*:[a-f0-9\.:]+\])(:\d+)?$")
class UnreadablePostError(IOError):
pass
class RawPostDataException(Exception):
"""
You cannot access raw_post_data from a request that has
multipart/* POST data if it has been accessed via POST,
FILES, etc..
"""
pass
class HttpRequest(object):
"""A basic HTTP request."""
# The encoding used in GET/POST dicts. None means use default setting.
_encoding = None
_upload_handlers = []
def __init__(self):
# WARNING: The `WSGIRequest` subclass doesn't call `super`.
# Any variable assignment made here should also happen in
# `WSGIRequest.__init__()`.
self.GET = QueryDict(mutable=True)
self.POST = QueryDict(mutable=True)
self.COOKIES = {}
self.META = {}
self.FILES = MultiValueDict()
self.path = ''
self.path_info = ''
self.method = None
self.resolver_match = None
self._post_parse_error = False
self.content_type = None
self.content_params = None
def __repr__(self):
if self.method is None or not self.get_full_path():
return force_str('<%s>' % self.__class__.__name__)
return force_str(
'<%s: %s %r>' % (self.__class__.__name__, self.method, force_str(self.get_full_path()))
)
def _get_raw_host(self):
"""
Return the HTTP host using the environment or request headers. Skip
allowed hosts protection, so may return an insecure host.
"""
# We try three options, in order of decreasing preference.
if settings.USE_X_FORWARDED_HOST and (
'HTTP_X_FORWARDED_HOST' in self.META):
host = self.META['HTTP_X_FORWARDED_HOST']
elif 'HTTP_HOST' in self.META:
host = self.META['HTTP_HOST']
else:
# Reconstruct the host using the algorithm from PEP 333.
host = self.META['SERVER_NAME']
server_port = self.get_port()
if server_port != ('443' if self.is_secure() else '80'):
host = '%s:%s' % (host, server_port)
return host
def get_host(self):
"""Return the HTTP host using the environment or request headers."""
host = self._get_raw_host()
# Allow variants of localhost if ALLOWED_HOSTS is empty and DEBUG=True.
allowed_hosts = settings.ALLOWED_HOSTS
if settings.DEBUG and not allowed_hosts:
allowed_hosts = ['localhost', '127.0.0.1', '[::1]']
domain, port = split_domain_port(host)
if domain and validate_host(domain, allowed_hosts):
return host
else:
msg = "Invalid HTTP_HOST header: %r." % host
if domain:
msg += " You may need to add %r to ALLOWED_HOSTS." % domain
else:
msg += " The domain name provided is not valid according to RFC 1034/1035."
raise DisallowedHost(msg)
def get_port(self):
"""Return the port number for the request as a string."""
if settings.USE_X_FORWARDED_PORT and 'HTTP_X_FORWARDED_PORT' in self.META:
port = self.META['HTTP_X_FORWARDED_PORT']
else:
port = self.META['SERVER_PORT']
return str(port)
def get_full_path(self, force_append_slash=False):
# RFC 3986 requires query string arguments to be in the ASCII range.
# Rather than crash if this doesn't happen, we encode defensively.
return '%s%s%s' % (
escape_uri_path(self.path),
'/' if force_append_slash and not self.path.endswith('/') else '',
('?' + iri_to_uri(self.META.get('QUERY_STRING', ''))) if self.META.get('QUERY_STRING', '') else ''
)
def get_signed_cookie(self, key, default=RAISE_ERROR, salt='', max_age=None):
"""
Attempts to return a signed cookie. If the signature fails or the
cookie has expired, raises an exception... unless you provide the
default argument in which case that value will be returned instead.
"""
try:
cookie_value = self.COOKIES[key]
except KeyError:
if default is not RAISE_ERROR:
return default
else:
raise
try:
value = signing.get_cookie_signer(salt=key + salt).unsign(
cookie_value, max_age=max_age)
except signing.BadSignature:
if default is not RAISE_ERROR:
return default
else:
raise
return value
def get_raw_uri(self):
"""
Return an absolute URI from variables available in this request. Skip
allowed hosts protection, so may return insecure URI.
"""
return '{scheme}://{host}{path}'.format(
scheme=self.scheme,
host=self._get_raw_host(),
path=self.get_full_path(),
)
def build_absolute_uri(self, location=None):
"""
Builds an absolute URI from the location and the variables available in
this request. If no ``location`` is specified, the absolute URI is
built on ``request.get_full_path()``. Anyway, if the location is
absolute, it is simply converted to an RFC 3987 compliant URI and
returned and if location is relative or is scheme-relative (i.e.,
``//example.com/``), it is urljoined to a base URL constructed from the
request variables.
"""
if location is None:
# Make it an absolute url (but schemeless and domainless) for the
# edge case that the path starts with '//'.
location = '//%s' % self.get_full_path()
bits = urlsplit(location)
if not (bits.scheme and bits.netloc):
current_uri = '{scheme}://{host}{path}'.format(scheme=self.scheme,
host=self.get_host(),
path=self.path)
# Join the constructed URL with the provided location, which will
# allow the provided ``location`` to apply query strings to the
# base path as well as override the host, if it begins with //
location = urljoin(current_uri, location)
return iri_to_uri(location)
def _get_scheme(self):
"""
Hook for subclasses like WSGIRequest to implement. Returns 'http' by
default.
"""
return 'http'
@property
def scheme(self):
if settings.SECURE_PROXY_SSL_HEADER:
try:
header, value = settings.SECURE_PROXY_SSL_HEADER
except ValueError:
raise ImproperlyConfigured(
'The SECURE_PROXY_SSL_HEADER setting must be a tuple containing two values.'
)
if self.META.get(header) == value:
return 'https'
return self._get_scheme()
def is_secure(self):
return self.scheme == 'https'
def is_ajax(self):
return self.META.get('HTTP_X_REQUESTED_WITH') == 'XMLHttpRequest'
@property
def encoding(self):
return self._encoding
@encoding.setter
def encoding(self, val):
"""
Sets the encoding used for GET/POST accesses. If the GET or POST
dictionary has already been created, it is removed and recreated on the
next access (so that it is decoded correctly).
"""
self._encoding = val
if hasattr(self, 'GET'):
del self.GET
if hasattr(self, '_post'):
del self._post
def _initialize_handlers(self):
self._upload_handlers = [uploadhandler.load_handler(handler, self)
for handler in settings.FILE_UPLOAD_HANDLERS]
@property
def upload_handlers(self):
if not self._upload_handlers:
# If there are no upload handlers defined, initialize them from settings.
self._initialize_handlers()
return self._upload_handlers
@upload_handlers.setter
def upload_handlers(self, upload_handlers):
if hasattr(self, '_files'):
raise AttributeError("You cannot set the upload handlers after the upload has been processed.")
self._upload_handlers = upload_handlers
def parse_file_upload(self, META, post_data):
"""Returns a tuple of (POST QueryDict, FILES MultiValueDict)."""
self.upload_handlers = ImmutableList(
self.upload_handlers,
warning="You cannot alter upload handlers after the upload has been processed."
)
parser = MultiPartParser(META, post_data, self.upload_handlers, self.encoding)
return parser.parse()
@property
def body(self):
if not hasattr(self, '_body'):
if self._read_started:
raise RawPostDataException("You cannot access body after reading from request's data stream")
# Limit the maximum request data size that will be handled in-memory.
if (settings.DATA_UPLOAD_MAX_MEMORY_SIZE is not None and
int(self.META.get('CONTENT_LENGTH') or 0) > settings.DATA_UPLOAD_MAX_MEMORY_SIZE):
raise RequestDataTooBig('Request body exceeded settings.DATA_UPLOAD_MAX_MEMORY_SIZE.')
try:
self._body = self.read()
except IOError as e:
six.reraise(UnreadablePostError, UnreadablePostError(*e.args), sys.exc_info()[2])
self._stream = BytesIO(self._body)
return self._body
def _mark_post_parse_error(self):
self._post = QueryDict()
self._files = MultiValueDict()
self._post_parse_error = True
def _load_post_and_files(self):
"""Populate self._post and self._files if the content-type is a form type"""
if self.method != 'POST':
self._post, self._files = QueryDict(encoding=self._encoding), MultiValueDict()
return
if self._read_started and not hasattr(self, '_body'):
self._mark_post_parse_error()
return
if self.content_type == 'multipart/form-data':
if hasattr(self, '_body'):
# Use already read data
data = BytesIO(self._body)
else:
data = self
try:
self._post, self._files = self.parse_file_upload(self.META, data)
except MultiPartParserError:
# An error occurred while parsing POST data. Since when
# formatting the error the request handler might access
# self.POST, set self._post and self._file to prevent
# attempts to parse POST data again.
# Mark that an error occurred. This allows self.__repr__ to
# be explicit about it instead of simply representing an
# empty POST
self._mark_post_parse_error()
raise
elif self.content_type == 'application/x-www-form-urlencoded':
self._post, self._files = QueryDict(self.body, encoding=self._encoding), MultiValueDict()
else:
self._post, self._files = QueryDict(encoding=self._encoding), MultiValueDict()
def close(self):
if hasattr(self, '_files'):
for f in chain.from_iterable(l[1] for l in self._files.lists()):
f.close()
# File-like and iterator interface.
#
# Expects self._stream to be set to an appropriate source of bytes by
# a corresponding request subclass (e.g. WSGIRequest).
# Also when request data has already been read by request.POST or
# request.body, self._stream points to a BytesIO instance
# containing that data.
def read(self, *args, **kwargs):
self._read_started = True
try:
return self._stream.read(*args, **kwargs)
except IOError as e:
six.reraise(UnreadablePostError, UnreadablePostError(*e.args), sys.exc_info()[2])
def readline(self, *args, **kwargs):
self._read_started = True
try:
return self._stream.readline(*args, **kwargs)
except IOError as e:
six.reraise(UnreadablePostError, UnreadablePostError(*e.args), sys.exc_info()[2])
def xreadlines(self):
while True:
buf = self.readline()
if not buf:
break
yield buf
__iter__ = xreadlines
def readlines(self):
return list(iter(self))
class QueryDict(MultiValueDict):
"""
A specialized MultiValueDict which represents a query string.
A QueryDict can be used to represent GET or POST data. It subclasses
MultiValueDict since keys in such data can be repeated, for instance
in the data from a form with a