Init

Author: derek-schaefer

.gitignore

@@ -0,0 +1,3 @@
+*~
+*.pyc
+*.db

AUTHORS

@@ -0,0 +1 @@
+Derek Schaefer

LICENSE

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

MANIFEST

@@ -0,0 +1,9 @@
+# file GENERATED by distutils, do NOT edit
+LICENSE
+setup.py
+json_field/__init__.py
+json_field/fields.py
+json_field/forms.py
+json_field/models.py
+json_field/tests.py
+json_field/views.py

MANIFEST.in

@@ -0,0 +1 @@
+include LICENSE

README.rst

@@ -0,0 +1,66 @@
+Django JSON Field
+=================
+
+``django-json-field`` contains a flexible JSONField and associated form field. The model field is not only capable of serializing common JSON data types (int, float, decimal, string, time, date, datetime, etc.) but also lazily deserializing them so they can be accessed and modified as normal Python objects within Django.
+
+A form field is also provided. It will accept serialized representations (i.e. ``{"date": "2012-04-23T19:16:54.133", "num": "1.2399999999999999911182158029987476766109466552734375"}``) but also provides safe access to the ``datetime`` module and ``Decimal`` class for explicit use (i.e. ``{"date": datetime.datetime(2012, 4, 23, 19, 16, 54, 133000), "num": Decimal('1.2399999999999999911182158029987476766109466552734375')}``).
+
+While the JSON string will not be deserialized until it is accessed it can still be a performance concern. You may find it valuable to disable deserialization (``JSONField(decoder=None)``), or to defer loading the field altogether (i.e. ``MyModel.objects.all().defer('json')``).
+
+``django-json-field`` is also compatible with South.
+
+Installation
+------------
+
+Install from PyPI:
+
+    ``pip install django-json-field``
+
+Install from GitHub:
+
+    ``git clone git://github.com/derek-schaefer/django-json-field.git``
+
+    ``pip install -e git+git://github.com/derek-schaefer/django-json-field.git#egg=json_field``
+
+Configuration
+-------------
+
+Add ``json_field`` to your ``PYTHONPATH`` and ``INSTALLED_APPS`` setting:
+
+::
+
+    INSTALLED_APPS = (
+        ...
+        'json_field',
+        ...
+    )
+
+That's all!
+
+Usage
+-----
+
+Add a ``JSONField`` to your model like any other field.
+
+::
+
+    from json_field import JSONField
+    from django.db import models
+    
+    class MyModel(models.Model):
+    
+        json = JSONField()
+
+``JSONField`` also has a few additional optional parameters.
+
+ - ``default``: Falls back on ``{}`` if not provided.
+ - ``db_type``: Allows you to specify the column type (default: ``text``)
+ - ``encoder``: Custom JSON encoder (default: ``DjangoJSONEncoder``)
+ - ``decoder``: Custom JSON decoder (default: ``json_fields.fields.JSONDecoder``)
+ - ``encoder_kwargs``: Specify all arguments to the encoder (overrides ``encoder``)
+ - ``decoder_kwargs``: Specify all arguments to the decoder (overrides ``decoder``)
+
+License
+-------
+
+``django-json-field`` is licensed under the New BSD license.

json_field/__init__.py

@@ -0,0 +1,6 @@
+try:
+    from json_field.fields import JSONField
+except ImportError:
+    pass # fails when imported by setup.py, no worries
+
+__version__ = '0.1'

json_field/fields.py

