django-hstore-1.5~alpha~git20161126+dfsg/ 0000775 0001750 0001750 00000000000 13016364461 020223 5 ustar kitterma kitterma django-hstore-1.5~alpha~git20161126+dfsg/setup.py 0000664 0001750 0001750 00000004670 13016340771 021742 0 ustar kitterma kitterma import os
import sys
from setuptools import setup
from django_hstore import get_version
if sys.argv[-1] == 'publish':
os.system("python setup.py sdist bdist_wheel upload -s")
args = {'version': get_version()}
print("You probably want to also tag the version now:")
print(" git tag -a %(version)s -m 'version %(version)s'" % args)
print(" git push --tags")
sys.exit()
def get_packages(package):
"""
Return root package and all sub-packages.
"""
return [dirpath
for dirpath, dirnames, filenames in os.walk(package)
if os.path.exists(os.path.join(dirpath, '__init__.py'))]
def get_package_data(package):
"""
Return all files under the root package, that are not in a
package themselves.
"""
walk = [(dirpath.replace(package + os.sep, '', 1), filenames)
for dirpath, dirnames, filenames in os.walk(package)
if not os.path.exists(os.path.join(dirpath, '__init__.py'))]
filepaths = []
for base, filenames in walk:
filepaths.extend([os.path.join(base, filename)
for filename in filenames])
return {package: filepaths}
setup(
name='django-hstore',
version=get_version(),
description='PostgreSQL HStore support for Django',
long_description=open('README.rst').read(),
author='Jordan McCoy',
maintainer='Djangonauts Organization',
maintainer_email='django-hstore@googlegroups.com',
license='BSD',
url='https://github.com/djangonauts/django-hstore',
download_url='https://github.com/djangonauts/django-hstore/releases',
platforms=['Platform Indipendent'],
keywords=['django', 'hstore', 'schemaless'],
packages=get_packages('django_hstore'),
package_data=get_package_data('django_hstore'),
zip_safe=False,
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Framework :: Django',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
],
)
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/ 0000775 0001750 0001750 00000000000 13016364461 023051 5 ustar kitterma kitterma django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/__init__.py 0000664 0001750 0001750 00000000673 13016340771 025166 0 ustar kitterma kitterma VERSION = (1, 5, 0, 'alpha')
__version__ = VERSION
def get_version():
version = '%s.%s' % (VERSION[0], VERSION[1])
if VERSION[2]:
version = '%s.%s' % (version, VERSION[2])
if VERSION[3:] == ('alpha', 0):
version = '%s pre-alpha' % version
else:
if VERSION[3] != 'final':
version = '%s %s' % (version, VERSION[3])
return version
default_app_config = 'django_hstore.apps.HStoreConfig'
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/managers.py 0000664 0001750 0001750 00000002177 13016340771 025225 0 ustar kitterma kitterma from __future__ import unicode_literals, absolute_import
from django.db import models
from django_hstore.query import HStoreQuerySet
from django_hstore.apps import GEODJANGO_INSTALLED
class HStoreManager(models.Manager):
"""
Object manager which enables hstore features.
"""
use_for_related_fields = True
def get_queryset(self):
return HStoreQuerySet(self.model, using=self._db)
get_query_set = get_queryset
def hkeys(self, attr, **params):
return self.filter(**params).hkeys(attr)
def hpeek(self, attr, key, **params):
return self.filter(**params).hpeek(attr, key)
def hslice(self, attr, keys, **params):
return self.filter(**params).hslice(attr, keys)
if GEODJANGO_INSTALLED:
from django.contrib.gis.db import models as geo_models
from django_hstore.query import HStoreGeoQuerySet
class HStoreGeoManager(geo_models.GeoManager, HStoreManager):
"""
Object manager combining Geodjango and hstore.
"""
def get_queryset(self):
return HStoreGeoQuerySet(self.model, using=self._db)
get_query_set = get_queryset
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/exceptions.py 0000664 0001750 0001750 00000000465 13016340771 025607 0 ustar kitterma kitterma from __future__ import unicode_literals, absolute_import
class HStoreDictException(Exception):
json_error_message = None
def __init__(self, *args, **kwargs):
self.json_error_message = kwargs.pop('json_error_message', None)
super(HStoreDictException, self).__init__(*args, **kwargs)
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/static/ 0000775 0001750 0001750 00000000000 13016364461 024340 5 ustar kitterma kitterma django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/static/admin/ 0000775 0001750 0001750 00000000000 13016364461 025430 5 ustar kitterma kitterma django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/static/admin/js/ 0000775 0001750 0001750 00000000000 13016364461 026044 5 ustar kitterma kitterma django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/static/admin/js/django_hstore/ 0000775 0001750 0001750 00000000000 13016400224 030656 5 ustar kitterma kitterma ././@LongLink 0000644 0000000 0000000 00000000146 00000000000 011604 L ustar root root django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/static/admin/js/django_hstore/hstore-widget.js django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/static/admin/js/django_hstore/hstore-widget.j0000664 0001750 0001750 00000015752 13016340771 033642 0 ustar kitterma kitterma var initDjangoHStoreWidget = function(hstore_field_name, inline_prefix) {
// ignore inline templates
// if hstore_field_name contains "__prefix__"
if(hstore_field_name.indexOf('__prefix__') > -1){
return;
}
var $ = django.jQuery;
// processing inlines
if(hstore_field_name.indexOf('inline') > -1){
var inlineClass = $('#id_'+hstore_field_name).parents('.inline-related, .grp-group').attr('class');
// if using TabularInlines stop here
// TabularInlines not supported
if (inlineClass.indexOf('tabular') > -1) {
return;
}
}
// reusable function that retrieves a template even if ID is not correct
// (written to support inlines)
var retrieveTemplate = function(template_name, field_name){
var specific_template = $('#'+template_name+'-'+field_name);
// if found specific template return that
if(specific_template.length){
return specific_template.html();
}
else{
// get fallback template
var html = $('.'+template_name+'-inline').html();
// replace all occurrences of __prefix__ with field_name
// and return
html = html.replace(/__prefix__/g, inline_prefix);
return html;
}
}
// reusable function that compiles the UI
var compileUI = function(params){
var hstore_field_id = 'id_'+hstore_field_name,
original_textarea = $('#'+hstore_field_id),
original_value = original_textarea.val(),
original_container = original_textarea.parents('.form-row, .grp-row').eq(0),
errorHtml = original_container.find('.errorlist').html(),
json_data = {};
if(original_value !== ''){
// manage case in which textarea is blank
try{
json_data = JSON.parse(original_value);
}
catch(e){
alert('invalid JSON:\n'+e);
return false;
}
}
var hstore_field_data = {
"id": hstore_field_id,
"label": original_container.find('label').text(),
"name": hstore_field_name,
"value": original_textarea.val(),
"help": original_container.find('.grp-help, .help').text(),
"errors": errorHtml,
"data": json_data
},
// compile template
ui_html = retrieveTemplate('hstore-ui-template', hstore_field_name),
compiled_ui_html = _.template(ui_html, hstore_field_data);
// this is just to DRY up a bit
if(params && params.replace_original === true){
// remove original textarea to avoid having two textareas with same ID
original_textarea.remove();
// inject compiled template and hide original
original_container.after(compiled_ui_html).hide();
}
return compiled_ui_html;
};
// generate UI
compileUI({ replace_original: true });
// cache other objects that we'll reuse
var row_html = retrieveTemplate('hstore-row-template', hstore_field_name),
empty_row = _.template(row_html, { 'key': '', 'value': '' }),
$hstore = $('#id_'+hstore_field_name).parents('.hstore');
// reusable function that updates the textarea value
var updateTextarea = function(container) {
// init empty json object
var new_value = {},
raw_textarea = container.find('textarea'),
rows = container.find('.form-row, .grp-row');
// loop over each object and populate json
rows.each(function() {
var inputs = $(this).find('input'),
key = inputs.eq(0).val(),
value = inputs.eq(1).val();
new_value[key] = value;
});
// update textarea value
$(raw_textarea).val(JSON.stringify(new_value, null, 4));
};
// remove row link
$hstore.delegate('a.remove-row', 'click', function(e) {
e.preventDefault();
// cache container jquery object before $(this) gets removed
$(this).parents('.form-row, .grp-row').eq(0).remove();
updateTextarea($hstore);
});
// add row link
$hstore.delegate('a.hs-add-row, .hs-add-row a', 'click', function(e) {
e.preventDefault();
$hstore.find('.hstore-rows').append(empty_row);
});
// toggle textarea link
$hstore.delegate('.hstore-toggle-txtarea', 'click', function(e) {
e.preventDefault();
var raw_textarea = $hstore.find('.hstore-textarea'),
hstore_rows = $hstore.find('.hstore-rows'),
add_row = $hstore.find('.hs-add-row');
if(raw_textarea.is(':visible')) {
var compiled_ui = compileUI();
// in case of JSON error
if(compiled_ui === false){
return;
}
// jquery < 1.8
try{
var $ui = $(compiled_ui);
}
// jquery >= 1.8
catch(e){
var $ui = $($.parseHTML(compiled_ui));
}
// update rows with only relevant content
hstore_rows.html($ui.find('.hstore-rows').html());
raw_textarea.hide();
hstore_rows.show();
add_row.show();
}
else{
raw_textarea.show();
hstore_rows.hide();
add_row.hide();
}
});
// update textarea whenever a field changes
$hstore.delegate('input[type=text]', 'keyup', function() {
updateTextarea($hstore);
});
};
django.jQuery(window).load(function() {
// support inlines
// bind only once
if(django.hstoreWidgetBoundInlines === undefined){
var $ = django.jQuery;
$('.grp-group .grp-add-handler, .inline-group .hs-add-row a, .inline-group .add-row').click(function(e){
var hstore_original_textareas = $(this).parents('.grp-group, .inline-group').eq(0).find('.hstore-original-textarea');
// if module contains .hstore-original-textarea
if(hstore_original_textareas.length > 0){
// loop over each inline
$(this).parents('.grp-group, .inline-group').find('.grp-items div.grp-dynamic-form, .inline-related').each(function(e, i){
var prefix = i;
// loop each textarea
$(this).find('.hstore-original-textarea').each(function(e, i){
// cache field name
var field_name = $(this).attr('name');
// ignore templates
// if name attribute contains __prefix__
if(field_name.indexOf('prefix') > -1){
// skip to next
return;
}
initDjangoHStoreWidget(field_name, prefix);
});
});
}
});
django.hstoreWidgetBoundInlines = true;
}
});
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/templates/ 0000775 0001750 0001750 00000000000 13016364461 025047 5 ustar kitterma kitterma django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/templates/hstore_default_widget.html 0000664 0001750 0001750 00000005511 13016340771 032310 0 ustar kitterma kitterma {% load i18n %}
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/templates/hstore_grappelli_widget.html 0000664 0001750 0001750 00000005234 13016340771 032645 0 ustar kitterma kitterma {% load i18n %}
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/forms.py 0000664 0001750 0001750 00000010126 13016340771 024547 0 ustar kitterma kitterma from __future__ import unicode_literals, absolute_import
import json
from django.forms import Field
from django.utils import six
from django.utils.translation import ugettext
from django.core.exceptions import ValidationError
from .widgets import AdminHStoreWidget
from . import utils
def validate_hstore(value, is_serialized=False):
""" HSTORE validation. """
# if empty
if value is None or value == '' or value == 'null':
value = '{}'
# ensure valid JSON
try:
# convert strings to dictionaries
if isinstance(value, six.string_types):
dictionary = json.loads(value)
# if serialized field, deserialize values
if is_serialized and isinstance(dictionary, dict):
dictionary = dict((k, json.loads(v)) for k, v in dictionary.items()) # TODO: modify to use field's deserializer
# if not a string we'll check at the next control if it's a dict
else:
dictionary = value
except ValueError as e:
raise ValidationError(ugettext(u'Invalid JSON: {0}').format(e))
# ensure is a dictionary
if not isinstance(dictionary, dict):
raise ValidationError(ugettext(u'No lists or values allowed, only dictionaries'))
# convert any non string object into string
for key, value in dictionary.items():
if isinstance(value, dict) or isinstance(value, list):
dictionary[key] = json.dumps(value)
if isinstance(value, bool) or isinstance(value, int) or isinstance(value, float):
if not is_serialized: # Only convert if not from serializedfield
dictionary[key] = six.text_type(value).lower()
return dictionary
class JsonMixin(object):
def to_python(self, value):
return validate_hstore(value)
def render(self, name, value, attrs=None):
# return json representation of a meaningful value
# doesn't show anything for None, empty strings or empty dictionaries
if value and not isinstance(value, six.string_types):
value = json.dumps(value, sort_keys=True, indent=4)
return super(JsonMixin, self).render(name, value, attrs)
class SerializedJsonMixin(JsonMixin):
def to_python(self, value):
return validate_hstore(value, is_serialized=True)
def render(self, name, value, attrs=None):
if isinstance(value, dict):
value = dict((k, json.dumps(v)) for k, v in value.items()) # TODO: Modify to use field's serializer
# return json representation of a meaningful value
# doesn't show anything for None, empty strings or empty dictionaries
if value and not isinstance(value, six.string_types):
value = json.dumps(value, sort_keys=True, indent=4)
return super(SerializedJsonMixin, self).render(name, value, attrs)
class DictionaryFieldWidget(JsonMixin, AdminHStoreWidget):
pass
class SerializedDictionaryFieldWidget(SerializedJsonMixin, AdminHStoreWidget):
pass
class ReferencesFieldWidget(JsonMixin, AdminHStoreWidget):
def render(self, name, value, attrs=None):
value = utils.serialize_references(value)
return super(ReferencesFieldWidget, self).render(name, value, attrs)
class DictionaryField(JsonMixin, Field):
"""
A dictionary form field.
"""
def __init__(self, **params):
params['widget'] = params.get('widget', DictionaryFieldWidget)
super(DictionaryField, self).__init__(**params)
class SerializedDictionaryField(SerializedJsonMixin, Field):
"""
Serialized dictionary field.
"""
def __init__(self, **params):
params['widget'] = params.get('widget', SerializedDictionaryFieldWidget)
super(SerializedDictionaryField, self).__init__(**params)
class ReferencesField(JsonMixin, Field):
"""
A references form field.
"""
def __init__(self, **params):
params['widget'] = params.get('widget', ReferencesFieldWidget)
super(ReferencesField, self).__init__(**params)
def to_python(self, value):
value = super(ReferencesField, self).to_python(value)
return utils.unserialize_references(value)
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/utils.py 0000664 0001750 0001750 00000005060 13016340771 024562 0 ustar kitterma kitterma from __future__ import unicode_literals, absolute_import
from decimal import Decimal
from datetime import date, time, datetime
from django.core.exceptions import ObjectDoesNotExist
from django.utils import six
def acquire_reference(reference):
try:
model, identifier = reference.split(':')
module, sep, attr = model.rpartition('.')
model = getattr(__import__(module, fromlist=(attr,)), attr)
return model.objects.get(pk=identifier)
except ObjectDoesNotExist:
return None
except Exception:
raise ValueError
def identify_instance(instance):
model = type(instance)
return '%s.%s:%s' % (model.__module__, model.__name__, instance.pk)
def serialize_references(references):
refs = {}
# if None or string return empty dict
if references is None or isinstance(references, six.string_types):
return {}
# if dictionary do serialization
elif isinstance(references, dict):
for key, instance in references.items():
if not isinstance(instance, six.string_types):
refs[key] = identify_instance(instance)
else:
refs[key] = instance
else:
return refs
# else just return the object, might be doing some other operation and we don't want to interfere
else:
return references
def unserialize_references(references):
refs = {}
if references is None:
return refs
for key, reference in references.items():
if isinstance(reference, six.string_types):
refs[key] = acquire_reference(reference)
else:
refs[key] = reference
else:
return refs
def get_cast_for_param(value_annot, key):
if not isinstance(value_annot, dict):
return ''
if value_annot[key] in (True, False):
return '::boolean'
elif issubclass(value_annot[key], datetime):
return '::timestamp'
elif issubclass(value_annot[key], date):
return '::date'
elif issubclass(value_annot[key], time):
return '::time'
elif issubclass(value_annot[key], six.integer_types):
return '::bigint'
elif issubclass(value_annot[key], float):
return '::float8'
elif issubclass(value_annot[key], Decimal):
return '::numeric'
else:
return ''
def get_value_annotations(param):
# We need to store the actual value for booleans, not just the type, for isnull
get_type = lambda v: v if isinstance(v, bool) else type(v)
return dict((key, get_type(subvalue)) for key, subvalue in six.iteritems(param))
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/models.py 0000664 0001750 0001750 00000000072 13016340771 024703 0 ustar kitterma kitterma import django
from .fields import DictionaryField # noqa
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/dict.py 0000664 0001750 0001750 00000012401 13016340771 024342 0 ustar kitterma kitterma import json
from decimal import Decimal
from django.utils import six
from django.utils.encoding import force_text, force_str
from .compat import UnicodeMixin
from . import utils, exceptions
__all__ = [
'HStoreDict',
'HStoreReferenceDict',
]
class DecimalEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, Decimal):
return float(obj)
return json.JSONEncoder.default(self, obj)
class HStoreDict(UnicodeMixin, dict):
"""
A dictionary subclass which implements hstore support.
"""
schema_mode = False # python2.6 compatibility
def __init__(self, value=None, field=None, instance=None, schema_mode=False, **kwargs):
self.schema_mode = schema_mode
# if passed value is string
# ensure is json formatted
if isinstance(value, six.string_types):
try:
value = json.loads(value)
except ValueError as e:
raise exceptions.HStoreDictException(
'HStoreDict accepts only valid json formatted strings.',
json_error_message=force_text(e)
)
elif value is None:
value = {}
# allow dictionaries only
if not isinstance(value, dict):
raise exceptions.HStoreDictException(
'HStoreDict accepts only dictionary objects, None and json formatted string representations of json objects'
)
if not self.schema_mode:
# ensure values are acceptable
for key, val in value.items():
value[key] = self.ensure_acceptable_value(val)
super(HStoreDict, self).__init__(value, **kwargs)
self.field = field
self.instance = instance
def __setitem__(self, *args, **kwargs):
"""
perform checks before setting the value of a key
"""
# ensure values are acceptable
value = self.ensure_acceptable_value(args[1])
# prepare *args
args = (args[0], value)
super(HStoreDict, self).__setitem__(*args, **kwargs)
def __getitem__(self, *args, **kwargs):
"""
retrieve value preserving type if in schema mode, string only otherwise
"""
value = super(HStoreDict, self).__getitem__(*args, **kwargs)
if self.schema_mode:
try:
return self.instance._hstore_virtual_fields[args[0]].to_python(value)
except KeyError:
pass
return value
def get(self, *args):
key = args[0]
try:
return self.__getitem__(key)
except KeyError:
if len(args) > 1:
return args[1] # return default value
else:
return None
# This method is used both for python3 and python2
# thanks to UnicodeMixin
def __unicode__(self):
return force_text(json.dumps(self))
def __getstate__(self):
return self.__dict__
def __copy__(self):
return self.__class__(self, self.field)
def update(self, *args, **kwargs):
for key, value in dict(*args, **kwargs).items():
self[key] = value
def ensure_acceptable_value(self, value):
"""
if schema_mode disabled (default behaviour):
- ensure booleans, integers, floats, Decimals, lists and dicts are
converted to string
- convert True and False objects to "true" and "false" so they can be
decoded back with the json library if needed
- convert lists and dictionaries to json formatted strings
- leave alone all other objects because they might be representation of django models
else:
- encode utf8 strings in python2
- convert to string
"""
if not self.schema_mode:
if isinstance(value, bool):
return force_text(value).lower()
elif isinstance(value, six.integer_types + (float, Decimal)):
return force_text(value)
elif isinstance(value, (list, dict)):
return force_text(json.dumps(value, cls=DecimalEncoder))
else:
return value
else:
# perform string conversion unless is None
if value is not None:
value = force_str(value)
return value
def remove(self, keys):
"""
Removes the specified keys from this dictionary.
"""
queryset = self.instance._base_manager.get_query_set()
queryset.filter(pk=self.instance.pk).hremove(self.field.name, keys)
class HStoreReferenceDict(HStoreDict):
"""
A dictionary which adds support to storing references to models
"""
def __getitem__(self, *args, **kwargs):
value = super(self.__class__, self).__getitem__(*args, **kwargs)
# if value is a string it needs to be converted to model instance
if isinstance(value, six.string_types):
reference = utils.acquire_reference(value)
self.__setitem__(args[0], reference)
return reference
# otherwise just return the relation
return value
def get(self, key, default=None):
try:
return self.__getitem__(key)
except KeyError:
return default
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/query.py 0000664 0001750 0001750 00000025263 13016340771 024576 0 ustar kitterma kitterma from __future__ import absolute_import, unicode_literals
import django
from django.db import transaction
from django.db.models.query import QuerySet
from django.db.models.query_utils import QueryWrapper
from django.db.models.sql.constants import SINGLE
from django.db.models.sql.datastructures import EmptyResultSet
from django.db.models.sql.query import Query
from django.db.models.sql.subqueries import UpdateQuery
from django.db.models.sql.where import WhereNode
from django.utils import six
from django_hstore.apps import GEODJANGO_INSTALLED
from django_hstore.utils import get_cast_for_param, get_value_annotations
try:
# django <= 1.8
from django.db.models.sql.where import EmptyShortCircuit
except ImportError:
# django >= 1.9
EmptyShortCircuit = Exception
def get_field(self, name):
if django.VERSION >= (1, 8):
return self.model._meta.get_field(name)
else:
return self.model._meta.get_field_by_name(name)[0]
def select_query(method):
def selector(self, *args, **params):
query = self.query.clone()
query.default_cols = False
query.clear_select_fields()
return method(self, query, *args, **params)
return selector
def update_query(method):
def updater(self, *args, **params):
self._for_write = True
query = method(self, self.query.clone(UpdateQuery), *args, **params)
with transaction.atomic(using=self.db):
rows = query.get_compiler(self.db).execute_sql(None)
self._result_cache = None
return rows
updater.alters_data = True
return updater
class HStoreWhereNode(WhereNode):
def add(self, data, *args, **kwargs):
# WhereNode will convert params into strings, so we need to record
# the type of the params as part of the value_annotation before calling
# the super class
if not isinstance(data, (list, tuple)):
return super(HStoreWhereNode, self).add(data, *args, **kwargs)
original_value = data[2]
if isinstance(original_value, dict):
len_children = len(self.children) if self.children else 0
value_annot = get_value_annotations(original_value)
# We should be able to get the normal child node here, but it is not returned in Django 1.5
super(HStoreWhereNode, self).add(data, *args, **kwargs)
# We also need to place the type annotation into self.children
# It will either be the last item in the last child, or be the last child
# We can tell which by comparing the lengths before and after calling the super method
if len_children < len(self.children):
child = self.children[-1]
obj, lookup_type, _, value = child
annotated_child = (obj, lookup_type, value_annot, value)
self.children[-1] = annotated_child
else:
child = self.children[-1][-1]
obj, lookup_type, _, value = child
annotated_child = (obj, lookup_type, value_annot, value)
self.children[-1][-1] = annotated_child
else:
return super(HStoreWhereNode, self).add(data, *args, **kwargs)
# FIXME: this method shuld be more clear.
def make_atom(self, child, qn, connection):
lvalue, lookup_type, value_annot, param = child
kwargs = {'connection': connection}
if lvalue and lvalue.field and hasattr(lvalue.field, 'db_type') and lvalue.field.db_type(**kwargs) == 'hstore':
try:
lvalue, params = lvalue.process(lookup_type, param, connection)
except EmptyShortCircuit:
raise EmptyResultSet()
field = self.sql_for_columns(lvalue, qn, connection)
if lookup_type == 'exact':
if isinstance(param, dict):
return ('{0} = %s'.format(field), [param])
raise ValueError('invalid value')
elif lookup_type in ('gt', 'gte', 'lt', 'lte'):
if isinstance(param, dict):
sign = (lookup_type[0] == 'g' and '>%s' or '<%s') % (lookup_type[-1] == 'e' and '=' or '')
param_keys = list(param.keys())
conditions = []
for key in param_keys:
cast = get_cast_for_param(value_annot, key)
conditions.append('(%s->\'%s\')%s %s %%s' % (field, key, cast, sign))
return (" AND ".join(conditions), param.values())
raise ValueError('invalid value')
elif lookup_type in ['contains', 'icontains']:
if isinstance(param, dict):
values = list(param.values())
keys = list(param.keys())
if len(values) == 1 and isinstance(values[0], (list, tuple)):
# Can't cast here because the list could contain multiple types
return ('%s->\'%s\' = ANY(%%s)' % (field, keys[0]), [[str(x) for x in values[0]]])
elif len(keys) == 1 and len(values) == 1:
# Retrieve key and compare to param instead of using '@>' in order to cast hstore value
cast = get_cast_for_param(value_annot, keys[0])
return ('(%s->\'%s\')%s = %%s' % (field, keys[0], cast), [values[0]])
return ('%s @> %%s' % field, [param])
elif isinstance(param, (list, tuple)):
if len(param) == 0:
raise ValueError('invalid value')
if len(param) < 2:
return ('%s ? %%s' % field, [param[0]])
if param:
return ('%s ?& %%s' % field, [param])
raise ValueError('invalid value')
elif isinstance(param, six.string_types):
# if looking for a string perform the normal text lookup
# that is: look for occurence of string in all the keys
pass
elif hasattr(child[0].field, 'serializer'):
try:
child[0].field._serialize_value(param)
pass
except Exception:
raise ValueError('invalid value')
else:
raise ValueError('invalid value')
elif lookup_type == 'isnull':
if isinstance(param, dict):
param_keys = list(param.keys())
conditions = []
for key in param_keys:
op = 'IS NULL' if value_annot[key] else 'IS NOT NULL'
conditions.append('(%s->\'%s\') %s' % (field, key, op))
return (" AND ".join(conditions), [])
# do not perform any special format
return super(HStoreWhereNode, self).make_atom(child, qn, connection)
else:
raise TypeError('invalid lookup type')
return super(HStoreWhereNode, self).make_atom(child, qn, connection)
make_hstore_atom = make_atom
class HStoreQuery(Query):
def __init__(self, model):
super(HStoreQuery, self).__init__(model, HStoreWhereNode)
class HStoreQuerySet(QuerySet):
def __init__(self, model=None, query=None, using=None, *args, **kwargs):
query = query or HStoreQuery(model)
super(HStoreQuerySet, self).__init__(model=model, query=query, using=using, *args, **kwargs)
@select_query
def hkeys(self, query, attr):
"""
Enumerates the keys in the specified hstore.
"""
query.add_extra({'_': 'akeys("%s")' % attr}, None, None, None, None, None)
result = query.get_compiler(self.db).execute_sql(SINGLE)
return (result[0] if result else [])
@select_query
def hpeek(self, query, attr, key):
"""
Peeks at a value of the specified key.
"""
query.add_extra({'_': '%s -> %%s' % attr}, [key], None, None, None, None)
result = query.get_compiler(self.db).execute_sql(SINGLE)
if result and result[0]:
field = get_field(self, attr)
return field._value_to_python(result[0])
@select_query
def hslice(self, query, attr, keys):
"""
Slices the specified key/value pairs.
"""
query.add_extra({'_': 'slice("%s", %%s)' % attr}, [keys], None, None, None, None)
result = query.get_compiler(self.db).execute_sql(SINGLE)
if result and result[0]:
field = get_field(self, attr)
return dict((key, field._value_to_python(value)) for key, value in result[0].items())
return {}
@update_query
def hremove(self, query, attr, keys):
"""
Removes the specified keys in the specified hstore.
"""
value = QueryWrapper('delete("%s", %%s)' % attr, [keys])
field = get_field(self, attr)
query.add_update_fields([(field, None, value)])
return query
@update_query
def hupdate(self, query, attr, updates):
"""
Updates the specified hstore.
"""
field = get_field(self, attr)
if hasattr(field, 'serializer'):
updates = field.get_prep_value(updates)
value = QueryWrapper('"%s" || %%s' % attr, [updates])
query.add_update_fields([(field, None, value)])
return query
if GEODJANGO_INSTALLED:
from django.contrib.gis.db.models.query import GeoQuerySet
if django.VERSION[:2] <= (1, 7):
from django.contrib.gis.db.models.sql.query import GeoQuery
from django.contrib.gis.db.models.sql.where import GeoWhereNode, GeoConstraint
class HStoreGeoWhereNode(HStoreWhereNode, GeoWhereNode):
def make_atom(self, child, qn, connection):
lvalue, lookup_type, value_annot, params_or_value = child
# if spatial query
if isinstance(lvalue, GeoConstraint):
return GeoWhereNode.make_atom(self, child, qn, connection)
# else might be an HSTORE query
return HStoreWhereNode.make_atom(self, child, qn, connection)
class HStoreGeoQuery(GeoQuery, Query):
def __init__(self, *args, **kwargs):
model = kwargs.pop('model', None) or args[0]
super(HStoreGeoQuery, self).__init__(model, HStoreGeoWhereNode)
class HStoreGeoQuerySet(HStoreQuerySet, GeoQuerySet):
def __init__(self, model=None, query=None, using=None, **kwargs):
query = query or HStoreGeoQuery(model)
super(HStoreGeoQuerySet, self).__init__(model=model, query=query, using=using, **kwargs)
else:
class HStoreGeoQuerySet(HStoreQuerySet, GeoQuerySet):
pass
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/lookups.py 0000664 0001750 0001750 00000011327 13016340771 025121 0 ustar kitterma kitterma from __future__ import unicode_literals, absolute_import
from django.utils import six
from django.db.models.lookups import (
GreaterThan,
GreaterThanOrEqual,
LessThan,
LessThanOrEqual,
Contains,
IContains,
IsNull
)
from django_hstore.utils import get_cast_for_param, get_value_annotations
__all__ = [
'HStoreComparisonLookupMixin',
'HStoreGreaterThan',
'HStoreGreaterThanOrEqual',
'HStoreLessThan',
'HStoreLessThanOrEqual',
'HStoreContains',
'HStoreIContains',
'HStoreIsNull'
]
class HStoreLookupMixin(object):
def __init__(self, lhs, rhs, *args, **kwargs):
# We need to record the types of the rhs parameters before they are converted to strings
if isinstance(rhs, dict):
self.value_annot = get_value_annotations(rhs)
super(HStoreLookupMixin, self).__init__(lhs, rhs)
class HStoreComparisonLookupMixin(HStoreLookupMixin):
"""
Mixin for hstore comparison custom lookups.
"""
def as_postgresql(self, compiler, connection):
lhs, lhs_params = self.process_lhs(compiler, connection)
rhs, rhs_params = self.process_rhs(compiler, connection)
if len(rhs_params) == 1 and isinstance(rhs_params[0], dict):
param = rhs_params[0]
sign = (self.lookup_name[0] == 'g' and '>%s' or '<%s') % (self.lookup_name[-1] == 'e' and '=' or '')
param_keys = list(param.keys())
conditions = []
for key in param_keys:
cast = get_cast_for_param(self.value_annot, key)
conditions.append('(%s->\'%s\')%s %s %%s' % (lhs, key, cast, sign))
return (" AND ".join(conditions), param.values())
raise ValueError('invalid value')
class HStoreGreaterThan(HStoreComparisonLookupMixin, GreaterThan):
pass
class HStoreGreaterThanOrEqual(HStoreComparisonLookupMixin, GreaterThanOrEqual):
pass
class HStoreLessThan(HStoreComparisonLookupMixin, LessThan):
pass
class HStoreLessThanOrEqual(HStoreComparisonLookupMixin, LessThanOrEqual):
pass
class HStoreContains(HStoreLookupMixin, Contains):
def as_postgresql(self, compiler, connection):
lhs, lhs_params = self.process_lhs(compiler, connection)
# FIXME: ::text cast is added by ``django.db.backends.postgresql_psycopg2.DatabaseOperations.lookup_cast``;
# maybe there's a cleaner way to fix the cast for hstore columns
if lhs.endswith('::text'):
lhs = '{0}{1}'.format(lhs[:-4], 'hstore')
param = self.rhs
if isinstance(param, dict):
values = list(param.values())
keys = list(param.keys())
if len(values) == 1 and isinstance(values[0], (list, tuple)):
# Can't cast here because the list could contain multiple types
return '%s->\'%s\' = ANY(%%s)' % (lhs, keys[0]), [[str(x) for x in values[0]]]
elif len(keys) == 1 and len(values) == 1:
# Retrieve key and compare to param instead of using '@>' in order to cast hstore value
cast = get_cast_for_param(self.value_annot, keys[0])
return ('(%s->\'%s\')%s = %%s' % (lhs, keys[0], cast), [values[0]])
return '%s @> %%s' % lhs, [param]
elif isinstance(param, (list, tuple)):
if len(param) == 0:
raise ValueError('invalid value')
if len(param) < 2:
return '%s ? %%s' % lhs, [param[0]]
if param:
return '%s ?& %%s' % lhs, [param]
elif isinstance(param, six.string_types):
# if looking for a string perform the normal text lookup
# that is: look for occurence of string in all the keys
pass
# needed for SerializedDictionaryField
elif hasattr(self.lhs.target, 'serializer'):
try:
self.lhs.target._serialize_value(param)
pass
except Exception:
raise ValueError('invalid value')
else:
raise ValueError('invalid value')
return super(HStoreContains, self).as_sql(compiler, connection)
class HStoreIContains(IContains, HStoreContains):
pass
class HStoreIsNull(IsNull):
def as_postgresql(self, compiler, connection):
lhs, lhs_params = self.process_lhs(compiler, connection)
if isinstance(self.rhs, dict):
param = self.rhs
param_keys = list(param.keys())
conditions = []
for key in param_keys:
op = 'IS NULL' if param[key] else 'IS NOT NULL'
conditions.append('(%s->\'%s\') %s' % (lhs, key, op))
return (" AND ".join(conditions), lhs_params)
return super(HStoreIsNull, self).as_sql(compiler, connection)
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/virtual.py 0000664 0001750 0001750 00000013643 13016340771 025116 0 ustar kitterma kitterma from django.db import models
from django.utils import six
from django.utils.functional import curry
from django import VERSION as DJANGO_VERSION
from .dict import HStoreDict
__all__ = [
'create_hstore_virtual_field',
'VirtualField'
]
class HStoreVirtualMixin(object):
"""
must be mixed-in with django fields
"""
concrete = False
def contribute_to_class(self, cls, name):
if self.choices:
setattr(cls, 'get_%s_display' % self.name,
curry(cls._get_FIELD_display, field=self))
self.attname = name
self.name = name
self.model = cls
# setting column as none will tell django to not consider this a concrete field
self.column = None
# Connect myself as the descriptor for this field
setattr(cls, name, self)
# add field to class
if DJANGO_VERSION[:2] >= (1, 8):
# virtual=True available since django 1.8
cls._meta.add_field(self, virtual=True)
else:
cls._meta.add_field(self)
# add also into virtual fields in order to support admin
cls._meta.virtual_fields.append(self)
def db_type(self, connection):
"""
returning None here will cause django to exclude this field
from the concrete field list (_meta.concrete_fields)
resulting in the fact that syncdb will skip this field when creating tables in PostgreSQL
"""
return None
def deconstruct(self, *args, **kwargs):
"""
specific for django 1.7 and greater (migration framework)
"""
name, path, args, kwargs = super(HStoreVirtualMixin, self).deconstruct(*args, **kwargs)
# the "to" key has been added to fix issue #103
# without it the command makemigrations fails
return (name, path, args, {'default': kwargs.get('default'), 'to': None})
# begin descriptor methods
def __get__(self, instance, instance_type=None):
"""
retrieve value from hstore dictionary
"""
if instance is None:
raise AttributeError('Can only be accessed via instance')
field = getattr(instance, self.hstore_field_name)
if not field:
return self.default
return field.get(self.name, self.default)
def __set__(self, instance, value):
"""
set value on hstore dictionary
"""
hstore_dictionary = getattr(instance, self.hstore_field_name)
if hstore_dictionary is None:
# init empty HStoreDict
setattr(instance, self.hstore_field_name, HStoreDict())
# reassign
hstore_dictionary = getattr(instance, self.hstore_field_name)
hstore_dictionary[self.name] = value
# end descriptor methods
class VirtualField(HStoreVirtualMixin, models.Field):
"""
dummy class, used by django 1.7 schema editor only
"""
def __init__(self, *args, **kwargs):
# --- begin workaround classes needed for #103 --- #
# https://github.com/djangonauts/django-hstore/issues/103
kwargs.pop('to', None)
super(VirtualField, self).__init__(*args, **kwargs)
class _Meta(object):
def __init__(self):
self.auto_created = False
# --- needed to avoid exception when repeating same migration --- #
self.app_label = 'django_hstore'
self.model_name = 'virtual'
# --- for backwards compatability with Django <= 1.7 --- #
self.object_name = self.model_name
class _Through(object):
def __init__(self):
self._meta = _Meta()
class _Rel(object):
def __init__(self):
self.to = self
self.through = _Through()
# --- needed to avoid exception when repeating same migration --- #
self._meta = _Meta()
# --- needed when creating migrations for the first time --- #
self.parent_link = False
self.rel = _Rel()
self.generate_reverse_relation = False
# --- end #103 --- #
def create_hstore_virtual_field(field_cls, kwargs, hstore_field_name):
"""
returns an instance of an HStore virtual field which is mixed-in
with the specified field class and initializated with the kwargs passed
"""
if isinstance(field_cls, six.string_types):
try:
BaseField = getattr(models, field_cls)
except AttributeError:
raise ValueError('specified class %s is not a standard django model field (couldn\'t find it in django.db.models)' % field_cls)
elif issubclass(field_cls, models.Field):
BaseField = field_cls
else:
raise ValueError('field must be either a django standard field or a subclass of django.db.models.Field')
class VirtualField(HStoreVirtualMixin, BaseField):
# keep basefield info (added for django-rest-framework-hstore)
__basefield__ = BaseField
VirtualField.hstore_field_name = hstore_field_name
# support DateTimeField
if BaseField == models.DateTimeField and (kwargs.get('null') or kwargs.get('blank')):
kwargs['default'] = None
# support Date and DateTime in django-rest-framework-hstore
if BaseField == models.DateTimeField or BaseField == models.DateField:
def value_to_string(self, obj):
val = self._get_val_from_obj(obj)
try:
return '' if val is None else val.isoformat()
except AttributeError:
return val
VirtualField.value_to_string = value_to_string
field = VirtualField(**kwargs)
if field.default == models.fields.NOT_PROVIDED:
field.default = ''
return field
# south compatibility, ignore virtual fields
try: # pragma no cover
from south.modelsinspector import add_ignored_fields
add_ignored_fields(["^django_hstore\.virtual\.VirtualField"])
except ImportError:
pass
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/hstore.py 0000664 0001750 0001750 00000000453 13016340771 024727 0 ustar kitterma kitterma from django_hstore.fields import DictionaryField, ReferencesField, SerializedDictionaryField # noqa
from django_hstore.managers import HStoreManager # noqa
from django_hstore.apps import GEODJANGO_INSTALLED
if GEODJANGO_INSTALLED:
from django_hstore.managers import HStoreGeoManager # noqa
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/apps.py 0000664 0001750 0001750 00000006233 13016340771 024370 0 ustar kitterma kitterma import sys
import django
from django.conf import settings
from django.db.backends.signals import connection_created
from django.apps import AppConfig
from psycopg2.extras import register_hstore
HSTORE_REGISTER_GLOBALLY = getattr(settings, "DJANGO_HSTORE_ADAPTER_REGISTRATION", "global") == "global"
CONNECTION_CREATED_SIGNAL_WEAKREF = bool(getattr(settings, "DJANGO_HSTORE_ADAPTER_SIGNAL_WEAKREF", False))
# This allows users that introduce hstore into an existing
# environment to disable global registration of the hstore adapter
# in order to avoid unpredictable behavior when having hstore installed individually
# on each database instead of on having it installed on template1.
# Check if GEODJANGO is being used
GEODJANGO_INSTALLED = False
for database in settings.DATABASES.values():
if 'postgis' in database.get('ENGINE'):
GEODJANGO_INSTALLED = True
break
class ConnectionCreateHandler(object):
"""
Generic connection handlers manager.
Executes attached functions when connection is created.
With possibility of attaching single execution methods.
"""
generic_handlers = []
unique_handlers = []
def __call__(self, sender, connection, **kwargs):
handlers = set()
if len(self.unique_handlers) > 0:
handlers.update(self.unique_handlers)
self.unique_handlers = []
handlers.update(self.generic_handlers)
# List comprehension is used instead of for statement
# only for performance.
return [x(connection) for x in handlers]
def attach_handler(self, func, vendor=None, unique=False):
if unique:
self.unique_handlers.append(func)
else:
self.generic_handlers.append(func)
connection_handler = ConnectionCreateHandler()
def register_hstore_handler(connection, **kwargs):
# do not register hstore if DB is not postgres
# do not register if HAS_HSTORE flag is set to false
if connection.vendor != 'postgresql' or \
connection.settings_dict.get('HAS_HSTORE', True) is False:
return
# if the ``NAME`` of the database in the connection settings is ``None``
# defer hstore registration by setting up a new unique handler
if connection.settings_dict['NAME'] is None:
connection_handler.attach_handler(register_hstore_handler,
vendor="postgresql",
unique=HSTORE_REGISTER_GLOBALLY)
return
if sys.version_info[0] < 3:
register_hstore(connection.connection, globally=HSTORE_REGISTER_GLOBALLY, unicode=True)
else:
register_hstore(connection.connection, globally=HSTORE_REGISTER_GLOBALLY)
connection_handler.attach_handler(register_hstore_handler,
vendor="postgresql",
unique=HSTORE_REGISTER_GLOBALLY)
class HStoreConfig(AppConfig):
name = 'django_hstore'
verbose = 'Django HStore'
def ready(self):
connection_created.connect(connection_handler,
weak=CONNECTION_CREATED_SIGNAL_WEAKREF,
dispatch_uid="_connection_create_handler")
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/descriptors.py 0000664 0001750 0001750 00000003120 13016340771 025756 0 ustar kitterma kitterma from .dict import HStoreDict, HStoreReferenceDict
__all__ = [
'HStoreDescriptor',
'HStoreReferenceDescriptor',
'SerializedDictDescriptor'
]
class Creator(object):
"""
A placeholder class that provides a way to set the attribute on the model.
"""
def __init__(self, field):
self.field = field
def __get__(self, obj, type=None):
if obj is None:
return self
return obj.__dict__[self.field.name]
def __set__(self, obj, value):
obj.__dict__[self.field.name] = self.field.to_python(value)
class HStoreDescriptor(Creator):
_DictClass = HStoreDict
def __init__(self, *args, **kwargs):
self.schema_mode = kwargs.pop('schema_mode', False)
super(HStoreDescriptor, self).__init__(*args, **kwargs)
def __set__(self, obj, value):
value = self.field.to_python(value)
if isinstance(value, dict):
value = self._DictClass(
value=value, field=self.field, instance=obj, schema_mode=self.schema_mode
)
obj.__dict__[self.field.name] = value
class SerializedDictDescriptor(Creator):
_DictClass = dict
def __set__(self, obj, value):
# Deserialization is only needed when retrieving data from DB
# (not when field is being set via assignment (`x.data = {...}`)
# or via the `.create()` method.
if value and self.field._from_db(obj):
value = self.field.to_python(value)
obj.__dict__[self.field.name] = value
class HStoreReferenceDescriptor(HStoreDescriptor):
_DictClass = HStoreReferenceDict
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/fields.py 0000664 0001750 0001750 00000032000 13016340771 024662 0 ustar kitterma kitterma from __future__ import absolute_import, unicode_literals
import datetime
import json
import django
from django.db import models
from django.utils import six
from django.utils.translation import ugettext_lazy as _
from . import forms, utils
from .descriptors import HStoreDescriptor, HStoreReferenceDescriptor, SerializedDictDescriptor
from .dict import HStoreDict, HStoreReferenceDict
from .virtual import create_hstore_virtual_field
class HStoreField(models.Field):
""" HStore Base Field """
def __init_dict(self, value):
"""
initializes HStoreDict
"""
return HStoreDict(value, self)
def validate(self, value, *args):
super(HStoreField, self).validate(value, *args)
forms.validate_hstore(value, is_serialized=hasattr(self, 'serializer'))
def contribute_to_class(self, cls, name):
super(HStoreField, self).contribute_to_class(cls, name)
setattr(cls, self.name, HStoreDescriptor(self))
def get_default(self):
"""
Returns the default value for this field.
"""
# if default defined
if self.has_default():
# if default is callable
if callable(self.default):
return self.__init_dict(self.default())
# if it's a dict
elif isinstance(self.default, dict):
return self.__init_dict(self.default)
# else just return it
return self.default
# default to empty dict
return self.__init_dict({})
def get_prep_value(self, value):
if isinstance(value, dict) and not isinstance(value, HStoreDict):
return self.__init_dict(value)
else:
return value
def get_db_prep_value(self, value, connection, prepared=False):
if not prepared:
value = self.get_prep_value(value)
return value
def value_to_string(self, obj):
return self._get_val_from_obj(obj)
def db_type(self, connection=None):
return 'hstore'
def south_field_triple(self): # pragma no cover
from south.modelsinspector import introspector
name = '%s.%s' % (self.__class__.__module__, self.__class__.__name__)
args, kwargs = introspector(self)
return name, args, kwargs
if django.VERSION >= (1, 7):
from .lookups import (HStoreGreaterThan, HStoreGreaterThanOrEqual, HStoreLessThan,
HStoreLessThanOrEqual, HStoreContains, HStoreIContains, HStoreIsNull)
HStoreField.register_lookup(HStoreGreaterThan)
HStoreField.register_lookup(HStoreGreaterThanOrEqual)
HStoreField.register_lookup(HStoreLessThan)
HStoreField.register_lookup(HStoreLessThanOrEqual)
HStoreField.register_lookup(HStoreContains)
HStoreField.register_lookup(HStoreIContains)
HStoreField.register_lookup(HStoreIsNull)
class DictionaryField(HStoreField):
description = _("A python dictionary in a postgresql hstore field.")
def __init__(self, *args, **kwargs):
self.schema = kwargs.pop('schema', None)
self.schema_mode = False
# if schema parameter is supplied the behaviour is slightly different
if self.schema is not None:
self._validate_schema(self.schema)
self.schema_mode = True
# DictionaryField with schema is not editable via admin
kwargs['editable'] = False
# null defaults to True to facilitate migrations
kwargs['null'] = kwargs.get('null', True)
super(DictionaryField, self).__init__(*args, **kwargs)
def __init_dict(self, value):
"""
init HStoreDict
pass schema_mode=True if in "schema" mode
"""
return HStoreDict(value, self, schema_mode=self.schema_mode)
def contribute_to_class(self, cls, name):
super(DictionaryField, self).contribute_to_class(cls, name)
setattr(cls, self.name, HStoreDescriptor(self, schema_mode=self.schema_mode))
if self.schema:
self._create_hstore_virtual_fields(cls, name)
def formfield(self, **kwargs):
kwargs['form_class'] = forms.DictionaryField
return super(DictionaryField, self).formfield(**kwargs)
def _value_to_python(self, value):
return value
def south_field_triple(self): # pragma no cover
name, args, kwargs = super(DictionaryField, self).south_field_triple()
# if schema mode replace the default value {} with None as {} would break south
if self.schema_mode:
kwargs['default'] = None
return name, args, kwargs
def _validate_schema(self, schema):
if not isinstance(schema, list):
raise ValueError('schema parameter must be a list')
if len(schema) == 0:
raise ValueError('schema parameter cannot be an empty list')
for field in schema:
if not isinstance(field, dict):
raise ValueError('schema parameter must contain dicts representing fields, read the docs to see the format')
if 'name' not in field:
raise ValueError('schema element %s is missing the name key' % field)
if 'class' not in field:
raise ValueError('schema element %s is missing the class key' % field)
def _create_hstore_virtual_fields(self, cls, hstore_field_name):
"""
this methods creates all the virtual fields automatically by reading the schema attribute
"""
if not self.schema and self.schema_mode is False:
return
# add hstore_virtual_fields attribute to class
if not hasattr(cls, '_hstore_virtual_fields'):
cls._hstore_virtual_fields = {}
# loop over all fields defined in schema
for field in self.schema:
# initialize the virtual field by specifying the class, the kwargs and the hstore field name
virtual_field = create_hstore_virtual_field(field['class'],
field.get('kwargs', {}),
hstore_field_name)
# this will call the contribute_to_class method in virtual.HStoreVirtualMixin
cls.add_to_class(field['name'], virtual_field)
# add this field to hstore_virtual_fields dict
cls._hstore_virtual_fields[field['name']] = virtual_field
def reload_schema(self, schema):
"""
Reload schema arbitrarily at run-time
"""
if schema:
self._validate_schema(schema)
self.schema = schema
self.schema_mode = True
self.editable = False
else:
self.schema = None
self.schema_mode = False
self.editable = True
# remove any existing virtual field
self._remove_hstore_virtual_fields()
# set new descriptor on model class
setattr(self.model, self.name, HStoreDescriptor(self, schema_mode=self.schema_mode))
# create virtual fields
self._create_hstore_virtual_fields(self.model, self.name)
def _remove_hstore_virtual_fields(self):
""" remove hstore virtual fields from class """
cls = self.model
# remove all hstore virtual fields related attributes
if hasattr(cls, '_hstore_virtual_fields'):
# remove attributes from class
for field_name in cls._hstore_virtual_fields.keys():
delattr(cls, field_name)
delattr(cls, '_hstore_virtual_fields')
# django >= 1.8
if django.VERSION >= (1, 8):
# remove all hstore virtual fields from meta
hstore_fields = []
# get all the existing hstore virtual fields
for field in getattr(cls._meta, 'virtual_fields'):
if hasattr(field, 'hstore_field_name'):
hstore_fields.append(field)
# remove from meta
for field in hstore_fields:
getattr(cls._meta, 'virtual_fields').remove(field)
# reset _meta.fields
fields = [f for f in cls._meta.fields if not hasattr(f, 'hstore_field_name')]
# cls._meta.fields.__class__ == ImmutableList
cls._meta.fields = cls._meta.fields.__class__(fields)
# django <= 1.7
# TODO: Remove this when django 1.7 is no longer supported.
else:
# remove all hstore virtual fields from meta
for meta_fields in ['fields', 'local_fields', 'virtual_fields']:
hstore_fields = []
# get all the existing hstore virtual fields
for field in getattr(cls._meta, meta_fields):
if hasattr(field, 'hstore_field_name'):
hstore_fields.append(field)
# remove from meta
for field in hstore_fields:
getattr(cls._meta, meta_fields).remove(field)
class ReferencesField(HStoreField):
description = _("A python dictionary of references to model instances in an hstore field.")
def contribute_to_class(self, cls, name):
super(ReferencesField, self).contribute_to_class(cls, name)
setattr(cls, self.name, HStoreReferenceDescriptor(self))
def formfield(self, **kwargs):
kwargs['form_class'] = forms.ReferencesField
return super(ReferencesField, self).formfield(**kwargs)
def get_prep_lookup(self, lookup, value):
if isinstance(value, dict):
return utils.serialize_references(value)
return value
def get_prep_value(self, value):
return utils.serialize_references(value)
def to_python(self, value):
return value if isinstance(value, dict) else HStoreReferenceDict({})
def _value_to_python(self, value):
return utils.acquire_reference(value)
class SerializedDictionaryField(HStoreField):
description = _("A python dictionary in a postgresql hstore field.")
def __init__(self, serializer=json.dumps, deserializer=json.loads, *args, **kwargs):
self.serializer = serializer
self.deserializer = deserializer
super(SerializedDictionaryField, self).__init__(*args, **kwargs)
def _from_db(self, model_instance):
"""
Helper to determine if model instance is from the DB.
"""
return bool(model_instance._state.adding and model_instance.pk)
def get_default(self):
"""
Returns the default value for this field.
"""
if self.has_default():
if callable(self.default):
return self.default()
return self.default
else:
return {}
def clean(self, value, model_instance):
if self._from_db(model_instance): # Only prepare data from DB
value = self.to_python(value)
self.validate(value, model_instance)
self.run_validators(value)
return value
def _serialize_value(self, value):
# Don't serialize None type or Datetime, Postgres can handle
if (value is None) or isinstance(value, datetime.date):
return value
else:
return self.serializer(value)
def _serialize_dict(self, value):
if value is None:
return value
return dict((k, self._serialize_value(v)) for k, v in value.items())
def _deserialize_value(self, value):
if value is None or isinstance(value, datetime.date):
return value
# needed for #111
elif not isinstance(value, six.string_types):
return value
else:
return self.deserializer(value)
def _deserialize_dict(self, value):
""" Helper to deserialize dict-like data """
if not value or isinstance(value, six.string_types):
return value
return dict((k, self._deserialize_value(v)) for k, v in value.items())
def contribute_to_class(self, cls, name):
super(SerializedDictionaryField, self).contribute_to_class(cls, name)
setattr(cls, self.name, SerializedDictDescriptor(self))
def formfield(self, **kwargs):
kwargs['form_class'] = forms.SerializedDictionaryField
return super(SerializedDictionaryField, self).formfield(**kwargs)
def get_prep_value(self, value):
""" Convert to query-friendly format. """
if not isinstance(value, dict): # Handle values from hremove
return value
return self._serialize_dict(value)
def get_prep_lookup(self, lookup_type, value):
""" Prepares value for the database prior to be used in a lookup """
if lookup_type == 'isnull':
return value
return self.get_prep_value(value)
def _value_to_python(self, value):
return self._deserialize_value(value)
def to_python(self, value):
""" Convert from db-friendly format to originally typed values. """
if isinstance(value, dict):
return self._deserialize_dict(value)
else:
return value
# south compatibility
try: # pragma no cover
from south.modelsinspector import add_introspection_rules
add_introspection_rules(rules=[], patterns=['django_hstore\.hstore'])
except ImportError:
pass
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/widgets.py 0000664 0001750 0001750 00000004525 13016340771 025075 0 ustar kitterma kitterma from __future__ import absolute_import, unicode_literals
import django
from django import forms
from django.conf import settings
from django.contrib.admin.templatetags.admin_static import static
from django.contrib.admin.widgets import AdminTextareaWidget
from django.template import Context
from django.template.loader import get_template
from django.utils.safestring import mark_safe
__all__ = [
'AdminHStoreWidget'
]
class BaseAdminHStoreWidget(AdminTextareaWidget):
"""
Base admin widget class for default-admin and grappelli-admin widgets
"""
admin_style = 'default'
@property
def media(self):
internal_js = [
"django_hstore/underscore-min.js",
"django_hstore/hstore-widget.js"
]
js = [static("admin/js/%s" % path) for path in internal_js]
return forms.Media(js=js)
def render(self, name, value, attrs=None):
if attrs is None:
attrs = {}
# it's called "original" because it will be replaced by a copy
attrs['class'] = 'hstore-original-textarea'
# get default HTML from AdminTextareaWidget
html = super(BaseAdminHStoreWidget, self).render(name, value, attrs)
# prepare template context
template_context = Context({
'field_name': name,
'STATIC_URL': settings.STATIC_URL,
'use_svg': django.VERSION >= (1, 9), # use svg icons if django >= 1.9
})
# get template object
template = get_template('hstore_%s_widget.html' % self.admin_style)
# render additional html
additional_html = template.render(template_context)
# append additional HTML and mark as safe
html = html + additional_html
html = mark_safe(html)
return html
class DefaultAdminHStoreWidget(BaseAdminHStoreWidget):
"""
Widget that displays the HStore contents
in the default django-admin with a nice interactive UI
"""
admin_style = 'default'
class GrappelliAdminHStoreWidget(BaseAdminHStoreWidget):
"""
Widget that displays the HStore contents
in the django-admin with a nice interactive UI
designed for django-grappelli
"""
admin_style = 'grappelli'
if 'grappelli' in settings.INSTALLED_APPS:
AdminHStoreWidget = GrappelliAdminHStoreWidget
else:
AdminHStoreWidget = DefaultAdminHStoreWidget
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore/compat.py 0000664 0001750 0001750 00000000555 13016340771 024711 0 ustar kitterma kitterma import sys
class UnicodeMixin(object):
"""
Mixin class to handle defining the proper __str__/__unicode__
methods in Python 2 or 3.
"""
if sys.version_info[0] >= 3: # Python 3
def __str__(self):
return self.__unicode__()
else: # Python 2
def __str__(self):
return self.__unicode__().encode('utf8')
django-hstore-1.5~alpha~git20161126+dfsg/README.rst 0000664 0001750 0001750 00000003540 13016340771 021712 0 ustar kitterma kitterma =============
django-hstore
=============
.. image:: https://travis-ci.org/djangonauts/django-hstore.svg
:target: https://travis-ci.org/djangonauts/django-hstore
.. image:: https://coveralls.io/repos/djangonauts/django-hstore/badge.svg
:target: https://coveralls.io/r/djangonauts/django-hstore
.. image:: https://requires.io/github/djangonauts/django-hstore/requirements.svg?branch=master
:target: https://requires.io/github/djangonauts/django-hstore/requirements/?branch=master
:alt: Requirements Status
.. image:: https://badge.fury.io/py/django-hstore.svg
:target: https://pypi.python.org/pypi/django-hstore
.. image:: https://img.shields.io/pypi/dm/django-hstore.svg
:target: https://pypi.python.org/pypi/django-hstore
------------
You need **dynamic columns** in your tables. What do you do?
- Create lots of tables to handle it. Nice, now you’ll need more models and lots of additional sqls. Insertion and selection will be slow as hell.
- Use a **noSQL** database just for this issue. **Good luck**.
- Create a serialized column. Nice, insertion will be fine, and reading data from a record too. But, what if you have a condition in your select that includes serialized data? Yeah, regular expressions.
------------
Documentation_ - `Mailing List`_
.. _Documentation: http://djangonauts.github.io/django-hstore/
.. _`Mailing List`: https://groups.google.com/forum/#!forum/django-hstore
------------
Projects using this package
---------------------------
- `django-rest-framework-hstore `__: **django-rest-framework** tools for **django-hstore**
- `Nodeshot `__: extensible django web application for management of community-led georeferenced data - some features of **django-hstore**, like the ``schema-mode`` have been developed for this project
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore.egg-info/ 0000775 0001750 0001750 00000000000 13016364461 024543 5 ustar kitterma kitterma django-hstore-1.5~alpha~git20161126+dfsg/django_hstore.egg-info/not-zip-safe 0000664 0001750 0001750 00000000001 13016364461 026771 0 ustar kitterma kitterma
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore.egg-info/top_level.txt 0000664 0001750 0001750 00000000016 13016364461 027272 0 ustar kitterma kitterma django_hstore
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore.egg-info/SOURCES.txt 0000664 0001750 0001750 00000002765 13016364461 026441 0 ustar kitterma kitterma AUTHORS
LICENSE
MANIFEST.in
README.rst
setup.cfg
setup.py
django_hstore/__init__.py
django_hstore/apps.py
django_hstore/compat.py
django_hstore/descriptors.py
django_hstore/dict.py
django_hstore/exceptions.py
django_hstore/fields.py
django_hstore/forms.py
django_hstore/hstore.py
django_hstore/lookups.py
django_hstore/managers.py
django_hstore/models.py
django_hstore/query.py
django_hstore/utils.py
django_hstore/virtual.py
django_hstore/widgets.py
django_hstore.egg-info/PKG-INFO
django_hstore.egg-info/SOURCES.txt
django_hstore.egg-info/dependency_links.txt
django_hstore.egg-info/not-zip-safe
django_hstore.egg-info/top_level.txt
django_hstore/static/admin/js/django_hstore/hstore-widget.js
django_hstore/static/admin/js/django_hstore/underscore-min.js
django_hstore/templates/hstore_default_widget.html
django_hstore/templates/hstore_grappelli_widget.html
tests/__init__.py
tests/local_settings.py.example
tests/local_settings_psycopg.py.example
tests/manage.py
tests/settings.py
tests/settings_psycopg.py
tests/urls.py
tests/django_hstore_tests/__init__.py
tests/django_hstore_tests/admin.py
tests/django_hstore_tests/models.py
tests/django_hstore_tests/tests/__init__.py
tests/django_hstore_tests/tests/test_dictionary_field.py
tests/django_hstore_tests/tests/test_gis_integration.py
tests/django_hstore_tests/tests/test_not_transactional.py
tests/django_hstore_tests/tests/test_reference_field.py
tests/django_hstore_tests/tests/test_schema_mode.py
tests/django_hstore_tests/tests/test_serialized_dictionary_field.py django-hstore-1.5~alpha~git20161126+dfsg/django_hstore.egg-info/dependency_links.txt 0000664 0001750 0001750 00000000001 13016364461 030611 0 ustar kitterma kitterma
django-hstore-1.5~alpha~git20161126+dfsg/django_hstore.egg-info/PKG-INFO 0000664 0001750 0001750 00000006321 13016364461 025642 0 ustar kitterma kitterma Metadata-Version: 1.1
Name: django-hstore
Version: 1.5.alpha
Summary: PostgreSQL HStore support for Django
Home-page: https://github.com/djangonauts/django-hstore
Author: Djangonauts Organization
Author-email: django-hstore@googlegroups.com
License: BSD
Download-URL: https://github.com/djangonauts/django-hstore/releases
Description: =============
django-hstore
=============
.. image:: https://travis-ci.org/djangonauts/django-hstore.svg
:target: https://travis-ci.org/djangonauts/django-hstore
.. image:: https://coveralls.io/repos/djangonauts/django-hstore/badge.svg
:target: https://coveralls.io/r/djangonauts/django-hstore
.. image:: https://requires.io/github/djangonauts/django-hstore/requirements.svg?branch=master
:target: https://requires.io/github/djangonauts/django-hstore/requirements/?branch=master
:alt: Requirements Status
.. image:: https://badge.fury.io/py/django-hstore.svg
:target: https://pypi.python.org/pypi/django-hstore
.. image:: https://img.shields.io/pypi/dm/django-hstore.svg
:target: https://pypi.python.org/pypi/django-hstore
------------
You need **dynamic columns** in your tables. What do you do?
- Create lots of tables to handle it. Nice, now you’ll need more models and lots of additional sqls. Insertion and selection will be slow as hell.
- Use a **noSQL** database just for this issue. **Good luck**.
- Create a serialized column. Nice, insertion will be fine, and reading data from a record too. But, what if you have a condition in your select that includes serialized data? Yeah, regular expressions.
------------
Documentation_ - `Mailing List`_
.. _Documentation: http://djangonauts.github.io/django-hstore/
.. _`Mailing List`: https://groups.google.com/forum/#!forum/django-hstore
------------
Projects using this package
---------------------------
- `django-rest-framework-hstore `__: **django-rest-framework** tools for **django-hstore**
- `Nodeshot `__: extensible django web application for management of community-led georeferenced data - some features of **django-hstore**, like the ``schema-mode`` have been developed for this project
Keywords: django,hstore,schemaless
Platform: Platform Indipendent
Classifier: Development Status :: 4 - Beta
Classifier: Environment :: Web Environment
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: BSD License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
Classifier: Framework :: Django
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
django-hstore-1.5~alpha~git20161126+dfsg/MANIFEST.in 0000664 0001750 0001750 00000000135 13016340771 021756 0 ustar kitterma kitterma include AUTHORS LICENSE README.rst
recursive-include tests *
recursive-exclude * *.pyc *.swp
django-hstore-1.5~alpha~git20161126+dfsg/setup.cfg 0000664 0001750 0001750 00000000565 13016364461 022052 0 ustar kitterma kitterma [bdist_wheel]
universal = 1
[isort]
known_django = django
sections = FUTURE,STDLIB,THIRDPARTY,DJANGO,FIRSTPARTY,TESTS,LOCALFOLDER
default_section = THIRDPARTY
known_standard_library = requests
known_first_party = django_hstore
known_tests = django_hstore_tests
multi_line_output = 3
line_length = 100
indent = 4
[egg_info]
tag_build =
tag_date = 0
tag_svn_revision = 0
django-hstore-1.5~alpha~git20161126+dfsg/LICENSE 0000664 0001750 0001750 00000004153 13016340771 021231 0 ustar kitterma kitterma Copyright (C) 2013-2014 Federico Capoano
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
Original Author
===============
Copyright (C) 2011 Jordan McCoy
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
django-hstore-1.5~alpha~git20161126+dfsg/tests/ 0000775 0001750 0001750 00000000000 13016364461 021365 5 ustar kitterma kitterma django-hstore-1.5~alpha~git20161126+dfsg/tests/__init__.py 0000664 0001750 0001750 00000000000 13016340771 023462 0 ustar kitterma kitterma django-hstore-1.5~alpha~git20161126+dfsg/tests/manage.py 0000775 0001750 0001750 00000000367 13016340771 023176 0 ustar kitterma kitterma #!/usr/bin/env python
import os
import sys
if __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "tests.settings")
from django.core.management import execute_from_command_line
execute_from_command_line(sys.argv)
django-hstore-1.5~alpha~git20161126+dfsg/tests/local_settings_psycopg.py.example 0000664 0001750 0001750 00000000605 13016340771 030146 0 ustar kitterma kitterma # -*- coding: utf-8 -*-
DATABASES = {
'default': {
# possible backends are:
# * django.db.backends.postgresql_psycopg2
# * django.contrib.gis.db.backends.postgis
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': 'django_hstore_psycopg2',
'USER': '',
'PASSWORD': '',
'HOST': '',
'PORT': ''
},
}
django-hstore-1.5~alpha~git20161126+dfsg/tests/urls.py 0000664 0001750 0001750 00000000512 13016340771 022720 0 ustar kitterma kitterma from django.conf import settings
from django.conf.urls import include, url
from django.contrib import admin
admin.autodiscover()
urlpatterns = [
url(r'^admin/', include(admin.site.urls)),
]
if 'grappelli' in settings.INSTALLED_APPS:
urlpatterns.append([
url(r'^grappelli/', include('grappelli.urls')),
])
django-hstore-1.5~alpha~git20161126+dfsg/tests/django_hstore_tests/ 0000775 0001750 0001750 00000000000 13016364461 025435 5 ustar kitterma kitterma django-hstore-1.5~alpha~git20161126+dfsg/tests/django_hstore_tests/__init__.py 0000664 0001750 0001750 00000000000 13016340771 027532 0 ustar kitterma kitterma django-hstore-1.5~alpha~git20161126+dfsg/tests/django_hstore_tests/admin.py 0000664 0001750 0001750 00000001314 13016340771 027074 0 ustar kitterma kitterma import django
from django.contrib import admin
from .models import * # noqa
class DataBagAdmin(admin.ModelAdmin):
pass
class DefaultsInlineAdmin(admin.StackedInline):
model = DefaultsInline
extra = 0
class DefaultsModelAdmin(admin.ModelAdmin):
inlines = [DefaultsInlineAdmin]
class RefsBagAdmin(admin.ModelAdmin):
pass
admin.site.register(DataBag, DataBagAdmin)
admin.site.register(SerializedDataBag, DataBagAdmin)
admin.site.register(DefaultsModel, DefaultsModelAdmin)
admin.site.register(RefsBag, RefsBagAdmin)
if django.VERSION >= (1, 6):
class SchemaDataBagAdmin(admin.ModelAdmin):
list_display = ['name']
admin.site.register(SchemaDataBag, SchemaDataBagAdmin)
django-hstore-1.5~alpha~git20161126+dfsg/tests/django_hstore_tests/models.py 0000664 0001750 0001750 00000014330 13016340771 027271 0 ustar kitterma kitterma import django
from django.db import models
from django_hstore import hstore
from django_hstore.apps import GEODJANGO_INSTALLED
__all__ = [
'Ref',
'DataBag',
'SerializedDataBag',
'SerializedDataBagNoID',
'NullableDataBag',
'RefsBag',
'NullableRefsBag',
'DefaultsModel',
'BadDefaultsModel',
'DefaultsInline',
'NumberedDataBag',
'UniqueTogetherDataBag'
]
class Ref(models.Model):
name = models.CharField(max_length=32)
class HStoreModel(models.Model):
objects = hstore.HStoreManager()
class Meta:
abstract = True
class DataBag(HStoreModel):
name = models.CharField(max_length=32)
data = hstore.DictionaryField()
class SerializedDataBag(HStoreModel):
name = models.CharField(max_length=32)
data = hstore.SerializedDictionaryField()
class SerializedDataBagNoID(HStoreModel):
slug = models.SlugField(primary_key=True)
name = models.CharField(max_length=32)
data = hstore.SerializedDictionaryField()
class NullableDataBag(HStoreModel):
name = models.CharField(max_length=32)
data = hstore.DictionaryField(null=True)
class RefsBag(HStoreModel):
name = models.CharField(max_length=32)
refs = hstore.ReferencesField()
class NullableRefsBag(HStoreModel):
name = models.CharField(max_length=32)
refs = hstore.ReferencesField(null=True, blank=True)
class DefaultsModel(models.Model):
a = hstore.DictionaryField(default={})
b = hstore.DictionaryField(default=None, null=True)
c = hstore.DictionaryField(default={'x': '1'})
class BadDefaultsModel(models.Model):
a = hstore.DictionaryField(default=None)
class DefaultsInline(models.Model):
parent = models.ForeignKey(DefaultsModel)
d = hstore.DictionaryField(default={'default': 'yes'})
class NumberedDataBag(HStoreModel):
name = models.CharField(max_length=32)
data = hstore.DictionaryField()
number = models.IntegerField()
class UniqueTogetherDataBag(HStoreModel):
name = models.CharField(max_length=32)
data = hstore.DictionaryField()
class Meta:
unique_together = ('name', 'data')
if django.VERSION >= (1, 6):
class SchemaDataBag(HStoreModel):
name = models.CharField(max_length=32)
data = hstore.DictionaryField(schema=[
{
'name': 'number',
'class': 'IntegerField',
'kwargs': {
'default': 0
}
},
{
'name': 'float',
'class': models.FloatField,
'kwargs': {
'default': 1.0
}
},
{
'name': 'boolean',
'class': 'BooleanField',
},
{
'name': 'boolean_true',
'class': 'BooleanField',
'kwargs': {
'verbose_name': 'boolean true',
'default': True
}
},
{
'name': 'char',
'class': 'CharField',
'kwargs': {
'default': 'test', 'blank': True, 'max_length': 10
}
},
{
'name': 'text',
'class': 'TextField',
'kwargs': {
'blank': True
}
},
{
'name': 'choice',
'class': 'CharField',
'kwargs': {
'blank': True,
'max_length': 10,
'choices': (('choice1', 'choice1'), ('choice2', 'choice2')),
'default': 'choice1'
}
},
{
'name': 'choice2',
'class': 'CharField',
'kwargs': {
'blank': True,
'max_length': 10,
'choices': (('choice1', 'choice1'), ('choice2', 'choice2')),
}
},
{
'name': 'date',
'class': 'DateField',
'kwargs': {
'blank': True
}
},
{
'name': 'datetime',
'class': 'DateTimeField',
'kwargs': {
'blank': True,
'null': True
}
},
{
'name': 'decimal',
'class': 'DecimalField',
'kwargs': {
'blank': True,
'decimal_places': 2,
'max_digits': 4
}
},
{
'name': 'email',
'class': 'EmailField',
'kwargs': {
'blank': True
}
},
{
'name': 'ip',
'class': 'GenericIPAddressField',
'kwargs': {
'blank': True,
'null': True
}
},
{
'name': 'url',
'class': models.URLField,
'kwargs': {
'blank': True
}
},
])
class NullSchemaDataBag(HStoreModel):
name = models.CharField(max_length=32)
data = hstore.DictionaryField(null=True, default=None, schema=[
{
'name': 'number',
'class': 'IntegerField',
'kwargs': {
'default': 1
}
},
{
'name': 'char',
'class': 'CharField',
'kwargs': {
'default': 'test', 'blank': True, 'max_length': 10
}
}
])
__all__.append('SchemaDataBag')
__all__.append('NullSchemaDataBag')
# if geodjango is in use define Location model, which contains GIS data
if GEODJANGO_INSTALLED:
from django.contrib.gis.db import models as geo_models
class Location(geo_models.Model):
name = geo_models.CharField(max_length=32)
data = hstore.DictionaryField()
point = geo_models.GeometryField()
objects = hstore.HStoreGeoManager()
__all__.append('Location')
django-hstore-1.5~alpha~git20161126+dfsg/tests/django_hstore_tests/tests/ 0000775 0001750 0001750 00000000000 13016364461 026577 5 ustar kitterma kitterma django-hstore-1.5~alpha~git20161126+dfsg/tests/django_hstore_tests/tests/__init__.py 0000664 0001750 0001750 00000000000 13016340771 030674 0 ustar kitterma kitterma django-hstore-1.5~alpha~git20161126+dfsg/tests/django_hstore_tests/tests/test_gis_integration.py 0000664 0001750 0001750 00000007076 13016340771 033405 0 ustar kitterma kitterma from django_hstore.apps import GEODJANGO_INSTALLED
if GEODJANGO_INSTALLED:
from django.test import TestCase
from django.contrib.gis.geos import GEOSGeometry
from django_hstore_tests.models import Location
class TestDictionaryFieldPlusGIS(TestCase):
""" Test DictionaryField with gis backend """
pnt1 = GEOSGeometry('POINT(65.5758316 57.1345383)')
pnt2 = GEOSGeometry('POINT(65.2316 57.3423233)')
def setUp(self):
Location.objects.all().delete()
def _create_locations(self):
loc1 = Location.objects.create(name='Location1', data={'prop1': '1', 'prop2': 'test_value'}, point=self.pnt1)
loc2 = Location.objects.create(name='Location2', data={'prop1': '2', 'prop2': 'test_value'}, point=self.pnt2)
return loc1, loc2
def test_location_create(self):
l1, l2 = self._create_locations()
other_loc = Location.objects.get(point__contains=self.pnt1)
self.assertEqual(other_loc.data, {'prop1': '1', 'prop2': 'test_value'})
def test_location_hupdate(self):
l1, l2 = self._create_locations()
Location.objects.filter(point__contains=self.pnt1).hupdate('data', {'prop1': '2'})
loc = Location.objects.exclude(point__contains=self.pnt2)[0]
self.assertEqual(loc.data, {'prop1': '2', 'prop2': 'test_value'})
loc = Location.objects.get(point__contains=self.pnt2)
self.assertNotEqual(loc.data, {'prop1': '1', 'prop2': 'test_value'})
def test_location_contains(self):
l1, l2 = self._create_locations()
self.assertEqual(Location.objects.filter(data__contains={'prop1': '1'}).count(), 1)
self.assertEqual(Location.objects.filter(data__contains={'prop1': '2'}).count(), 1)
def test_location_geomanager(self):
l1, l2 = self._create_locations()
d1 = Location.objects.filter(point__distance_lte=(self.pnt1, 70000))
self.assertEqual(d1.count(), 2)
def test_manager(self):
from django_hstore.managers import HStoreGeoManager
isinstance(Location.objects, HStoreGeoManager)
hasattr(Location.objects, 'hpeek')
hasattr(Location.objects, 'hslice')
hasattr(Location.objects, 'hkeys')
# noqa
class TestReferencesFieldPlusGIS(TestDictionaryFieldPlusGIS):
""" Test ReferenceField with gis backend """
def _create_locations(self):
loc1 = Location.objects.create(name='Location1', data={'prop1': '1', 'prop2': 'test_value'}, point=self.pnt1)
loc2 = Location.objects.create(name='Location2', data={'prop1': '2', 'prop2': 'test_value'}, point=self.pnt2)
return loc1, loc2
def test_location_create(self):
l1, l2 = self._create_locations()
loc_1 = Location.objects.get(point__contains=self.pnt1)
self.assertEqual(loc_1.data, {'prop1': '1', 'prop2': 'test_value'})
loc_2 = Location.objects.get(point__contains=self.pnt2)
self.assertEqual(loc_2.data, {'prop1': '2', 'prop2': 'test_value'})
def test_location_hupdate(self):
l1, l2 = self._create_locations()
Location.objects.filter(point__contains=self.pnt1).hupdate('data', {'prop1': '2'})
loc = Location.objects.exclude(point__contains=self.pnt2)[0]
self.assertEqual(loc.data, {'prop1': '2', 'prop2': 'test_value'})
loc = Location.objects.get(point__contains=self.pnt2)
self.assertNotEqual(loc.data, {'prop1': '1', 'prop2': 'test_value'})
././@LongLink 0000644 0000000 0000000 00000000155 00000000000 011604 L ustar root root django-hstore-1.5~alpha~git20161126+dfsg/tests/django_hstore_tests/tests/test_serialized_dictionary_field.py django-hstore-1.5~alpha~git20161126+dfsg/tests/django_hstore_tests/tests/test_serialized_dictionary_0000664 0001750 0001750 00000047135 13016340771 034310 0 ustar kitterma kitterma # -*- coding: utf-8 -*-
import datetime
from django import forms
from django.contrib.auth.models import User
from django.core.exceptions import ValidationError
from django.core.urlresolvers import reverse
from django.db.models.aggregates import Count
from django.test import TestCase
from django_hstore.forms import SerializedDictionaryFieldWidget
from django_hstore_tests.models import SerializedDataBag, SerializedDataBagNoID
class TestSerializedDictionaryField(TestCase):
def setUp(self):
SerializedDataBag.objects.all().delete()
def _create_bags(self):
alpha = SerializedDataBag.objects.create(name='alpha', data={'v': 1, 'v2': '3', 'v3': {'a': 1}})
beta = SerializedDataBag.objects.create(name='beta', data={'v': 2, 'v2': [1, '4', 5, {'f': 6}], 'v3': {'a': 2}})
return alpha, beta
def _create_bitfield_bags(self):
# create dictionaries with bits as dictionary keys (i.e. bag5 = {'b0':'1', 'b2':'1'})
for i in range(10):
SerializedDataBag.objects.create(
name='bag%d' % (i,),
data=dict(('b%d' % (bit,), '1') for bit in range(4) if (1 << bit) & i)
)
def test_hstore_dict(self):
alpha, beta = self._create_bags()
self.assertEqual(alpha.data, {'v': 1, 'v2': '3', 'v3': {'a': 1}})
self.assertEqual(beta.data, {'v': 2, 'v2': [1, '4', 5, {'f': 6}], 'v3': {'a': 2}})
def test_number(self):
databag = SerializedDataBag(name='number')
databag.data['num'] = 1
self.assertEqual(databag.data['num'], 1)
databag.save()
databag = SerializedDataBag.objects.get(name='number')
self.assertEqual(databag.data['num'], 1)
databag = SerializedDataBag(name='number', data={'num': 1})
self.assertEqual(databag.data['num'], 1)
def test_non_id_pk(self):
databag = SerializedDataBagNoID(slug='123', name='abc')
databag.data['num'] = 1
databag.save()
SerializedDataBagNoID.objects.get(slug='123')
def test_create_directly(self):
SerializedDataBag.objects.create(name='abc', data={'num': 1})
SerializedDataBagNoID.objects.create(slug='123', name='abc', data={'num': 1})
def test_full_clean(self):
databag = SerializedDataBag(name='number')
databag.data['num'] = 1
self.assertEqual(databag.data['num'], 1)
databag.full_clean()
databag.save()
databag = SerializedDataBag.objects.get(name='number')
self.assertEqual(databag.data['num'], 1)
def test_list(self):
databag = SerializedDataBag.objects.create(name='list', data={'list': ['a', 'b', 'c']})
databag = SerializedDataBag.objects.get(name='list')
self.assertEqual(databag.data['list'], ['a', 'b', 'c'])
def test_dictionary(self):
databag = SerializedDataBag.objects.create(name='dict', data={'dict': {'subkey': 'subvalue'}})
databag = SerializedDataBag.objects.get(name='dict')
self.assertEqual(databag.data['dict'], {'subkey': 'subvalue'})
databag.data['dict'] = {'subkey': True, 'list': ['a', 'b', False]}
databag.save()
self.assertEqual(databag.data['dict'], {'subkey': True, 'list': ['a', 'b', False]})
def test_boolean(self):
databag = SerializedDataBag.objects.create(name='boolean', data={'boolean': True})
databag = SerializedDataBag.objects.get(name='boolean')
self.assertEqual(databag.data['boolean'], True)
def test_empty_instantiation(self):
bag = SerializedDataBag.objects.create(name='bag')
self.assertTrue(isinstance(bag.data, dict))
self.assertEqual(bag.data, {})
def test_empty_querying(self):
SerializedDataBag.objects.create(name='bag')
self.assertTrue(SerializedDataBag.objects.get(data={}))
self.assertTrue(SerializedDataBag.objects.filter(data={}))
self.assertTrue(SerializedDataBag.objects.filter(data__contains={}))
def test_null_values(self):
null_v = SerializedDataBag.objects.create(name="test", data={"v": None})
nonnull_v = SerializedDataBag.objects.create(name="test", data={"v": "item"})
r = SerializedDataBag.objects.filter(data__isnull={"v": True})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], null_v)
r = SerializedDataBag.objects.filter(data__isnull={"v": False})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], nonnull_v)
def test_named_querying(self):
alpha, beta = self._create_bags()
self.assertEqual(SerializedDataBag.objects.get(name='alpha'), alpha)
self.assertEqual(SerializedDataBag.objects.filter(name='beta')[0], beta)
def test_aggregates(self):
self._create_bitfield_bags()
self.assertEqual(SerializedDataBag.objects.filter(data__contains={'b0': '1'}).aggregate(Count('id'))['id__count'], 5)
self.assertEqual(SerializedDataBag.objects.filter(data__contains={'b1': '1'}).aggregate(Count('id'))['id__count'], 4)
def test_annotations(self):
self._create_bitfield_bags()
self.assertEqual(SerializedDataBag.objects.annotate(num_id=Count('id')).filter(num_id=1)[0].num_id, 1)
def test_nested_filtering(self):
self._create_bitfield_bags()
# Test cumulative successive filters for both dictionaries and other fields
f = SerializedDataBag.objects.all()
self.assertEqual(10, f.count())
f = f.filter(data__contains={'b0': '1'})
self.assertEqual(5, f.count())
f = f.filter(data__contains={'b1': '1'})
self.assertEqual(2, f.count())
f = f.filter(name='bag3')
self.assertEqual(1, f.count())
def test_unicode_processing(self):
greets = {
u'de': u'Gr\xfc\xdfe, Welt',
u'en': u'hello, world',
u'es': u'hola, ma\xf1ana',
u'he': u'\u05e9\u05dc\u05d5\u05dd, \u05e2\u05d5\u05dc\u05dd',
u'jp': u'\u3053\u3093\u306b\u3061\u306f\u3001\u4e16\u754c',
u'zh': u'\u4f60\u597d\uff0c\u4e16\u754c',
}
SerializedDataBag.objects.create(name='multilang', data=greets)
self.assertEqual(greets, SerializedDataBag.objects.get(name='multilang').data)
def test_query_escaping(self):
me = self
def readwrite(s):
# try create and query with potentially illegal characters in the field and dictionary key/value
o = SerializedDataBag.objects.create(name=s, data={s: s})
me.assertEqual(o, SerializedDataBag.objects.get(name=s, data={s: s}))
readwrite('\' select')
readwrite('% select')
readwrite('\\\' select')
readwrite('-- select')
readwrite('\n select')
readwrite('\r select')
readwrite('* select')
def test_replace_full_dictionary(self):
SerializedDataBag.objects.create(name='foo', data={'change': 'old value', 'remove': 'baz'})
replacement = {'change': 'new value', 'added': 'new'}
SerializedDataBag.objects.filter(name='foo').update(data=replacement)
self.assertEqual(replacement, SerializedDataBag.objects.get(name='foo').data)
def test_equivalence_querying(self):
alpha, beta = self._create_bags()
for bag in (alpha, beta):
data = {'v': bag.data['v'], 'v2': bag.data['v2'], 'v3': bag.data['v3']}
self.assertEqual(SerializedDataBag.objects.get(data=data), bag)
r = SerializedDataBag.objects.filter(data=data)
self.assertEqual(len(r), 1)
self.assertEqual(r[0], bag)
def test_key_value_subset_querying(self):
alpha, beta = self._create_bags()
for bag in (alpha, beta):
r = SerializedDataBag.objects.filter(data__contains={'v': bag.data['v']})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], bag)
r = SerializedDataBag.objects.filter(data__contains={'v': bag.data['v'], 'v2': bag.data['v2']})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], bag)
def test_key_value_gt_querying(self):
alpha, beta = self._create_bags()
self.assertGreater(beta.data['v'], alpha.data['v'])
r = SerializedDataBag.objects.filter(data__gt={'v': alpha.data['v']})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], beta)
r = SerializedDataBag.objects.filter(data__gte={'v': alpha.data['v']})
self.assertEqual(len(r), 2)
def test_key_value_gt_casting_number_query(self):
alpha = SerializedDataBag.objects.create(name='alpha', data={'v': 10})
SerializedDataBag.objects.create(name='alpha', data={'v': 1})
r = SerializedDataBag.objects.filter(data__gt={'v': 2})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], alpha)
def test_key_value_contains_casting_date_query(self):
date = datetime.date(2014, 9, 28)
alpha = SerializedDataBag.objects.create(name='alpha', data={'v': date.isoformat()})
r = SerializedDataBag.objects.filter(data__contains={'v': date})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], alpha)
def test_multiple_key_value_gt_querying(self):
alpha, beta = self._create_bags()
self.assertGreater(beta.data['v'], alpha.data['v'])
r = SerializedDataBag.objects.filter(data__gt={'v': alpha.data['v'], 'v3': alpha.data['v3']})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], beta)
r = SerializedDataBag.objects.filter(data__gt={'v': alpha.data['v'], 'v3': beta.data['v3']})
self.assertEqual(len(r), 0)
r = SerializedDataBag.objects.filter(data__gte={'v': alpha.data['v'], 'v3': alpha.data['v3']})
self.assertEqual(len(r), 2)
r = SerializedDataBag.objects.filter(data__gte={'v': alpha.data['v'], 'v3': beta.data['v3']})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], beta)
def test_multiple_key_value_lt_querying(self):
alpha, beta = self._create_bags()
self.assertGreater(beta.data['v'], alpha.data['v'])
r = SerializedDataBag.objects.filter(data__lt={'v': beta.data['v'], 'v3': beta.data['v3']})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], alpha)
r = SerializedDataBag.objects.filter(data__lt={'v': beta.data['v'], 'v3': alpha.data['v3']})
self.assertEqual(len(r), 0)
r = SerializedDataBag.objects.filter(data__lte={'v': beta.data['v'], 'v3': beta.data['v3']})
self.assertEqual(len(r), 2)
r = SerializedDataBag.objects.filter(data__lte={'v': beta.data['v'], 'v3': alpha.data['v3']})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], alpha)
def test_key_value_lt_querying(self):
alpha, beta = self._create_bags()
self.assertLess(alpha.data['v'], beta.data['v'])
r = SerializedDataBag.objects.filter(data__lt={'v': beta.data['v']})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], alpha)
r = SerializedDataBag.objects.filter(data__lte={'v': beta.data['v']})
self.assertEqual(len(r), 2)
def test_multiple_key_subset_querying(self):
alpha, beta = self._create_bags()
for keys in (['v'], ['v', 'v2']):
self.assertEqual(SerializedDataBag.objects.filter(data__contains=keys).count(), 2)
for keys in (['v', 'nv'], ['n1', 'n2']):
self.assertEqual(SerializedDataBag.objects.filter(data__contains=keys).count(), 0)
def test_single_key_querying(self):
alpha, beta = self._create_bags()
for key in ('v', 'v2'):
self.assertEqual(SerializedDataBag.objects.filter(data__contains=[key]).count(), 2)
for key in ('n1', 'n2'):
self.assertEqual(SerializedDataBag.objects.filter(data__contains=[key]).count(), 0)
def test_simple_text_icontains_querying(self):
alpha, beta = self._create_bags()
SerializedDataBag.objects.create(name='gamma', data={'theKey': 'someverySpecialValue', 'v2': '3'})
self.assertEqual(SerializedDataBag.objects.filter(data__contains='very').count(), 1)
self.assertEqual(SerializedDataBag.objects.filter(data__contains='very')[0].name, 'gamma')
self.assertEqual(SerializedDataBag.objects.filter(data__icontains='specialvalue').count(), 1)
self.assertEqual(SerializedDataBag.objects.filter(data__icontains='specialvalue')[0].name, 'gamma')
self.assertEqual(SerializedDataBag.objects.filter(data__contains='the').count(), 1)
self.assertEqual(SerializedDataBag.objects.filter(data__contains='the')[0].name, 'gamma')
self.assertEqual(SerializedDataBag.objects.filter(data__icontains='eke').count(), 1)
self.assertEqual(SerializedDataBag.objects.filter(data__icontains='eke')[0].name, 'gamma')
def test_containment_lookup(self):
alpha, beta = self._create_bags()
qs = SerializedDataBag.objects.filter(data__contains=1)
self.assertEqual(len(qs), 2)
self.assertEqual(qs[0], alpha)
self.assertEqual(qs[1], beta)
qs = SerializedDataBag.objects.filter(data__icontains=2)
self.assertEqual(len(qs), 2)
self.assertEqual(list(qs), [alpha, beta])
qs = SerializedDataBag.objects.filter(data__contains='3')
self.assertEqual(len(qs), 2)
self.assertEqual(qs[0], alpha)
self.assertEqual(qs[1], beta)
qs = SerializedDataBag.objects.filter(data__contains='4')
self.assertEqual(len(qs), 1)
self.assertEqual(qs[0], beta)
# Multiple filters
qs = SerializedDataBag.objects.filter(data__contains='4').filter(data__contains=5)
self.assertEqual(len(qs), 1)
self.assertEqual(qs[0], beta)
qs = SerializedDataBag.objects.filter(data__contains=1).filter(data__contains='4')
self.assertEqual(len(qs), 1)
self.assertEqual(qs[0], beta)
# Contains value in nested dict
qs = SerializedDataBag.objects.filter(data__contains=6)
self.assertEqual(len(qs), 1)
def test_invalid_comparison_lookup_values(self):
alpha, beta = self._create_bags()
with self.assertRaises(ValueError):
SerializedDataBag.objects.filter(data__lt=[1, 2])[0]
with self.assertRaises(ValueError):
SerializedDataBag.objects.filter(data__lt=99)[0]
with self.assertRaises(ValueError):
SerializedDataBag.objects.filter(data__lte=[1, 2])[0]
with self.assertRaises(ValueError):
SerializedDataBag.objects.filter(data__lte=99)[0]
with self.assertRaises(ValueError):
SerializedDataBag.objects.filter(data__gt=[1, 2])[0]
with self.assertRaises(ValueError):
SerializedDataBag.objects.filter(data__gt=99)[0]
with self.assertRaises(ValueError):
SerializedDataBag.objects.filter(data__gte=[1, 2])[0]
with self.assertRaises(ValueError):
SerializedDataBag.objects.filter(data__gte=99)[0]
def test_hkeys(self):
alpha, beta = self._create_bags()
self.assertEqual(SerializedDataBag.objects.hkeys(id=alpha.id, attr='data'), ['v', 'v2', 'v3'])
self.assertEqual(SerializedDataBag.objects.hkeys(id=beta.id, attr='data'), ['v', 'v2', 'v3'])
def test_hpeek(self):
alpha, beta = self._create_bags()
self.assertEqual(SerializedDataBag.objects.hpeek(id=alpha.id, attr='data', key='v'), 1)
self.assertEqual(SerializedDataBag.objects.filter(id=alpha.id).hpeek(attr='data', key='v'), 1)
self.assertEqual(SerializedDataBag.objects.hpeek(id=alpha.id, attr='data', key='invalid'), None)
def test_hremove(self):
alpha, beta = self._create_bags()
self.assertEqual(SerializedDataBag.objects.get(name='alpha').data, alpha.data)
SerializedDataBag.objects.filter(name='alpha').hremove('data', 'v2')
self.assertEqual(SerializedDataBag.objects.get(name='alpha').data, {'v': 1, 'v3': {'a': 1}})
self.assertEqual(SerializedDataBag.objects.get(name='beta').data, beta.data)
SerializedDataBag.objects.filter(name='beta').hremove('data', ['v', 'v2', 'v3'])
self.assertEqual(SerializedDataBag.objects.get(name='beta').data, {})
def test_hslice(self):
alpha, beta = self._create_bags()
self.assertEqual(SerializedDataBag.objects.hslice(id=alpha.id, attr='data', keys=['v']), {'v': 1})
self.assertEqual(SerializedDataBag.objects.filter(id=alpha.id).hslice(attr='data', keys=['v']), {'v': 1})
self.assertEqual(SerializedDataBag.objects.hslice(id=alpha.id, attr='data', keys=['ggg']), {})
def test_hupdate(self):
alpha, beta = self._create_bags()
self.assertEqual(SerializedDataBag.objects.get(name='alpha').data, alpha.data)
SerializedDataBag.objects.filter(name='alpha').hupdate('data', {'v2': '10', 'v3': {'a': '20'}})
self.assertEqual(SerializedDataBag.objects.get(name='alpha').data, {'v': 1, 'v2': '10', 'v3': {'a': '20'}})
def test_hstore_model_field_validation(self):
d = SerializedDataBag()
with self.assertRaises(ValidationError):
d.full_clean()
d.data = 'test'
with self.assertRaises(ValidationError):
d.full_clean()
d.data = '["test"]'
with self.assertRaises(ValidationError):
d.full_clean()
d.data = ["test"]
with self.assertRaises(ValidationError):
d.full_clean()
d.data = {
'a': 1,
'b': 2.2,
'c': ['a', 'b'],
'd': {'test': 'test'}
}
with self.assertRaises(ValidationError):
d.full_clean()
def test_admin_widget(self):
alpha, beta = self._create_bags()
# create admin user
admin = User.objects.create(username='admin', password='tester', is_staff=True, is_superuser=True, is_active=True)
admin.set_password('tester')
admin.save()
# login as admin
self.client.login(username='admin', password='tester')
# access admin change form page
url = reverse('admin:django_hstore_tests_serializeddatabag_change', args=[alpha.id])
response = self.client.get(url)
# ensure textarea with id="id_data" is there
self.assertContains(response, 'textarea')
self.assertContains(response, 'id_data')
def test_dictionary_default_admin_widget(self):
class HForm(forms.ModelForm):
class Meta:
model = SerializedDataBag
exclude = []
form = HForm()
self.assertEqual(form.fields['data'].widget.__class__, SerializedDictionaryFieldWidget)
def test_dictionary_custom_admin_widget(self):
class CustomWidget(forms.Widget):
pass
class HForm(forms.ModelForm):
class Meta:
model = SerializedDataBag
widgets = {'data': CustomWidget}
exclude = []
form = HForm()
self.assertEqual(form.fields['data'].widget.__class__, CustomWidget)
def test_properties_hstore(self):
"""
Make sure the hstore field does what it is supposed to.
"""
instance = SerializedDataBag()
test_props = {'foo': 'bar', 'size': '3'}
instance.name = "foo"
instance.data = test_props
instance.save()
self.assertIsInstance(instance.data, dict)
self.assertEqual(instance.data, test_props)
instance = SerializedDataBag.objects.get(pk=instance.pk)
self.assertIsInstance(instance.data, dict)
self.assertEqual(instance.data, test_props)
self.assertEqual(instance.data['size'], '3')
self.assertIn('foo', instance.data)
def test_unicode(self):
i = SerializedDataBag()
i.data['key'] = 'è'
i.save()
i.data['key'] = u'è'
i.save()
def test_str(self):
d = SerializedDataBag()
self.assertEqual(str(d.data), '{}')
django-hstore-1.5~alpha~git20161126+dfsg/tests/django_hstore_tests/tests/test_schema_mode.py 0000664 0001750 0001750 00000042411 13016340771 032454 0 ustar kitterma kitterma # -*- coding: utf-8 -*-
import os
import shutil
import sys
import django
from django.contrib.auth.models import User
from django.core.exceptions import ValidationError
from django.core.management import call_command
from django.core.urlresolvers import reverse
from django.db import models
from django.test import TestCase
from django_hstore import hstore
from django_hstore.virtual import create_hstore_virtual_field
from django_hstore_tests.models import NullSchemaDataBag, SchemaDataBag
if sys.version_info[0] >= 3:
from io import StringIO
else:
from StringIO import StringIO
MIGRATION_PATH = '{0}/../{1}'.format(os.path.dirname(__file__), 'migrations')
class TestSchemaMode(TestCase):
@classmethod
def tearDownClass(cls):
TestSchemaMode._delete_migrations()
@classmethod
def _delete_migrations(cls):
# delete migration files
try:
shutil.rmtree(MIGRATION_PATH)
except OSError:
pass
def _login_as_admin(self):
# create admin user
admin = User.objects.create(username='admin', password='tester', is_staff=True, is_superuser=True, is_active=True)
admin.set_password('tester')
admin.save()
# login as admin
self.client.login(username='admin', password='tester')
def test_to_python_conversion(self):
d = SchemaDataBag().data
d['number'] = 2
self.assertEqual(d['number'], 2)
d['boolean'] = True
self.assertTrue(d['boolean'])
d['boolean'] = False
self.assertFalse(d['boolean'])
d['float'] = 2.5
self.assertEqual(d['float'], 2.5)
self.assertEqual(d.get('float'), 2.5)
def test_dict_get(self):
d = SchemaDataBag().data
d['number'] = 2
self.assertEqual(d.get('number'), 2)
self.assertEqual(d.get('default_test', 'default'), 'default')
self.assertIsNone(d.get('default_test'))
def test_virtual_field_default_value(self):
d = SchemaDataBag()
self.assertEqual(d.number, 0)
self.assertEqual(d.float, 1.0)
# accessing the HStoreDict key raises KeyError if not assigned previously
with self.assertRaises(KeyError):
d.data['number']
def test_virtual_field_called_statically(self):
with self.assertRaises(AttributeError):
SchemaDataBag.number
def test_schemadatabag_assignment(self):
d = SchemaDataBag()
d.number = 4
self.assertEqual(d.data['number'], 4)
d.float = 2.5
self.assertEqual(d.data['float'], 2.5)
d.data['number'] = 5
self.assertEqual(d.number, 5)
def test_schemadatabag_save(self):
d = SchemaDataBag()
d.name = 'test'
d.number = 4
d.float = 2.0
d.save()
d = SchemaDataBag.objects.get(pk=d.id)
self.assertEqual(d.number, 4)
self.assertEqual(d.data['number'], 4)
def test_schemadatabag_validation_error(self):
d = SchemaDataBag()
d.name = 'test'
d.number = 'WRONG'
d.float = 2.0
with self.assertRaises(ValidationError):
d.full_clean()
d.number = 9
d.float = 'WRONG'
with self.assertRaises(ValidationError):
d.full_clean()
d.float = 2.0
d.char = 'test'
d.choice = 'choice1'
d.full_clean()
d.save()
def test_admin_list(self):
self._login_as_admin()
url = reverse('admin:django_hstore_tests_schemadatabag_changelist')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
def test_admin_add(self):
self._login_as_admin()
url = reverse('admin:django_hstore_tests_schemadatabag_add')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
response = self.client.post(url, {'name': 'test_add', 'number': 3, 'float': 2.4})
d = SchemaDataBag.objects.all()[0]
self.assertEqual(d.name, 'test_add')
self.assertEqual(d.number, 3)
self.assertEqual(d.float, 2.4)
def test_admin_add_utf8(self):
self._login_as_admin()
url = reverse('admin:django_hstore_tests_schemadatabag_add')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
response = self.client.post(url, {'name': 'test_add', 'number': 3, 'float': 2.4, 'char': 'è'})
d = SchemaDataBag.objects.all()[0]
self.assertEqual(d.name, 'test_add')
self.assertEqual(d.number, 3)
self.assertEqual(d.float, 2.4)
def test_admin_change(self):
self._login_as_admin()
d = SchemaDataBag()
d.name = 'test1'
d.number = 1
d.float = 2.5
d.save()
url = reverse('admin:django_hstore_tests_schemadatabag_change', args=[d.id])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
response = self.client.post(url, {'name': 'test_change', 'number': 6, 'float': 2.6})
d = SchemaDataBag.objects.get(pk=d.id)
self.assertEqual(d.name, 'test_change')
self.assertEqual(d.number, 6)
self.assertEqual(d.data['number'], 6)
self.assertEqual(d.float, 2.6)
self.assertEqual(d.data['float'], 2.6)
def test_create_hstore_virtual_field(self):
integer = create_hstore_virtual_field('IntegerField', {'default': 0}, 'data')
self.assertIsInstance(integer, models.IntegerField)
char = create_hstore_virtual_field('CharField', {'default': 'test', 'blank': True, 'max_length': 10}, 'data')
self.assertIsInstance(char, models.CharField)
text = create_hstore_virtual_field('TextField', {'blank': True}, 'data')
self.assertIsInstance(text, models.TextField)
def test_create_hstore_virtual_field_wrong_class(self):
with self.assertRaises(ValueError):
create_hstore_virtual_field(float, {'blank': True}, 'data')
def test_create_hstore_virtual_field_wrong_class_string(self):
with self.assertRaises(ValueError):
create_hstore_virtual_field('IdoNotExist', {'blank': True}, 'data')
def test_create_hstore_virtual_field_concrete_class(self):
integer = create_hstore_virtual_field(models.IntegerField, {'default': 0}, 'data')
url = create_hstore_virtual_field(models.URLField, {'blank': True}, 'data')
self.assertTrue(isinstance(integer, models.IntegerField))
self.assertTrue(isinstance(url, models.URLField))
def test_DictionaryField_with_schema(self):
hstore.DictionaryField(schema=[
{
'name': 'number',
'class': 'IntegerField',
'kwargs': {
'default': 0,
'verbose_name': 'verbose number'
}
}
])
def test_schema_validation_string(self):
with self.assertRaises(ValueError):
hstore.DictionaryField(schema='')
with self.assertRaises(ValueError):
hstore.DictionaryField(schema='WRONG')
def test_schema_validation_wrong_list(self):
with self.assertRaises(ValueError):
hstore.DictionaryField(schema=[])
with self.assertRaises(ValueError):
hstore.DictionaryField(schema=['i am teasing you'])
def test_schema_validation_wrong_dict(self):
with self.assertRaises(ValueError):
hstore.DictionaryField(schema=[
{'wrong': 'wrong'}
])
with self.assertRaises(ValueError):
hstore.DictionaryField(schema=[
{'name': 'test'}
])
def test_utf8(self):
d = SchemaDataBag()
d.name = 'test'
d.number = 4
d.float = 2.0
d.char = 'è'
d.full_clean()
d.save()
d = SchemaDataBag.objects.get(pk=d.id)
self.assertEqual(d.char, u'è')
d.char = u'è'
d.full_clean()
d.save()
d = SchemaDataBag.objects.get(pk=d.id)
self.assertEqual(d.char, u'è')
def test_create(self):
s1 = SchemaDataBag.objects.create(
name='create1',
number=2,
float=2.2,
boolean=True,
boolean_true=False,
choice='choice2',
choice2='choice1',
char='create2',
text='create3'
)
s1 = SchemaDataBag.objects.get(pk=s1.pk)
self.assertEqual(s1.name, 'create1')
self.assertEqual(s1.number, 2)
self.assertEqual(s1.float, 2.2)
self.assertEqual(s1.boolean, True)
self.assertEqual(s1.boolean_true, False)
self.assertEqual(s1.choice, 'choice2')
self.assertEqual(s1.choice2, 'choice1')
self.assertEqual(s1.char, 'create2')
self.assertEqual(s1.text, 'create3')
def test_extra_key_regression(self):
s = SchemaDataBag()
s.data['extrakey'] = 2
self.assertEqual(s.data['extrakey'], '2')
def test_virtual_date_drf_support(self):
class FakeModel(object):
date = '2014-08-08'
virtual_date = SchemaDataBag()._hstore_virtual_fields['date']
self.assertEqual(virtual_date.value_to_string(FakeModel()), '2014-08-08')
def test_basefield_attribute(self):
virtual_field = SchemaDataBag()._hstore_virtual_fields['char']
self.assertEqual(virtual_field.__basefield__.__name__, 'CharField')
def test_str(self):
d = SchemaDataBag()
self.assertEqual(str(d.data), '{}')
if django.VERSION >= (1, 8):
def test_reload_schema(self):
# cache some stuff
f = SchemaDataBag._meta.get_field('data')
original_schema = list(f.schema)
local_fields_length = len(SchemaDataBag._meta.local_fields)
hstore_virtual_fields_keys = list(SchemaDataBag._hstore_virtual_fields.keys())
# original state
d = SchemaDataBag()
self.assertTrue(d.data.schema_mode)
self.assertEqual(len(SchemaDataBag._meta.virtual_fields), len(original_schema))
self.assertEqual(len(SchemaDataBag._meta.fields), len(original_schema) + local_fields_length)
self.assertEqual(len(SchemaDataBag._meta.local_fields), 3)
self.assertTrue(hasattr(SchemaDataBag, '_hstore_virtual_fields'))
for key in hstore_virtual_fields_keys:
self.assertTrue(hasattr(d, key))
# schema erased
f.reload_schema(None)
self.assertIsNone(f.schema)
self.assertFalse(f.schema_mode)
self.assertTrue(f.editable)
self.assertEqual(len(SchemaDataBag._meta.virtual_fields), 0)
self.assertEqual(len(SchemaDataBag._meta.fields), local_fields_length)
self.assertEqual(len(SchemaDataBag._meta.local_fields), local_fields_length)
self.assertFalse(hasattr(SchemaDataBag, '_hstore_virtual_fields'))
d = SchemaDataBag()
self.assertFalse(d.data.schema_mode)
for key in hstore_virtual_fields_keys:
self.assertFalse(hasattr(d, key))
# reload original schema
f.reload_schema(original_schema)
d = SchemaDataBag()
self.assertTrue(d.data.schema_mode)
self.assertEqual(len(SchemaDataBag._meta.virtual_fields), len(original_schema))
self.assertEqual(len(SchemaDataBag._meta.fields), len(original_schema) + local_fields_length)
self.assertEqual(len(SchemaDataBag._meta.local_fields), 3)
self.assertTrue(hasattr(SchemaDataBag, '_hstore_virtual_fields'))
for key in hstore_virtual_fields_keys:
self.assertTrue(hasattr(d, key))
else:
# TODO: will removed when django 1.7 will be deprecated
def test_reload_schema(self):
# cache some stuff
f = SchemaDataBag._meta.get_field('data')
original_schema = list(f.schema)
concrete_fields_length = len(SchemaDataBag._meta.concrete_fields)
hstore_virtual_fields_keys = list(SchemaDataBag._hstore_virtual_fields.keys())
# original state
d = SchemaDataBag()
self.assertTrue(d.data.schema_mode)
self.assertEqual(len(SchemaDataBag._meta.virtual_fields), len(original_schema))
self.assertEqual(len(SchemaDataBag._meta.fields), len(original_schema) + concrete_fields_length)
self.assertEqual(len(SchemaDataBag._meta.local_fields), len(original_schema) + concrete_fields_length)
self.assertTrue(hasattr(SchemaDataBag, '_hstore_virtual_fields'))
for key in hstore_virtual_fields_keys:
self.assertTrue(hasattr(d, key))
# schema erased
f.reload_schema(None)
self.assertIsNone(f.schema)
self.assertFalse(f.schema_mode)
self.assertTrue(f.editable)
self.assertEqual(len(SchemaDataBag._meta.virtual_fields), 0)
self.assertEqual(len(SchemaDataBag._meta.fields), concrete_fields_length)
self.assertEqual(len(SchemaDataBag._meta.local_fields), concrete_fields_length)
self.assertFalse(hasattr(SchemaDataBag, '_hstore_virtual_fields'))
d = SchemaDataBag()
self.assertFalse(d.data.schema_mode)
for key in hstore_virtual_fields_keys:
self.assertFalse(hasattr(d, key))
# reload original schema
f.reload_schema(original_schema)
d = SchemaDataBag()
self.assertTrue(d.data.schema_mode)
self.assertEqual(len(SchemaDataBag._meta.virtual_fields), len(original_schema))
self.assertEqual(len(SchemaDataBag._meta.fields), len(original_schema) + concrete_fields_length)
self.assertEqual(len(SchemaDataBag._meta.local_fields), len(original_schema) + concrete_fields_length)
self.assertTrue(hasattr(SchemaDataBag, '_hstore_virtual_fields'))
for key in hstore_virtual_fields_keys:
self.assertTrue(hasattr(d, key))
def test_datetime_is_none(self):
""" issue #82 https://github.com/djangonauts/django-hstore/issues/82 """
d = SchemaDataBag()
d.name = 'datetime'
self.assertIsNone(d.datetime, None)
d.full_clean()
d.save()
d = SchemaDataBag.objects.get(name='datetime')
self.assertIsNone(d.datetime, None)
def test_none_handling(self):
""" failing test for https://github.com/djangonauts/django-hstore/pull/92 """
d = NullSchemaDataBag()
self.assertIsNone(d.data)
d.char = 'testing'
d.number = 2
self.assertEqual(d.char, 'testing')
self.assertEqual(d.number, 2)
d.char = ''
d.number = 0
self.assertEqual(d.char, '')
self.assertEqual(d.number, 0)
if django.VERSION >= (1, 7):
def _test_migrations_issue_103(self):
""" failing test for https://github.com/djangonauts/django-hstore/issues/103 """
# start capturing output
output = StringIO()
sys.stdout = output
call_command('makemigrations', 'django_hstore_tests')
# stop capturing print statements
sys.stdout = sys.__stdout__
self.assertIn('No changes detected', output.getvalue())
# add a new migration which replicates the bug in #103
with open('{0}/{1}'.format(MIGRATION_PATH, '0002_issue_103.py'), 'w') as f:
f.write("""# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
import datetime
import django_hstore.virtual
class Migration(migrations.Migration):
dependencies = [
('django_hstore_tests', '0001_initial'),
]
operations = [
migrations.AlterField(
model_name='schemadatabag',
name='datetime',
field=django_hstore.virtual.VirtualField(default=datetime.datetime(2015, 4, 19, 16, 44, 9, 417872)),
preserve_default=True,
),
]""")
f.close()
# start capturing output
output = StringIO()
sys.stdout = output
call_command('migrate', 'django_hstore_tests', fake_initial=True)
# stop capturing print statements
sys.stdout = sys.__stdout__
self.assertIn('Applying django_hstore_tests.0002_issue_103... OK', output.getvalue())
def _test_migrations_issue_117(self):
""" failing test for https://github.com/djangonauts/django-hstore/issues/117 """
# start capturing output
output = StringIO()
sys.stdout = output
call_command('makemigrations', 'django_hstore_tests')
# stop capturing print statements
sys.stdout = sys.__stdout__
self.assertIn('0001_initial', output.getvalue())
# start capturing output
output = StringIO()
sys.stdout = output
call_command('makemigrations', 'django_hstore_tests')
# stop capturing print statements
sys.stdout = sys.__stdout__
self.assertIn('No changes detected', output.getvalue())
def test_migrations(self):
self._test_migrations_issue_117()
# changes in django 1.8 make this test obsolete
if django.VERSION == (1, 7):
self._test_migrations_issue_103()
TestSchemaMode._delete_migrations()
django-hstore-1.5~alpha~git20161126+dfsg/tests/django_hstore_tests/tests/test_reference_field.py 0000664 0001750 0001750 00000020141 13016340771 033305 0 ustar kitterma kitterma from django import forms
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
from django.test import TestCase
from django_hstore.forms import ReferencesFieldWidget
from django_hstore.utils import acquire_reference, serialize_references, unserialize_references
from django_hstore_tests.models import NullableRefsBag, Ref, RefsBag
class TestReferencesField(TestCase):
def setUp(self):
Ref.objects.all().delete()
RefsBag.objects.all().delete()
def _create_bags(self):
refs = [Ref.objects.create(name=str(i)) for i in range(4)]
alpha = RefsBag.objects.create(name='alpha', refs={'0': refs[0], '1': refs[1]})
beta = RefsBag.objects.create(name='beta', refs={'0': refs[2], '1': refs[3]})
return alpha, beta, refs
def test_empty_instantiation(self):
bag = RefsBag.objects.create(name='bag')
self.assertTrue(isinstance(bag.refs, dict))
self.assertEqual(bag.refs, {})
def test_unsaved_empty_instantiation(self):
bag = RefsBag(name='bag')
self.assertEqual(bag.refs.get('idontexist', 'default'), 'default')
self.assertTrue(isinstance(bag.refs, dict))
def test_unsave_empty_instantiation_of_nullable_ref(self):
bag = NullableRefsBag(name='bag')
self.assertEqual(bag.refs.get('idontexist', 'default'), 'default')
self.assertTrue(isinstance(bag.refs, dict))
def test_simple_retrieval(self):
alpha, beta, refs = self._create_bags()
alpha = RefsBag.objects.get(name='alpha')
self.assertEqual(Ref.objects.get(name='0'), alpha.refs['0'])
def test_simple_retrieval_get(self):
alpha, beta, refs = self._create_bags()
alpha = RefsBag.objects.get(name='alpha')
self.assertEqual(Ref.objects.get(name='0'), alpha.refs.get('0'))
# try getting a non existent key
self.assertEqual(alpha.refs.get('idontexist', 'default'), 'default')
self.assertEqual(alpha.refs.get('idontexist'), None)
def test_empty_querying(self):
RefsBag.objects.create(name='bag')
self.assertTrue(RefsBag.objects.get(refs={}))
self.assertTrue(RefsBag.objects.filter(refs={}))
self.assertTrue(RefsBag.objects.filter(refs__contains={}))
def test_equivalence_querying(self):
alpha, beta, refs = self._create_bags()
for bag in (alpha, beta):
refs = {'0': bag.refs['0'], '1': bag.refs['1']}
self.assertEqual(RefsBag.objects.get(refs=refs), bag)
r = RefsBag.objects.filter(refs=refs)
self.assertEqual(len(r), 1)
self.assertEqual(r[0], bag)
def test_key_value_subset_querying(self):
alpha, beta, refs = self._create_bags()
for bag in (alpha, beta):
r = RefsBag.objects.filter(refs__contains={'0': bag.refs['0']})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], bag)
r = RefsBag.objects.filter(refs__contains={'0': bag.refs['0'], '1': bag.refs['1']})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], bag)
def test_multiple_key_subset_querying(self):
alpha, beta, refs = self._create_bags()
for keys in (['0'], ['0', '1']):
self.assertEqual(RefsBag.objects.filter(refs__contains=keys).count(), 2)
for keys in (['0', 'nv'], ['n1', 'n2']):
self.assertEqual(RefsBag.objects.filter(refs__contains=keys).count(), 0)
def test_single_key_querying(self):
alpha, beta, refs = self._create_bags()
for key in ('0', '1'):
self.assertEqual(RefsBag.objects.filter(refs__contains=[key]).count(), 2)
for key in ('n1', 'n2'):
self.assertEqual(RefsBag.objects.filter(refs__contains=[key]).count(), 0)
def test_hkeys(self):
alpha, beta, refs = self._create_bags()
self.assertEqual(RefsBag.objects.hkeys(id=alpha.id, attr='refs'), ['0', '1'])
def test_hpeek(self):
alpha, beta, refs = self._create_bags()
self.assertEqual(RefsBag.objects.hpeek(id=alpha.id, attr='refs', key='0'), refs[0])
self.assertEqual(RefsBag.objects.filter(id=alpha.id).hpeek(attr='refs', key='0'), refs[0])
self.assertEqual(RefsBag.objects.hpeek(id=alpha.id, attr='refs', key='invalid'), None)
def test_hremove(self):
alpha, beta, refs = self._create_bags()
self.assertEqual(RefsBag.objects.get(name='alpha').refs['0'], alpha.refs['0'])
self.assertEqual(RefsBag.objects.get(name='alpha').refs['1'], alpha.refs['1'])
self.assertIn("0", RefsBag.objects.get(name='alpha').refs)
RefsBag.objects.filter(name='alpha').hremove('refs', '0')
self.assertNotIn("0", RefsBag.objects.get(name='alpha').refs)
self.assertIn("1", RefsBag.objects.get(name='alpha').refs)
self.assertEqual(RefsBag.objects.get(name='beta').refs['0'], beta.refs['0'])
self.assertEqual(RefsBag.objects.get(name='beta').refs['1'], beta.refs['1'])
RefsBag.objects.filter(name='beta').hremove('refs', ['0', '1'])
self.assertEqual(RefsBag.objects.get(name='beta').refs, {})
def test_hslice(self):
alpha, beta, refs = self._create_bags()
self.assertEqual(RefsBag.objects.hslice(id=alpha.id, attr='refs', keys=['0']), {'0': refs[0]})
self.assertEqual(RefsBag.objects.filter(id=alpha.id).hslice(attr='refs', keys=['0']), {'0': refs[0]})
self.assertEqual(RefsBag.objects.hslice(id=alpha.id, attr='refs', keys=['invalid']), {})
def test_admin_reference_field(self):
alpha, beta, refs = self._create_bags()
# create admin user
admin = User.objects.create(username='admin', password='tester', is_staff=True, is_superuser=True, is_active=True)
admin.set_password('tester')
admin.save()
# login as admin
self.client.login(username='admin', password='tester')
# access admin change form page
url = reverse('admin:django_hstore_tests_refsbag_change', args=[alpha.id])
response = self.client.get(url)
# ensure textarea with id="id_data" is there
self.assertContains(response, 'textarea')
self.assertContains(response, 'id_refs')
def test_unserialize_references_edge_cases(self):
alpha, beta, refs = self._create_bags()
refs = unserialize_references(alpha.refs)
# repeat
refs = unserialize_references(alpha.refs)
self.assertEqual(len(unserialize_references(refs).keys()), 2)
self.assertEqual(unserialize_references(None), {})
def test_unserialize_references(self):
alpha, beta, refs = self._create_bags()
ref = dict(alpha=alpha, beta=beta)
serialized_refs = serialize_references(ref)
unserialized_refs = unserialize_references(serialized_refs)
self.assertEqual(unserialized_refs['alpha'].pk, alpha.pk)
self.assertEqual(unserialized_refs['beta'].pk, beta.pk)
def test_serialize_references_edge_cases(self):
self.assertEqual(serialize_references(None), {})
self.assertEqual(serialize_references({'test': 'test'}), {'test': 'test'})
def test_acquire_references_value_error(self):
with self.assertRaises(ValueError):
acquire_reference(None)
with self.assertRaises(ValueError):
acquire_reference('')
def test_acquire_references_none(self):
self.assertIsNone(acquire_reference('django_hstore_tests.models.SchemaDataBag:2'))
def test_str(self):
r = RefsBag()
self.assertEqual(str(r.refs), '{}')
def test_references_default_admin_widget(self):
class HForm(forms.ModelForm):
class Meta:
model = RefsBag
exclude = []
form = HForm()
self.assertEqual(form.fields['refs'].widget.__class__, ReferencesFieldWidget)
def test_references_custom_admin_widget(self):
class CustomWidget(forms.Widget):
pass
class HForm(forms.ModelForm):
class Meta:
model = RefsBag
widgets = {'refs': CustomWidget}
exclude = []
form = HForm()
self.assertEqual(form.fields['refs'].widget.__class__, CustomWidget)
django-hstore-1.5~alpha~git20161126+dfsg/tests/django_hstore_tests/tests/test_not_transactional.py 0000664 0001750 0001750 00000001747 13016340771 033741 0 ustar kitterma kitterma from django import VERSION as DJANGO_VERSION
from django.db import connection, transaction
from django.test import SimpleTestCase
from django_hstore.fields import HStoreDict
from django_hstore_tests.models import DataBag
class TestNotTransactional(SimpleTestCase):
allow_database_queries = True
if DJANGO_VERSION[:2] >= (1, 8):
def setUp(self):
# avoid error "connection already closed"
connection.connect()
def test_hstore_registring_in_transaction_block(self):
obj1 = DataBag.objects.create(name='alpha1', data={'v': '1', 'v2': '3'})
obj2 = DataBag.objects.create(name='alpha2', data={'v': '1', 'v2': '3'})
# Close any existing connection before doing anything
connection.close()
with transaction.atomic():
qs = DataBag.objects.filter(name__in=["alpha2", "alpha1"])
self.assertIsInstance(qs[0].data, HStoreDict)
obj1.delete()
obj2.delete()
connection.close()
django-hstore-1.5~alpha~git20161126+dfsg/tests/django_hstore_tests/tests/test_dictionary_field.py 0000664 0001750 0001750 00000065064 13016340771 033531 0 ustar kitterma kitterma # -*- coding: utf-8 -*-
import datetime
import json
import pickle
import sys
from decimal import Decimal
from django import VERSION as DJANGO_VERSION
from django import forms
from django.contrib.auth.models import User
from django.core.exceptions import ValidationError
from django.core.urlresolvers import reverse
from django.db import transaction
from django.db.models.aggregates import Count
from django.db.utils import IntegrityError
from django.test import TestCase
from django.utils.encoding import force_text
from django_hstore import get_version
from django_hstore.exceptions import HStoreDictException
from django_hstore.fields import HStoreDict
from django_hstore.forms import DictionaryFieldWidget
from django_hstore.utils import get_cast_for_param
from django_hstore_tests.models import (
BadDefaultsModel,
DataBag,
DefaultsModel,
NullableDataBag,
NumberedDataBag,
UniqueTogetherDataBag
)
class TestDictionaryField(TestCase):
def setUp(self):
DataBag.objects.all().delete()
def _create_bags(self):
alpha = DataBag.objects.create(name='alpha', data={'v': '1', 'v2': '3'})
beta = DataBag.objects.create(name='beta', data={'v': '2', 'v2': '4'})
return alpha, beta
def _create_bitfield_bags(self):
# create dictionaries with bits as dictionary keys (i.e. bag5 = {'b0':'1', 'b2':'1'})
for i in range(10):
DataBag.objects.create(name='bag%d' % (i,),
data=dict(('b%d' % (bit,), '1') for bit in range(4) if (1 << bit) & i))
def test_hstore_dict(self):
alpha, beta = self._create_bags()
self.assertEqual(alpha.data, {'v': '1', 'v2': '3'})
self.assertEqual(beta.data, {'v': '2', 'v2': '4'})
def test_decimal(self):
databag = DataBag(name='decimal')
databag.data['dec'] = Decimal('1.01')
self.assertEqual(databag.data['dec'], force_text(Decimal('1.01')))
databag.save()
databag = DataBag.objects.get(name='decimal')
self.assertEqual(databag.data['dec'], force_text(Decimal('1.01')))
databag = DataBag(name='decimal', data={'dec': Decimal('1.01')})
self.assertEqual(databag.data['dec'], force_text(Decimal('1.01')))
def test_long(self):
if sys.version < '3':
l = long(100000000000) # noqa
databag = DataBag(name='long')
databag.data['long'] = l
self.assertEqual(databag.data['long'], force_text(l))
databag.save()
databag = DataBag.objects.get(name='long')
self.assertEqual(databag.data['long'], force_text(l))
databag = DataBag(name='long', data={'long': l})
self.assertEqual(databag.data['long'], force_text(l))
def test_number(self):
databag = DataBag(name='number')
databag.data['num'] = 1
self.assertEqual(databag.data['num'], '1')
databag.save()
databag = DataBag.objects.get(name='number')
self.assertEqual(databag.data['num'], '1')
databag = DataBag(name='number', data={'num': 1})
self.assertEqual(databag.data['num'], '1')
def test_list(self):
databag = DataBag.objects.create(name='list', data={'list': ['a', 'b', 'c']})
databag = DataBag.objects.get(name='list')
self.assertEqual(json.loads(databag.data['list']), ['a', 'b', 'c'])
def test_dictionary(self):
databag = DataBag.objects.create(name='dict', data={'dict': {'subkey': 'subvalue'}})
databag = DataBag.objects.get(name='dict')
self.assertEqual(json.loads(databag.data['dict']), {'subkey': 'subvalue'})
databag.data['dict'] = {'subkey': True, 'list': ['a', 'b', False]}
databag.save()
self.assertEqual(json.loads(databag.data['dict']), {'subkey': True, 'list': ['a', 'b', False]})
def test_boolean(self):
databag = DataBag.objects.create(name='boolean', data={'boolean': True})
databag = DataBag.objects.get(name='boolean')
self.assertEqual(json.loads(databag.data['boolean']), True)
self.assertTrue(DataBag.objects.get(data__contains={'boolean': True}))
def test_is_pickable(self):
m = DefaultsModel()
m.save()
try:
pickle.dumps(m)
except TypeError as e:
self.fail('pickle of DefaultsModel failed: %s' % e)
def test_empty_instantiation(self):
bag = DataBag.objects.create(name='bag')
self.assertTrue(isinstance(bag.data, dict))
self.assertEqual(bag.data, {})
def test_empty_querying(self):
DataBag.objects.create(name='bag')
self.assertTrue(DataBag.objects.get(data={}))
self.assertTrue(DataBag.objects.filter(data={}))
self.assertTrue(DataBag.objects.filter(data__contains={}))
def test_nullable_queryinig(self):
# backward incompatible change in 1.3.3:
# default value of a dictionary field which is can be null will never be None
# but always an empty HStoreDict
NullableDataBag.objects.create(name='nullable')
self.assertFalse(NullableDataBag.objects.filter(data__exact=None))
self.assertFalse(NullableDataBag.objects.filter(data__isnull=True))
self.assertTrue(NullableDataBag.objects.filter(data__isnull=False))
def test_nullable_set(self):
n = NullableDataBag()
n.data['test'] = 'test'
self.assertEqual(n.data['test'], 'test')
def test_nullable_get(self):
n = NullableDataBag()
self.assertEqual(n.data.get('test', 'test'), 'test')
self.assertEqual(n.data.get('test', False), False)
self.assertEqual(n.data.get('test'), None)
def test_nullable_getitem(self):
n = NullableDataBag()
with self.assertRaises(KeyError):
n.data['test']
def test_null_values(self):
null_v = DataBag.objects.create(name="test", data={"v": None})
nonnull_v = DataBag.objects.create(name="test", data={"v": "item"})
r = DataBag.objects.filter(data__isnull={"v": True})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], null_v)
r = DataBag.objects.filter(data__isnull={"v": False})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], nonnull_v)
def test_named_querying(self):
alpha, beta = self._create_bags()
self.assertEqual(DataBag.objects.get(name='alpha'), alpha)
self.assertEqual(DataBag.objects.filter(name='beta')[0], beta)
def test_aggregates(self):
self._create_bitfield_bags()
self.assertEqual(DataBag.objects.filter(data__contains={'b0': '1'}).aggregate(Count('id'))['id__count'], 5)
self.assertEqual(DataBag.objects.filter(data__contains={'b1': '1'}).aggregate(Count('id'))['id__count'], 4)
def test_annotations(self):
self._create_bitfield_bags()
self.assertEqual(DataBag.objects.annotate(num_id=Count('id')).filter(num_id=1)[0].num_id, 1)
def test_nested_filtering(self):
self._create_bitfield_bags()
# Test cumulative successive filters for both dictionaries and other fields
f = DataBag.objects.all()
self.assertEqual(10, f.count())
f = f.filter(data__contains={'b0': '1'})
self.assertEqual(5, f.count())
f = f.filter(data__contains={'b1': '1'})
self.assertEqual(2, f.count())
f = f.filter(name='bag3')
self.assertEqual(1, f.count())
def test_unicode_processing(self):
greets = {
u'de': u'Gr\xfc\xdfe, Welt',
u'en': u'hello, world',
u'es': u'hola, ma\xf1ana',
u'he': u'\u05e9\u05dc\u05d5\u05dd, \u05e2\u05d5\u05dc\u05dd',
u'jp': u'\u3053\u3093\u306b\u3061\u306f\u3001\u4e16\u754c',
u'zh': u'\u4f60\u597d\uff0c\u4e16\u754c',
}
DataBag.objects.create(name='multilang', data=greets)
self.assertEqual(greets, DataBag.objects.get(name='multilang').data)
def test_query_escaping(self):
me = self
def readwrite(s):
# try create and query with potentially illegal characters in the field and dictionary key/value
o = DataBag.objects.create(name=s, data={s: s})
me.assertEqual(o, DataBag.objects.get(name=s, data={s: s}))
readwrite('\' select')
readwrite('% select')
readwrite('\\\' select')
readwrite('-- select')
readwrite('\n select')
readwrite('\r select')
readwrite('* select')
def test_replace_full_dictionary(self):
DataBag.objects.create(name='foo', data={'change': 'old value', 'remove': 'baz'})
replacement = {'change': 'new value', 'added': 'new'}
DataBag.objects.filter(name='foo').update(data=replacement)
self.assertEqual(replacement, DataBag.objects.get(name='foo').data)
def test_equivalence_querying(self):
alpha, beta = self._create_bags()
for bag in (alpha, beta):
data = {'v': bag.data['v'], 'v2': bag.data['v2']}
self.assertEqual(DataBag.objects.get(data=data), bag)
r = DataBag.objects.filter(data=data)
self.assertEqual(len(r), 1)
self.assertEqual(r[0], bag)
def test_key_value_subset_querying(self):
alpha, beta = self._create_bags()
for bag in (alpha, beta):
r = DataBag.objects.filter(data__contains={'v': bag.data['v']})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], bag)
r = DataBag.objects.filter(data__contains={'v': bag.data['v'], 'v2': bag.data['v2']})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], bag)
def test_value_in_subset_querying(self):
alpha, beta = self._create_bags()
res = DataBag.objects.filter(data__contains={'v': [alpha.data['v']]})
self.assertEqual(len(res), 1)
self.assertEqual(res[0], alpha)
res = DataBag.objects.filter(data__contains={'v': [alpha.data['v'], beta.data['v']]})
self.assertEqual(len(res), 2)
self.assertEqual(set(res), set([alpha, beta]))
# int values are ok
r = DataBag.objects.filter(data__contains={'v': [int(alpha.data['v'])]})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], alpha)
def test_key_value_gt_querying(self):
alpha, beta = self._create_bags()
self.assertGreater(beta.data['v'], alpha.data['v'])
r = DataBag.objects.filter(data__gt={'v': alpha.data['v']})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], beta)
r = DataBag.objects.filter(data__gte={'v': alpha.data['v']})
self.assertEqual(len(r), 2)
def test_key_value_gt_casting_number_query(self):
alpha = DataBag.objects.create(name='alpha', data={'v': 10})
DataBag.objects.create(name='alpha', data={'v': 1})
r = DataBag.objects.filter(data__gt={'v': 2})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], alpha)
def test_key_value_contains_casting_date_query(self):
date = datetime.date(2014, 9, 28)
alpha = DataBag.objects.create(name='alpha', data={'v': date.isoformat()})
r = DataBag.objects.filter(data__contains={'v': date})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], alpha)
def test_multiple_key_value_gt_querying(self):
alpha, beta = self._create_bags()
self.assertGreater(beta.data['v'], alpha.data['v'])
r = DataBag.objects.filter(data__gt={'v': alpha.data['v'], 'v2': alpha.data['v2']})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], beta)
r = DataBag.objects.filter(data__gt={'v': alpha.data['v'], 'v2': beta.data['v2']})
self.assertEqual(len(r), 0)
r = DataBag.objects.filter(data__gte={'v': alpha.data['v'], 'v2': alpha.data['v2']})
self.assertEqual(len(r), 2)
r = DataBag.objects.filter(data__gte={'v': alpha.data['v'], 'v2': beta.data['v2']})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], beta)
def test_multiple_key_value_lt_querying(self):
alpha, beta = self._create_bags()
self.assertGreater(beta.data['v'], alpha.data['v'])
r = DataBag.objects.filter(data__lt={'v': beta.data['v'], 'v2': beta.data['v2']})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], alpha)
r = DataBag.objects.filter(data__lt={'v': beta.data['v'], 'v2': alpha.data['v2']})
self.assertEqual(len(r), 0)
r = DataBag.objects.filter(data__lte={'v': beta.data['v'], 'v2': beta.data['v2']})
self.assertEqual(len(r), 2)
r = DataBag.objects.filter(data__lte={'v': beta.data['v'], 'v2': alpha.data['v2']})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], alpha)
def test_key_value_lt_querying(self):
alpha, beta = self._create_bags()
self.assertLess(alpha.data['v'], beta.data['v'])
r = DataBag.objects.filter(data__lt={'v': beta.data['v']})
self.assertEqual(len(r), 1)
self.assertEqual(r[0], alpha)
r = DataBag.objects.filter(data__lte={'v': beta.data['v']})
self.assertEqual(len(r), 2)
def test_multiple_key_subset_querying(self):
alpha, beta = self._create_bags()
for keys in (['v'], ['v', 'v2']):
self.assertEqual(DataBag.objects.filter(data__contains=keys).count(), 2)
for keys in (['v', 'nv'], ['n1', 'n2']):
self.assertEqual(DataBag.objects.filter(data__contains=keys).count(), 0)
def test_single_key_querying(self):
alpha, beta = self._create_bags()
for key in ('v', 'v2'):
self.assertEqual(DataBag.objects.filter(data__contains=[key]).count(), 2)
for key in ('n1', 'n2'):
self.assertEqual(DataBag.objects.filter(data__contains=[key]).count(), 0)
def test_simple_text_icontains_querying(self):
alpha, beta = self._create_bags()
DataBag.objects.create(name='gamma', data={'theKey': 'someverySpecialValue', 'v2': '3'})
self.assertEqual(DataBag.objects.filter(data__contains='very').count(), 1)
self.assertEqual(DataBag.objects.filter(data__contains='very')[0].name, 'gamma')
self.assertEqual(DataBag.objects.filter(data__icontains='specialvalue').count(), 1)
self.assertEqual(DataBag.objects.filter(data__icontains='specialvalue')[0].name, 'gamma')
self.assertEqual(DataBag.objects.filter(data__contains='the').count(), 1)
self.assertEqual(DataBag.objects.filter(data__contains='the')[0].name, 'gamma')
self.assertEqual(DataBag.objects.filter(data__icontains='eke').count(), 1)
self.assertEqual(DataBag.objects.filter(data__icontains='eke')[0].name, 'gamma')
def test_invalid_containment_lookup_values(self):
alpha, beta = self._create_bags()
with self.assertRaises(ValueError):
DataBag.objects.filter(data__contains=99)[0]
with self.assertRaises(ValueError):
DataBag.objects.filter(data__icontains=99)[0]
with self.assertRaises(ValueError):
DataBag.objects.filter(data__icontains=[])[0]
def test_invalid_comparison_lookup_values(self):
alpha, beta = self._create_bags()
with self.assertRaises(ValueError):
DataBag.objects.filter(data__lt=[1, 2])[0]
with self.assertRaises(ValueError):
DataBag.objects.filter(data__lt=99)[0]
with self.assertRaises(ValueError):
DataBag.objects.filter(data__lte=[1, 2])[0]
with self.assertRaises(ValueError):
DataBag.objects.filter(data__lte=99)[0]
with self.assertRaises(ValueError):
DataBag.objects.filter(data__gt=[1, 2])[0]
with self.assertRaises(ValueError):
DataBag.objects.filter(data__gt=99)[0]
with self.assertRaises(ValueError):
DataBag.objects.filter(data__gte=[1, 2])[0]
with self.assertRaises(ValueError):
DataBag.objects.filter(data__gte=99)[0]
def test_hkeys(self):
alpha, beta = self._create_bags()
self.assertEqual(DataBag.objects.hkeys(id=alpha.id, attr='data'), ['v', 'v2'])
self.assertEqual(DataBag.objects.hkeys(id=beta.id, attr='data'), ['v', 'v2'])
def test_hpeek(self):
alpha, beta = self._create_bags()
self.assertEqual(DataBag.objects.hpeek(id=alpha.id, attr='data', key='v'), '1')
self.assertEqual(DataBag.objects.filter(id=alpha.id).hpeek(attr='data', key='v'), '1')
self.assertEqual(DataBag.objects.hpeek(id=alpha.id, attr='data', key='invalid'), None)
def test_hremove(self):
alpha, beta = self._create_bags()
self.assertEqual(DataBag.objects.get(name='alpha').data, alpha.data)
DataBag.objects.filter(name='alpha').hremove('data', 'v2')
self.assertEqual(DataBag.objects.get(name='alpha').data, {'v': '1'})
self.assertEqual(DataBag.objects.get(name='beta').data, beta.data)
DataBag.objects.filter(name='beta').hremove('data', ['v', 'v2'])
self.assertEqual(DataBag.objects.get(name='beta').data, {})
def test_hslice(self):
alpha, beta = self._create_bags()
self.assertEqual(DataBag.objects.hslice(id=alpha.id, attr='data', keys=['v']), {'v': '1'})
self.assertEqual(DataBag.objects.filter(id=alpha.id).hslice(attr='data', keys=['v']), {'v': '1'})
self.assertEqual(DataBag.objects.hslice(id=alpha.id, attr='data', keys=['ggg']), {})
def test_hupdate(self):
alpha, beta = self._create_bags()
self.assertEqual(DataBag.objects.get(name='alpha').data, alpha.data)
DataBag.objects.filter(name='alpha').hupdate('data', {'v2': '10', 'v3': '20'})
self.assertEqual(DataBag.objects.get(name='alpha').data, {'v': '1', 'v2': '10', 'v3': '20'})
def test_hupdate_atomic(self):
""" https://github.com/djangonauts/django-hstore/issues/84 """
if hasattr(transaction, 'atomic'):
with transaction.atomic():
self.test_hupdate()
def test_default(self):
m = DefaultsModel()
m.save()
def test_bad_default(self):
m = BadDefaultsModel()
try:
m.save()
except IntegrityError:
if DJANGO_VERSION[:2] >= (1, 6):
pass
# TODO: remove in future versions of django-hstore
else:
transaction.rollback()
else:
self.assertTrue(False)
def test_serialization_deserialization(self):
alpha, beta = self._create_bags()
self.assertEqual(json.loads(str(DataBag.objects.get(name='alpha').data)), json.loads(str(alpha.data)))
self.assertEqual(json.loads(str(DataBag.objects.get(name='beta').data)), json.loads(str(beta.data)))
def test_hstoredictionaryexception(self):
# ok
HStoreDict({})
# json object string allowed
HStoreDict('{}')
# None is ok, will be converted to empty dict
HStoreDict(None)
HStoreDict()
# non-json string not allowed
with self.assertRaises(HStoreDictException):
HStoreDict('wrong')
# list not allowed
with self.assertRaises(HStoreDictException):
HStoreDict(['wrong'])
# json array string representation not allowed
with self.assertRaises(HStoreDictException):
HStoreDict('["wrong"]')
# number not allowed
with self.assertRaises(HStoreDictException):
HStoreDict(3)
def test_hstoredictionary_unicode_vs_str(self):
d = HStoreDict({'test': 'test'})
self.assertEqual(d.__str__(), d.__unicode__())
def test_hstore_model_field_validation(self):
d = DataBag()
with self.assertRaises(ValidationError):
d.full_clean()
d.data = 'test'
with self.assertRaises(ValidationError):
d.full_clean()
d.data = '["test"]'
with self.assertRaises(ValidationError):
d.full_clean()
d.data = ["test"]
with self.assertRaises(ValidationError):
d.full_clean()
d.data = {
'a': 1,
'b': 2.2,
'c': ['a', 'b'],
'd': {'test': 'test'}
}
with self.assertRaises(ValidationError):
d.full_clean()
def test_admin_widget(self):
alpha, beta = self._create_bags()
# create admin user
admin = User.objects.create(username='admin', password='tester', is_staff=True, is_superuser=True, is_active=True)
admin.set_password('tester')
admin.save()
# login as admin
self.client.login(username='admin', password='tester')
# access admin change form page
url = reverse('admin:django_hstore_tests_databag_change', args=[alpha.id])
response = self.client.get(url)
# ensure textarea with id="id_data" is there
self.assertContains(response, 'textarea')
self.assertContains(response, 'id_data')
def test_dictionary_default_admin_widget(self):
class HForm(forms.ModelForm):
class Meta:
model = DataBag
exclude = []
form = HForm()
self.assertEqual(form.fields['data'].widget.__class__, DictionaryFieldWidget)
def test_dictionary_custom_admin_widget(self):
class CustomWidget(forms.Widget):
pass
class HForm(forms.ModelForm):
class Meta:
model = DataBag
widgets = {'data': CustomWidget}
exclude = []
form = HForm()
self.assertEqual(form.fields['data'].widget.__class__, CustomWidget)
def test_get_version(self):
get_version()
def test_unique_together(self):
d = UniqueTogetherDataBag()
d.name = 'test'
d.data = {'test': 'test '}
d.full_clean()
d.save()
d = UniqueTogetherDataBag()
d.name = 'test'
d.data = {'test': 'test '}
with self.assertRaises(ValidationError):
d.full_clean()
def test_properties_hstore(self):
"""
Make sure the hstore field does what it is supposed to.
"""
from django_hstore.fields import HStoreDict
instance = DataBag()
test_props = {'foo': 'bar', 'size': '3'}
instance.name = 'foo'
instance.data = test_props
instance.save()
self.assertEqual(type(instance.data), HStoreDict)
self.assertEqual(instance.data, test_props)
instance = DataBag.objects.get(pk=instance.pk)
self.assertEqual(type(instance.data), HStoreDict)
self.assertEqual(instance.data, test_props)
self.assertEqual(instance.data['size'], '3')
self.assertIn('foo', instance.data)
def test_unicode(self):
i = DataBag()
i.data['key'] = 'è'
i.save()
i.data['key'] = u'è'
i.save()
def test_get_default(self):
d = HStoreDict()
self.assertIsNone(d.get('none_key', None))
self.assertIsNone(d.get('none_key'))
def test_str(self):
d = DataBag()
self.assertEqual(str(d.data), '{}')
def test_array_with_decimal(self):
instance = DataBag(name="decimal")
array_decimal = [Decimal('1.01')]
array_dumped = '[1.01]'
instance.data['arr_dec'] = array_decimal
self.assertEqual(instance.data['arr_dec'], array_dumped)
instance.save()
instance = DataBag.objects.get(pk=instance.pk)
self.assertEqual(instance.data['arr_dec'], array_dumped)
def test_native_contains(self):
d = DataBag()
d.name = "A bag of data"
d.data = {
'd1': '1',
'd2': '2'
}
d.save()
result = DataBag.objects.filter(name__contains='of data')
self.assertEqual(result.count(), 1)
self.assertEqual(result[0].pk, d.pk)
result = DataBag.objects.filter(name__contains='OF data')
self.assertEqual(result.count(), 0)
def test_native_icontains(self):
d = DataBag()
d.name = "A bag of data"
d.data = {
'd1': '1',
'd2': '2'
}
d.save()
result = DataBag.objects.filter(name__icontains='A bAg')
self.assertEqual(result.count(), 1)
self.assertEqual(result[0].pk, d.pk)
def test_native_gt(self):
d = NumberedDataBag()
d.name = "A bag of data"
d.number = 12
d.save()
result = NumberedDataBag.objects.filter(number__gt=12)
self.assertEqual(result.count(), 0)
result = NumberedDataBag.objects.filter(number__gt=1)
self.assertEqual(result.count(), 1)
self.assertEqual(result[0].pk, d.pk)
result = NumberedDataBag.objects.filter(number__gt=13)
self.assertEqual(result.count(), 0)
def test_native_gte(self):
d = NumberedDataBag()
d.name = "A bag of data"
d.number = 12
d.save()
result = NumberedDataBag.objects.filter(number__gte=12)
self.assertEqual(result.count(), 1)
self.assertEqual(result[0].pk, d.pk)
result = NumberedDataBag.objects.filter(number__gte=1)
self.assertEqual(result.count(), 1)
self.assertEqual(result[0].pk, d.pk)
result = NumberedDataBag.objects.filter(number__gte=13)
self.assertEqual(result.count(), 0)
def test_native_lt(self):
d = NumberedDataBag()
d.name = "A bag of data"
d.number = 12
d.save()
result = NumberedDataBag.objects.filter(number__lt=20)
self.assertEqual(result.count(), 1)
self.assertEqual(result[0].pk, d.pk)
result = NumberedDataBag.objects.filter(number__lt=12)
self.assertEqual(result.count(), 0)
result = NumberedDataBag.objects.filter(number__lt=1)
self.assertEqual(result.count(), 0)
def test_native_lte(self):
d = NumberedDataBag()
d.name = "A bag of data"
d.number = 12
d.save()
result = NumberedDataBag.objects.filter(number__lte=12)
self.assertEqual(result.count(), 1)
self.assertEqual(result[0].pk, d.pk)
result = NumberedDataBag.objects.filter(number__lte=13)
self.assertEqual(result.count(), 1)
self.assertEqual(result[0].pk, d.pk)
result = NumberedDataBag.objects.filter(number__lte=1)
self.assertEqual(result.count(), 0)
def test_get_cast_for_param(self):
self.assertEqual(get_cast_for_param([], 'a'), '')
self.assertEqual(get_cast_for_param({'a': True}, 'a'), '::boolean')
self.assertEqual(get_cast_for_param({'a': datetime.datetime}, 'a'), '::timestamp')
self.assertEqual(get_cast_for_param({'a': datetime.time}, 'a'), '::time')
self.assertEqual(get_cast_for_param({'a': int}, 'a'), '::bigint')
self.assertEqual(get_cast_for_param({'a': float}, 'a'), '::float8')
from decimal import Decimal
self.assertEqual(get_cast_for_param({'a': Decimal}, 'a'), '::numeric')
django-hstore-1.5~alpha~git20161126+dfsg/tests/local_settings.py.example 0000664 0001750 0001750 00000000574 13016340771 026407 0 ustar kitterma kitterma # -*- coding: utf-8 -*-
DATABASES = {
'default': {
# possible backends are:
# * django.db.backends.postgresql_psycopg2
# * django.contrib.gis.db.backends.postgis
'ENGINE': 'django.contrib.gis.db.backends.postgis',
'NAME': 'django_hstore',
'USER': '',
'PASSWORD': '',
'HOST': '',
'PORT': ''
},
}
django-hstore-1.5~alpha~git20161126+dfsg/tests/settings_psycopg.py 0000664 0001750 0001750 00000005276 13016340771 025353 0 ustar kitterma kitterma from __future__ import print_function
import os
import sys
import django
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
DEBUG = True
SECRET_KEY = '!5myuh^d23p9$$lo5k$39x&ji!vceayg+wwt472!bgs$0!i3k4'
DATABASES = {
'default': {
# possible backends are:
# * django.db.backends.postgresql_psycopg2
# * django.contrib.gis.db.backends.postgis
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': 'django_hstore_psycopg2',
'USER': '',
'PASSWORD': '',
'HOST': '',
'PORT': ''
},
}
ALLOWED_HOSTS = []
if django.VERSION[:2] >= (1, 7):
INSTALLED_APPS = (
'django.contrib.admin.apps.AdminConfig',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'django_hstore',
'django_hstore_tests',
)
else:
INSTALLED_APPS = (
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'django_hstore',
'django_hstore_tests',
)
MIDDLEWARE_CLASSES = (
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
)
ROOT_URLCONF = 'urls'
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
STATIC_URL = '/static/'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
# local settings must be imported before test runner otherwise they'll be ignored
try:
from local_settings_psycopg import * # noqa
except ImportError:
pass
if django.VERSION[:2] >= (1, 6):
TEST_RUNNER = 'django.test.runner.DiscoverRunner'
else:
try:
import discover_runner # noqa
TEST_RUNNER = "discover_runner.DiscoverRunner"
except ImportError:
print("For run tests with django <= 1.5 you should install "
"django-discover-runner.")
sys.exit(-1)
django-hstore-1.5~alpha~git20161126+dfsg/tests/settings.py 0000664 0001750 0001750 00000004735 13016340771 023606 0 ustar kitterma kitterma from __future__ import print_function
import os
import sys
import django
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
DEBUG = True
SECRET_KEY = '!5myuh^d23p9$$lo5k$39x&ji!vceayg+wwt472!bgs$0!i3k4'
DATABASES = {
'default': {
# possible backends are:
# * django.db.backends.postgresql_psycopg2
# * django.contrib.gis.db.backends.postgis
'ENGINE': 'django.contrib.gis.db.backends.postgis',
'NAME': 'django_hstore',
'USER': '',
'PASSWORD': '',
'HOST': '',
'PORT': ''
},
}
ALLOWED_HOSTS = []
INSTALLED_APPS = (
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'django_hstore',
'django_hstore_tests'
)
if django.VERSION[:2] >= (1, 7):
INSTALLED_APPS = (
'django.contrib.admin.apps.AdminConfig',
) + INSTALLED_APPS
else:
INSTALLED_APPS = (
'django.contrib.admin',
) + INSTALLED_APPS
MIDDLEWARE_CLASSES = (
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
)
ROOT_URLCONF = 'urls'
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
STATIC_URL = '/static/'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
# local settings must be imported before test runner otherwise they'll be ignored
try:
from local_settings import * # noqa
except ImportError:
pass
if django.VERSION[:2] >= (1, 6):
TEST_RUNNER = 'django.test.runner.DiscoverRunner'
else:
try:
import discover_runner # noqa
TEST_RUNNER = "discover_runner.DiscoverRunner"
except ImportError:
print("For run tests with django <= 1.5 you should install "
"django-discover-runner.")
sys.exit(-1)
django-hstore-1.5~alpha~git20161126+dfsg/AUTHORS 0000664 0001750 0001750 00000001231 13016340771 021266 0 ustar kitterma kitterma Current Mantainers
------------------
Federico Capoano https://github.com/nemesisdesign/
Andrei Antoukh https://github.com/niwibe
Original Author
---------------
Jordan McCoy https://github.com/jordanm
Contributors
------------
Jannis Leidel https://github.com/jezdez
Oliver Yu https://github.com/oliy
Pavel Chernykh https://github.com/pavel-v-chernykh
Tippr https://github.com/Tippr
Donald Stufft https://github.com/dstufft
Mikko Hellsing https://github.com/aino
Adieu https://github.com/adieu
Alexander Dinu https://github.com/aluuu
Anthony Lukach http://github.com/alukach
django-hstore-1.5~alpha~git20161126+dfsg/PKG-INFO 0000664 0001750 0001750 00000006321 13016364461 021322 0 ustar kitterma kitterma Metadata-Version: 1.1
Name: django-hstore
Version: 1.5.alpha
Summary: PostgreSQL HStore support for Django
Home-page: https://github.com/djangonauts/django-hstore
Author: Djangonauts Organization
Author-email: django-hstore@googlegroups.com
License: BSD
Download-URL: https://github.com/djangonauts/django-hstore/releases
Description: =============
django-hstore
=============
.. image:: https://travis-ci.org/djangonauts/django-hstore.svg
:target: https://travis-ci.org/djangonauts/django-hstore
.. image:: https://coveralls.io/repos/djangonauts/django-hstore/badge.svg
:target: https://coveralls.io/r/djangonauts/django-hstore
.. image:: https://requires.io/github/djangonauts/django-hstore/requirements.svg?branch=master
:target: https://requires.io/github/djangonauts/django-hstore/requirements/?branch=master
:alt: Requirements Status
.. image:: https://badge.fury.io/py/django-hstore.svg
:target: https://pypi.python.org/pypi/django-hstore
.. image:: https://img.shields.io/pypi/dm/django-hstore.svg
:target: https://pypi.python.org/pypi/django-hstore
------------
You need **dynamic columns** in your tables. What do you do?
- Create lots of tables to handle it. Nice, now you’ll need more models and lots of additional sqls. Insertion and selection will be slow as hell.
- Use a **noSQL** database just for this issue. **Good luck**.
- Create a serialized column. Nice, insertion will be fine, and reading data from a record too. But, what if you have a condition in your select that includes serialized data? Yeah, regular expressions.
------------
Documentation_ - `Mailing List`_
.. _Documentation: http://djangonauts.github.io/django-hstore/
.. _`Mailing List`: https://groups.google.com/forum/#!forum/django-hstore
------------
Projects using this package
---------------------------
- `django-rest-framework-hstore `__: **django-rest-framework** tools for **django-hstore**
- `Nodeshot `__: extensible django web application for management of community-led georeferenced data - some features of **django-hstore**, like the ``schema-mode`` have been developed for this project
Keywords: django,hstore,schemaless
Platform: Platform Indipendent
Classifier: Development Status :: 4 - Beta
Classifier: Environment :: Web Environment
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: BSD License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
Classifier: Framework :: Django
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4