Fresh Start

Author: primal100

.gitignore

@@ -0,0 +1,7 @@
+*.pyc
+*.log
+.idea/*
+build/*
+dist/*
+docs/_*
+django_postgres_extensions.egg-info/*

LICENSE

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

MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE
+include readme.rst
+include description.rst

description.rst

@@ -0,0 +1,5 @@
+Django Postgres Extensions!
+
+Django Postgres Extensions adds a lot of functionality to Django.contrib.postgres, specifically in relation to ArrayField, HStoreField and JSONField, including much better form fields for dealing with these field types. The app also includes an Array Many To Many Field, so you can store the relationship in an array column instead of requiring an extra database table.
+
+Check out http://django-postgres-extensions.readthedocs.io/en/latest/ to get started.

django_postgres_extensions/__init__.py

@@ -0,0 +1,2 @@
+default_app_config = 'django_postgres_extensions.apps.PSQLExtensionsConfig'
+__version__ = "0.9.2"

django_postgres_extensions/admin/__init__.py

@@ -0,0 +1,73 @@
+from django.contrib.admin.options import ModelAdmin
+from django.utils.translation import string_concat, ugettext as _
+from django.forms.widgets import CheckboxSelectMultiple, SelectMultiple
+from django_postgres_extensions.models import ArrayManyToManyField
+from django.contrib.admin import widgets
+
+class PostgresAdmin(ModelAdmin):
+
+    def formfield_for_manytomany(self, db_field, request=None, **kwargs):
+        """
+        Get a form Field for a ManyToManyField.
+        """
+        # If it uses an intermediary model that isn't auto created, don't show
+        # a field in admin.
+        if hasattr(db_field, 'through') and not db_field.remote_field.through._meta.auto_created:
+            return None
+        db = kwargs.get('using')
+
+        if db_field.name in self.raw_id_fields:
+            kwargs['widget'] = widgets.ManyToManyRawIdWidget(db_field.remote_field,
+                                    self.admin_site, using=db)
+            kwargs['help_text'] = ''
+        elif db_field.name in (list(self.filter_vertical) + list(self.filter_horizontal)):
+            kwargs['widget'] = widgets.FilteredSelectMultiple(
+                db_field.verbose_name,
+                db_field.name in self.filter_vertical
+            )
+
+        if 'queryset' not in kwargs:
+            queryset = self.get_field_queryset(db, db_field, request)
+            if queryset is not None:
+                kwargs['queryset'] = queryset
+
+        form_field = db_field.formfield(**kwargs)
+        if isinstance(form_field.widget, SelectMultiple) and not isinstance(form_field.widget, CheckboxSelectMultiple):
+            msg = _('Hold down "Control", or "Command" on a Mac, to select more than one.')
+            help_text = form_field.help_text
+            form_field.help_text = string_concat(help_text, ' ', msg) if help_text else msg
+        return form_field
+
+    def formfield_for_dbfield(self, db_field, request, **kwargs):
+
+        # ForeignKey or ManyToManyFields
+        if isinstance(db_field, ArrayManyToManyField):
+            # Combine the field kwargs with any options for formfield_overrides.
+            # Make sure the passed in **kwargs override anything in
+            # formfield_overrides because **kwargs is more specific, and should
+            # always win.
+            if db_field.__class__ in self.formfield_overrides:
+                kwargs = dict(self.formfield_overrides[db_field.__class__], **kwargs)
+
+            formfield = self.formfield_for_manytomany(db_field, request, **kwargs)
+
+            # For non-raw_id fields, wrap the widget with a wrapper that adds
+            # extra HTML -- the "add other" interface -- to the end of the
+            # rendered output. formfield can be None if it came from a
+            # OneToOneField with parent_link=True or a M2M intermediary.
+            if formfield and db_field.name not in self.raw_id_fields:
+                related_modeladmin = self.admin_site._registry.get(db_field.remote_field.model)
+                wrapper_kwargs = {}
+                if related_modeladmin:
+                    wrapper_kwargs.update(
+                        can_add_related=related_modeladmin.has_add_permission(request),
+                        can_change_related=related_modeladmin.has_change_permission(request),
+                        can_delete_related=related_modeladmin.has_delete_permission(request),
+                    )
+                formfield.widget = widgets.RelatedFieldWidgetWrapper(
+                    formfield.widget, db_field.remote_field, self.admin_site, **wrapper_kwargs
+                )
+
+            return formfield
+        else:
+            return super(PostgresAdmin, self).formfield_for_dbfield(db_field, request, **kwargs)

django_postgres_extensions/admin/options.py

@@ -0,0 +1,23 @@
+from django.apps import AppConfig
+from django.utils.translation import ugettext_lazy as _
+from django.db.models import query
+from django.db.models.sql import datastructures
+from .models.query import update, _update, format, prefetch_one_level
+from .models.sql.datastructures import as_sql
+from django.db.models.signals import pre_delete
+from .signals import delete_reverse_related
+from django.conf import settings
+
+
+class PSQLExtensionsConfig(AppConfig):
+    name = 'django_postgres_extensions'
+    verbose_name = _('Extra features for PostgreSQL fields')
+
+    def ready(self):
+        query.QuerySet.format = format
+        query.QuerySet.update = update
+        query.QuerySet._update = _update
+        if getattr(settings, 'ENABLE_ARRAY_M2M', False):
+            datastructures.Join.as_sql = as_sql
+            query.prefetch_one_level = prefetch_one_level
+            pre_delete.connect(delete_reverse_related)

django_postgres_extensions/apps.py

@@ -0,0 +1,38 @@
+from django.db.backends.postgresql.base import DatabaseWrapper as BaseDatabaseWrapper
+from .schema import DatabaseSchemaEditor
+from .creation import DatabaseCreation
+from .operations import DatabaseOperations
+
+class DatabaseWrapper(BaseDatabaseWrapper):
+
+    SchemaEditorClass = DatabaseSchemaEditor
+
+    def __init__(self, *args, **kwargs):
+        super(DatabaseWrapper, self).__init__(*args, **kwargs)
+        self.creation = DatabaseCreation(self)
+        self.ops = DatabaseOperations(self)
+
+        self.any_operators = {
+            'exact': '= ANY(%s)',
+            'in': 'LIKE ANY(%s)',
+            'gt': '< ANY(%s)',
+            'gte': '<= ANY(%s)',
+            'lt': '> ANY(%s)',
+            'lte': '>= ANY(%s)',
+            'startof': 'LIKE ANY(%s)',
+            'endof': 'LIKE ANY(%s)',
+            'contains': '<@ ANY(%s)'
+        }
+
+
+        self.all_operators = {
+            'exact': '= ALL(%s)',
+            'in': 'LIKE ALL(%s)',
+            'gt': '< ALL(%s)',
+            'gte': '<= ALL(%s)',
+            'lt': '> ALL(%s)',
+            'lte': '>= ALL(%s)',
+            'startof': 'LIKE ALL(%s)',
+            'endof': 'LIKE ALL(%s)',
+            'contains': '<@ ALL(%s)'
+        }

django_postgres_extensions/backends/__init__.py

@@ -0,0 +1,65 @@
+from django.contrib.postgres.signals import register_hstore_handler
+from django.db.backends.postgresql.creation import DatabaseCreation as BaseDatabaseCreation
+from django.conf import settings
+
+class DatabaseCreation(BaseDatabaseCreation):
+    def create_test_db(self, verbosity=1, autoclobber=False, serialize=True, keepdb=False):
+        """
+        Creates a test database, prompting the user for confirmation if the
+        database already exists. Returns the name of the test database created.
+        """
+        # Don't import django.core.management if it isn't needed.
+        from django.core.management import call_command
+
+        test_database_name = self._get_test_db_name()
+
+        if verbosity >= 1:
+            action = 'Creating'
+            if keepdb:
+                action = "Using existing"
+
+            print("%s test database for alias %s..." % (
+                action,
+                self._get_database_display_str(verbosity, test_database_name),
+            ))
+
+        # We could skip this call if keepdb is True, but we instead
+        # give it the keepdb param. This is to handle the case
+        # where the test DB doesn't exist, in which case we need to
+        # create it, then just not destroy it. If we instead skip
+        # this, we will get an exception.
+        self._create_test_db(verbosity, autoclobber, keepdb)
+
+        self.connection.close()
+        settings.DATABASES[self.connection.alias]["NAME"] = test_database_name
+        self.connection.settings_dict["NAME"] = test_database_name
+
+        with self.connection.cursor() as cursor:
+            for extension in ('hstore',):
+                cursor.execute("CREATE EXTENSION IF NOT EXISTS %s" % extension)
+        register_hstore_handler(self.connection)
+
+        # We report migrate messages at one level lower than that requested.
+        # This ensures we don't get flooded with messages during testing
+        # (unless you really ask to be flooded).
+        call_command(
+            'migrate',
+            verbosity=max(verbosity - 1, 0),
+            interactive=False,
+            database=self.connection.alias,
+            run_syncdb=True,
+        )
+
+        # We then serialize the current state of the database into a string
+        # and store it on the connection. This slightly horrific process is so people
+        # who are testing on databases without transactions or who are using
+        # a TransactionTestCase still get a clean database on every test run.
+        if serialize:
+            self.connection._test_serialized_contents = self.serialize_db_to_string()
+
+        call_command('createcachetable', database=self.connection.alias)
+
+        # Ensure a connection for the side effect of initializing the test database.
+        self.connection.ensure_connection()
+
+        return test_database_name

django_postgres_extensions/backends/postgresql/__init__.py

@@ -0,0 +1,4 @@
+from django.db.backends.postgresql.operations import DatabaseOperations as BaseDatabaseOperations
+
+class DatabaseOperations(BaseDatabaseOperations):
+    compiler_module = "django_postgres_extensions.models.sql.compiler"

django_postgres_extensions/backends/postgresql/base.py

@@ -0,0 +1,21 @@
+from django.db.backends.postgresql import schema
+
+class DatabaseSchemaEditor(schema.DatabaseSchemaEditor):
+    sql_create_array_index = "CREATE INDEX %(name)s ON %(table)s USING GIN (%(columns)s)%(extra)s"
+
+    def _model_indexes_sql(self, model):
+        output = super(DatabaseSchemaEditor, self)._model_indexes_sql(model)
+        if not model._meta.managed or model._meta.proxy or model._meta.swapped:
+            return output
+
+        for field in model._meta.local_fields:
+            array_index_statement = self._create_array_index_sql(model, field)
+            if array_index_statement is not None:
+                output.append(array_index_statement)
+        return output
+
+    def _create_array_index_sql(self, model, field):
+        db_type = field.db_type(connection=self.connection)
+        if db_type is not None and '[' in db_type and db_type.endswith(']') and (field.db_index or field.unique):
+            return self._create_index_sql(model, [field], suffix='_gin', sql=self.sql_create_array_index)
+        return None

django_postgres_extensions/backends/postgresql/creation.py

@@ -0,0 +1,2 @@
+from .fields import NestedFormField
+from .widgets import NestedFormWidget

django_postgres_extensions/backends/postgresql/operations.py

@@ -0,0 +1,67 @@
+from .widgets import NestedFormWidget
+from django.forms.fields import MultiValueField, CharField
+from django.core.exceptions import ValidationError
+
+
+class NestedFormField(MultiValueField):
+    """
+    A Field that aggregates the logic of multiple Fields to create a nested form within a form.
+
+    The compress method returns a dictionary of field names and values.
+
+    Requires either a ``fields`` or ``keys`` argument but not both.
+
+    The ``fields`` argument is a list of tuples; each tuple consisting of a field name and a field instance.
+    If given a nested form will be created consisting of these fields.
+
+    The ``keys`` argument is a list/tuple of field names. If given, a nested form will be created consisting of
+    django.forms.CharField instances, with the given key names. This is primarily for use with
+    django.contrib.postgres.HStoreField. By default, all fields are not required.
+
+    To make all fields required set the ``require_all_fields`` argument to True.
+
+    The ``max_value_length`` is ignored if the ``fields`` argument is given. If the ``keys`` argument is given, the max
+    length for each CharField instance will be set to this value.
+
+    Uses the NestedFormWidget.
+    """
+    def __init__(self, fields=(), keys=(), require_all_fields=False, max_value_length=25, *args, **kwargs):
+        if (fields and keys) or (not fields and not keys):
+            raise ValueError("NestedFormField requires either a tuple of fields or keys but not both")
+
+        if keys:
+            fields = []
+            for key in keys:
+                field = CharField(max_length=max_value_length, required=False)
+                fields.append((key, field))
+        form_fields = []
+        widgets = []
+        self.labels = []
+        self.names = {}
+        for field in fields:
+            label = field[1].label or field[0]
+            self.names[label] = field[0]
+            self.labels.append(label)
+            form_fields.append(field[1])
+            widgets.append(field[1].widget)
+        widget = NestedFormWidget(self.labels, widgets, self.names)
+        super(NestedFormField, self).__init__(*args, fields=form_fields, widget=widget,
+                                              require_all_fields=require_all_fields, **kwargs)
+
+    def compress(self, data_list):
+        result = {}
+        for i, label in enumerate(self.labels):
+            name = self.names[label]
+            result[name] = data_list[i]
+        return result
+
+    def to_python(self, value):
+        if not value:
+            return {}
+        if isinstance(value, dict):
+            return value
+        else:
+            raise ValidationError(
+                self.error_messages['invalid_json'],
+                code='invalid_json',
+            )