@@ -0,0 +1,122 @@
+from json_field.forms import JSONFormField
+
+from django.db import models
+from django.utils import simplejson as json
+from django.core import exceptions
+from django.core.serializers.json import DjangoJSONEncoder
+from django.utils.translation import ugettext as _
+
+import decimal
+from datetime import datetime
+from dateutil import parser as date_parser
+
+class JSONDecoder(json.JSONDecoder):
+
+    _recursable_types = [str, unicode, list, dict]
+
+    def _is_recursive(self, obj):
+        return type(obj) in JSONDecoder._recursable_types
+
+    def decode(self, obj, *args, **kwargs):
+        if not kwargs.get('recurse', False):
+            obj = super(JSONDecoder, self).decode(obj, *args, **kwargs)
+        if isinstance(obj, list):
+            for i in xrange(len(obj)):
+                item = obj[i]
+                if self._is_recursive(item):
+                    obj[i] = self.decode(item, recurse=True)
+        elif isinstance(obj, dict):
+            for key, value in obj.items():
+                if self._is_recursive(value):
+                    obj[key] = self.decode(value, recurse=True)
+        elif isinstance(obj, basestring):
+            try:
+                return decimal.Decimal(obj) # first since dateutil will consume this
+            except decimal.InvalidOperation:
+                pass
+            try:
+                return datetime.strptime(obj, '%H:%M:%S.%f').time() # with microsecond
+            except ValueError:
+                pass
+            try:
+                return datetime.strptime(obj, '%H:%M:%S').time() # without microsecond
+            except ValueError:
+                pass
+            try:
+                return datetime.strptime(obj, '%Y-%m-%d').date() # simple date
+            except ValueError:
+                pass
+            try:
+                return date_parser.parse(obj) # supports multiple formats
+            except ValueError:
+                pass
+        return obj
+
+class JSONField(models.TextField):
+    """ Stores and loads valid JSON objects. """
+
+    __metaclass__ = models.SubfieldBase
+
+    description = 'JSON object'
+
+    default_error_messages = {
+        'invalid': _(u'Enter a valid JSON object')
+    }
+
+    def __init__(self, *args, **kwargs):
+        self._db_type = kwargs.pop('db_type', None)
+        encoder = kwargs.pop('encoder', DjangoJSONEncoder)
+        decoder = kwargs.pop('decoder', JSONDecoder)
+        encoder_kwargs = kwargs.pop('encoder_kwargs', {})
+        decoder_kwargs = kwargs.pop('decoder_kwargs', {})
+        if not encoder_kwargs and encoder:
+            encoder_kwargs.update({'cls':encoder})
+        if not decoder_kwargs and decoder:
+            decoder_kwargs.update({'cls':decoder})
+        self.encoder_kwargs = encoder_kwargs
+        self.decoder_kwargs = decoder_kwargs
+        kwargs['default'] = kwargs.get('default', {})
+        kwargs['help_text'] = kwargs.get('help_text', self.default_error_messages['invalid'])
+        super(JSONField, self).__init__(*args, **kwargs)
+
+    def db_type(self, connection):
+        if self._db_type:
+            return self._db_type
+        return super(JSONField, self).db_type(connection)
+
+    def to_python(self, value):
+        if not value:
+            return None
+        if isinstance(value, basestring):
+            try:
+                value = json.loads(value, **self.decoder_kwargs)
+            except json.JSONDecodeError:
+                pass
+        return value
+
+    def get_db_prep_value(self, value, *args, **kwargs):
+        if value is None:
+            return None
+        return json.dumps(value, **self.encoder_kwargs)
+
+    def value_to_string(self, obj):
+        return self.get_db_prep_value(self._get_val_from_obj(obj))
+
+    def value_from_object(self, obj):
+        return json.dumps(super(JSONField, self).value_from_object(obj), **self.encoder_kwargs)
+
+    def formfield(self, **kwargs):
+        defaults = {
+            'form_class': kwargs.get('form_class', JSONFormField),
+            'encoder_kwargs': self.encoder_kwargs,
+            'decoder_kwargs': self.decoder_kwargs,
+        }
+        defaults.update(kwargs)
+        return super(JSONField, self).formfield(**defaults)
+
+try:
+    # add support for South migrations
+    from south.modelsinspector import add_introspection_rules
+    add_introspection_rules([], ['^json_field\.fields\.JSONField'])
+except ImportError:
+    pass

json_field/forms.py

