0001-django-1.11-support.patch

Emmanuel Cazenave, 17 janvier 2018 15:52

Voir les différences: en ligne côte à côte

Subject: [PATCH] django 1.11 support

* breaks backward compatibility : now nothing is importable directly from the root module
(because django 1.11 requires almost empty root __init__.py for application)
* create a migration file (django 1.11 start application friendliness)
* adopt EO standard packaging practices (in packaging commands and version management)
* adopt EO standard tests and CI practices (tox, pytest, jenkins.sh)

 django_journal/__init__.py                |  75 ----------------------
 django_journal/admin.py                   |   6 +-
 django_journal/main.py                    |  72 +++++++++++++++++++++
 django_journal/middleware.py              |   8 +--
 django_journal/migrations/0001_initial.py | 103 ++++++++++++++++++++++++++++++
 django_journal/migrations/__init__.py     |   0
 django_journal/models.py                  |   6 +-
 django_journal/tests.py                   |  20 ++++--
 jenkins.sh                                |   4 ++
 setup.py                                  |  64 +++++++++----------
 tox.ini                                   |   9 +++
 11 files changed, 243 insertions(+), 124 deletions(-)
 create mode 100644 django_journal/main.py
 create mode 100644 django_journal/migrations/0001_initial.py
 create mode 100644 django_journal/migrations/__init__.py
 create mode 100755 jenkins.sh
 create mode 100644 tox.ini

     import logging
     from exceptions import JournalException
     from models import (Journal, Tag, Template)
     import django.db.models
     from django.conf import settings
     from decorator import atomic
     __all__ = ('record', 'error_record', 'Journal')
     __version__ = '1.25.1'
     def unicode_truncate(s, length, encoding='utf-8'):
         '''Truncate an unicode string so that its UTF-8 encoding is less than
            length.'''
         encoded = s.encode(encoding)[:length]
         return encoded.decode(encoding, 'ignore')
     @atomic
     def record(tag, template, using=None, **kwargs):
         '''Record an event in the journal. The modification is done inside the
            current transaction.
            tag:
                a string identifier giving the type of the event
            tpl:
                a format string to describe the event
            kwargs:
                a mapping of object or data to interpolate in the format string
         '''
         template = unicode(template)
         tag = Tag.objects.using(using).get_cached(name=tag)
         template = Template.objects.using(using).get_cached(content=template)
         try:
             message = template.content.format(**kwargs)
         except (KeyError, IndexError), e:
             raise JournalException(
                     'Missing variable for the template message', template, e)
         try:
             logger = logging.getLogger('django.journal.%s' % tag)
             if tag.name == 'error' or tag.name.startswith('error-'):
                 logger.error(message)
             elif tag.name == 'warning' or tag.name.startswith('warning-'):
                 logger.warning(message)
             else:
                 logger.info(message)
         except:
             try:
                 logging.getLogger('django.journal').exception('Unable to log msg')
             except:
                 pass # we tried, really, we tried
         journal = Journal.objects.using(using).create(tag=tag, template=template,
                 message=unicode_truncate(message, 128))
         for name, value in kwargs.iteritems():
             if value is None:
                 continue
             tag = Tag.objects.using(using).get_cached(name=name)
             if isinstance(value, django.db.models.Model):
                 journal.objectdata_set.create(tag=tag, content_object=value)
             else:
                 journal.stringdata_set.create(tag=tag, content=unicode(value))
         return journal
     def error_record(tag, tpl, **kwargs):
         '''Records error events.
            You must use this function when logging error events. It uses another
            database alias than the default one to be immune to transaction rollback
            when logging in the middle of a transaction which is going to
            rollback.
         '''
         return record(tag, tpl,
                 using=getattr(settings, 'JOURNAL_DB_FOR_ERROR_ALIAS', 'default'),
                 **kwargs)

     from django.contrib.contenttypes.models import ContentType
     from django.utils.html import escape
     from models import Journal, Tag, ObjectData, StringData
     from django.db import models
     from django.utils.translation import ugettext_lazy as _
     from django.utils.html import escape
     from django.core.urlresolvers import reverse, NoReverseMatch
     import actions
     from . import actions
     from .models import Journal, Tag, ObjectData, StringData
     class ModelAdminFormatter(Formatter):
         def __init__(self, model_admin=None, filter_link=True,

     import logging
     from django.conf import settings
     import django.db.models
     from .decorator import atomic
     from .exceptions import JournalException
     from .models import (Journal, Tag, Template)
     def unicode_truncate(s, length, encoding='utf-8'):
         '''Truncate an unicode string so that its UTF-8 encoding is less than
            length.'''
         encoded = s.encode(encoding)[:length]
         return encoded.decode(encoding, 'ignore')
     @atomic
     def record(tag, template, using=None, **kwargs):
         '''Record an event in the journal. The modification is done inside the
            current transaction.
            tag:
                a string identifier giving the type of the event
            tpl:
                a format string to describe the event
            kwargs:
                a mapping of object or data to interpolate in the format string
         '''
         template = unicode(template)
         tag = Tag.objects.using(using).get_cached(name=tag)
         template = Template.objects.using(using).get_cached(content=template)
         try:
             message = template.content.format(**kwargs)
         except (KeyError, IndexError), e:
             raise JournalException(
                     'Missing variable for the template message', template, e)
         try:
             logger = logging.getLogger('django.journal.%s' % tag)
             if tag.name == 'error' or tag.name.startswith('error-'):
                 logger.error(message)
             elif tag.name == 'warning' or tag.name.startswith('warning-'):
                 logger.warning(message)
             else:
                 logger.info(message)
         except:
             try:
                 logging.getLogger('django.journal').exception('Unable to log msg')
             except:
                 pass # we tried, really, we tried
         journal = Journal.objects.using(using).create(tag=tag, template=template,
                 message=unicode_truncate(message, 128))
         for name, value in kwargs.iteritems():
             if value is None:
                 continue
             tag = Tag.objects.using(using).get_cached(name=name)
             if isinstance(value, django.db.models.Model):
                 journal.objectdata_set.create(tag=tag, content_object=value)
             else:
                 journal.stringdata_set.create(tag=tag, content=unicode(value))
         return journal
     def error_record(tag, tpl, **kwargs):
         '''Records error events.
            You must use this function when logging error events. It uses another
            database alias than the default one to be immune to transaction rollback
            when logging in the middle of a transaction which is going to
            rollback.
         '''
         return record(tag, tpl,
                 using=getattr(settings, 'JOURNAL_DB_FOR_ERROR_ALIAS', 'default'),
                 **kwargs)

     import django_journal
     from . import main
     class JournalMiddleware(object):
         '''Add record and error_record methods to the request object to log
-...
                     kwargs['user'] = user
                 if 'ip' not in kwargs:
                     kwargs['ip'] = ip
                 django_journal.record(tag, template, using=using,**kwargs)
             def error_record(tag, template, using=None, **kwargs):
                 main.record(tag, template, using=using, **kwargs)
             def error_record(tag, template, **kwargs):
                 if 'user' not in kwargs:
                     kwargs['user'] = user
                 if 'ip' not in kwargs:
                     kwargs['ip'] = ip
                 django_journal.error_record(tag, template, using=using, **kwargs)
                 main.error_record(tag, template, **kwargs)
             request.record = record
             request.error_record = error_record
             return None

     # -*- coding: utf-8 -*-
     # Generated by Django 1.11.9 on 2018-01-16 08:28
     from __future__ import unicode_literals
     from django.db import migrations, models
     import django.db.models.deletion
     class Migration(migrations.Migration):
         initial = True
         dependencies = [
             ('contenttypes', '0002_remove_content_type_name'),
+        ]
         operations = [
             migrations.CreateModel(
                 name='Journal',
                 fields=[
                     ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                     ('time', models.DateTimeField(auto_now_add=True, db_index=True, verbose_name='time')),
                     ('message', models.CharField(db_index=True, max_length=128, verbose_name='message')),
                 ],
                 options={
                     'ordering': ('-id',),
                     'verbose_name': 'journal entry',
                     'verbose_name_plural': 'journal entries',
                 },
             ),
             migrations.CreateModel(
                 name='ObjectData',
                 fields=[
                     ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                     ('object_id', models.PositiveIntegerField(db_index=True, verbose_name='object id')),
                     ('content_type', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='contenttypes.ContentType', verbose_name='content type')),
                     ('journal', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='django_journal.Journal', verbose_name='journal entry')),
                 ],
                 options={
                     'verbose_name': 'linked object',
                 },
             ),
             migrations.CreateModel(
                 name='StringData',
                 fields=[
                     ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                     ('content', models.TextField(verbose_name='content')),
                     ('journal', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='django_journal.Journal', verbose_name='journal entry')),
                 ],
                 options={
                     'verbose_name': 'linked text string',
                 },
             ),
             migrations.CreateModel(
                 name='Tag',
                 fields=[
                     ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                     ('name', models.CharField(db_index=True, max_length=32, unique=True, verbose_name='name')),
                 ],
                 options={
                     'ordering': ('name',),
                     'verbose_name': 'tag',
                 },
             ),
             migrations.CreateModel(
                 name='Template',
                 fields=[
                     ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                     ('content', models.TextField(db_index=True, unique=True, verbose_name='content')),
                 ],
                 options={
                     'ordering': ('content',),
                 },
             ),
             migrations.AddField(
                 model_name='stringdata',
                 name='tag',
                 field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='django_journal.Tag', verbose_name='tag'),
             ),
             migrations.AddField(
                 model_name='objectdata',
                 name='tag',
                 field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='django_journal.Tag', verbose_name='tag'),
             ),
             migrations.AddField(
                 model_name='journal',
                 name='tag',
                 field=models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, to='django_journal.Tag', verbose_name='tag'),
             ),
             migrations.AddField(
                 model_name='journal',
                 name='template',
                 field=models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, to='django_journal.Template', verbose_name='template'),
             ),
             migrations.AlterUniqueTogether(
                 name='stringdata',
                 unique_together=set([('journal', 'tag')]),
             ),
             migrations.AlterUniqueTogether(
                 name='objectdata',
                 unique_together=set([('journal', 'tag')]),
             ),
+        ]

     import string
     from django.db import models
     from django.contrib.contenttypes import generic
     from django.contrib.contenttypes.fields import GenericForeignKey
     from django.utils.translation import ugettext_lazy as _
     import managers
     from . import managers
     class Tag(models.Model):
-...
                 verbose_name=_('content type'))
         object_id = models.PositiveIntegerField(db_index=True,
                 verbose_name=_('object id'))
         content_object = generic.GenericForeignKey('content_type',
         content_object = GenericForeignKey('content_type',
                 'object_id')
         class Meta:

     from django.test import TestCase
     from django.contrib.auth.models import User, Group
     from django.db import transaction
     from django.db.transaction import atomic
     from . import record
     from .main import record
     from . import actions
     from . import models
     class JournalTestCase(TestCase):
         def setUp(self):
             models.JOURNAL_METADATA_CACHE_TIMEOUT = 0
             self.users = []
             self.groups = []
             with transaction.commit_on_success():
             with atomic():
                 for i in range(20):
                     self.users.append(
                             User.objects.create(username='user%s' % i))
-...
             l = list(actions.export_as_csv_generator(qs))
             self.assertEquals(l[1]['user'], '<deleted>')
     def test_middleware(db):
         class FakeRequest(object):
             META = dict()
         from .middleware import JournalMiddleware
         jm = JournalMiddleware()
         request = FakeRequest()
         jm.process_request(request)
         request.record('yes', 'we can')
         request.error_record('me', 'too')

jenkins.sh
	1	#!/bin/bash -e
	2
	3	pip install -U tox
	4	tox -r

     #!/usr/bin/python
     import os
     import subprocess
     import sys
     from setuptools import setup, find_packages
     from setuptools.command.install_lib import install_lib as _install_lib
     from distutils.command.build import build as _build
     from setuptools.command.sdist import sdist as _sdist
     from setuptools.command.sdist import sdist
     from distutils.cmd import Command
-...
         sub_commands = [('compile_translations', None)] + _build.sub_commands
     class sdist(_sdist):
         sub_commands = [('compile_translations', None)] + _sdist.sub_commands
     class eo_sdist(sdist):
         def run(self):
             print "creating VERSION file"
             if os.path.exists('VERSION'):
                 os.remove('VERSION')
             version = get_version()
             version_file = open('VERSION', 'w')
             version_file.write(version)
             version_file.close()
             sdist.run(self)
             print "removing VERSION file"
             if os.path.exists('VERSION'):
                 os.remove('VERSION')
     class install_lib(_install_lib):
-...
     def get_version():
         import glob
         import re
         import os
         version = None
         for d in glob.glob('*'):
             if not os.path.isdir(d):
                 continue
             module_file = os.path.join(d, '__init__.py')
             if not os.path.exists(module_file):
                 continue
             for v in re.findall("""__version__ *= *['"](.*)['"]""",
                     open(module_file).read()):
                 assert version is None
                 version = v
             if version:
                 break
         assert version is not None
         if os.path.exists('VERSION'):
             version_file = open('VERSION', 'r')
             version = version_file.read()
             version_file.close()
             return version
         if os.path.exists('.git'):
             import subprocess
             p = subprocess.Popen(['git','describe','--dirty', '--match=v*'],
                     stdout=subprocess.PIPE)
             p = subprocess.Popen(['git', 'describe', '--match=v*'], stdout=subprocess.PIPE)
             result = p.communicate()[0]
             assert p.returncode == 0, 'git returned non-zero'
             new_version = result.split()[0][1:]
             major_minor_release = new_version.split('-')[0]
             assert  version == major_minor_release, \
                     '__version__ (%s) must match the last git annotated tag (%s)' % (version, major_minor_release)
             version = new_version.replace('-', '.').replace('.g', '+g')
         return version
             version = result.split()[0][1:]
             version = version.replace('-', '.')
             return version
         return '0'
     setup(name='django-journal',
           version=get_version(),
-...
               'build': build,
               'install_lib': install_lib,
               'compile_translations': compile_translations,
               'sdist': sdist,
               'sdist': eo_sdist,
               'test': test
           },
           install_requires=[
               'django >= 1.7',
               'django >= 1.11,<2.0',
               'django-model-utils',
           ],
           setup_requires=[
               'django >= 1.4.2',
               'django >= 1.11,<2.0',
           ])

     [testenv]
     usedevelop = True
     deps =
       pytest
       pytest-django
     setenv =
       DJANGO_SETTINGS_MODULE=test_settings
     commands =
       {posargs:py.test --junitxml=junit.xml django_journal/tests.py}
+    -

Projet

Général

Profil

Produits Entr'ouvert » Django Journal

0001-django-1.11-support.patch