@@ -0,0 +1,27 @@
+from django.forms import fields, util
+from django.utils import simplejson as json
+
+import datetime
+import decimal
+
+class JSONFormField(fields.Field):
+
+    def __init__(self, *args, **kwargs):
+        self.encoder_kwargs = kwargs.pop('encoder_kwargs')
+        self.decoder_kwargs = kwargs.pop('decoder_kwargs')
+        super(JSONFormField, self).__init__(*args, **kwargs)
+
+    def clean(self, value):
+        # Have to jump through a few hoops to make this reliable
+        value = super(JSONFormField, self).clean(value)
+        json_globals = {
+            '__builtins__': None,
+            'datetime': datetime,
+            'Decimal': decimal.Decimal,
+        }
+        value = json.dumps(eval(value, json_globals, {}), **self.encoder_kwargs)
+        try:
+            json.loads(value, **self.decoder_kwargs)
+        except ValueError, e:
+            raise util.ValidationError(self.help_text)
+        return value

json_field/models.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python
+import os
+import sys
+
+if __name__ == "__main__":
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "test_project.settings")
+
+    from django.core.management import execute_from_command_line
+
+    execute_from_command_line(sys.argv)

json_field/tests.py

@@ -0,0 +1,30 @@
+import json_field
+
+from distutils.core import setup
+
+description = 'Generic JSON model and form fields.'
+
+try:
+    with open('README.rst') as f:
+        long_description = f.read()
+except IOError:
+    long_description = description
+
+setup(
+    name = 'django-json-field',
+    version = json_field.__version__,
+    description = description,
+    author = 'Derek Schaefer',
+    author_email = '[email protected]',
+    url = 'https://github.com/derek-schaefer/django-json-field',
+    long_description = long_description,
+    packages = ['json_field'],
+    classifiers = [
+        'Development Status :: 3 - Alpha',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: BSD License',
+        'Operating System :: OS Independent',
+        'Programming Language :: Python',
+        'Topic :: Software Development :: Libraries :: Python Modules',
+    ],
+)

json_field/views.py

@@ -0,0 +1,4 @@
+from django.contrib import admin
+
+from test_project.app.models import Test
+admin.site.register(Test)

manage.py

@@ -0,0 +1,8 @@
+from json_field import JSONField
+
+from django.db import models
+
+class Test(models.Model):
+
+    json = JSONField()
+    json_null = JSONField(blank=True, null=True)

setup.py

@@ -0,0 +1,45 @@
+from test_project.app.models import Test
+
+from django.test import TestCase
+from django.db.utils import IntegrityError
+
+from decimal import Decimal
+
+class JSONFieldTest(TestCase):
+
+    def test_simple(self):
+        t1 = Test.objects.create(json=123)
+        self.assertEqual(123, t1.json)
+        t2 = Test.objects.create(json='123')
+        self.assertEqual(123, t2.json)
+        t3 = Test.objects.create(json=[123])
+        self.assertEqual([123], t3.json)
+        t4 = Test.objects.create(json='[123]')
+        self.assertEqual([123], t4.json)
+        t5 = Test.objects.create(json={'test':[1,2,3]})
+        self.assertEqual({'test':[1,2,3]}, t5.json)
+        t6 = Test.objects.create(json='{"test":[1,2,3]}')
+        self.assertEqual({'test':[1,2,3]}, t6.json)
+
+    def test_null(self):
+        with self.assertRaises(IntegrityError):
+            Test.objects.create(json=None)
+        with self.assertRaises(IntegrityError):
+            Test.objects.create(json='')
+        Test.objects.create(json_null=None)
+        Test.objects.create(json_null='')
+
+    def test_decimal(self):
+        t1 = Test.objects.create(json=Decimal(1.24))
+        self.assertEqual(Decimal(1.24), t1.json)
+        t2 = Test.objects.create(json={'test':[{'test':Decimal(1.24)}]})
+        self.assertEqual({'test':[{'test':Decimal(1.24)}]}, t2.json)
+
+    def test_time(self):
+        pass
+
+    def test_date(self):
+        pass
+
+    def test_datetime(self):
+        pass

test_project/__init__.py

@@ -0,0 +1 @@
+# Create your views here.