apps/picture/models.py

   1 from django.db import models, transaction
   2 import catalogue.models
   3 from django.db.models import permalink
   4 from sorl.thumbnail import ImageField
   5 from django.conf import settings
   6 from django.core.files.storage import FileSystemStorage
   7 from django.utils.datastructures import SortedDict
   8 from django.template.loader import render_to_string
   9 from django.utils.safestring import mark_safe
  10 from django.core.cache import get_cache
  11 from catalogue.utils import split_tags, related_tag_name
  12 from django.utils.safestring import mark_safe
  13 from fnpdjango.utils.text.slughifi import slughifi
  14 from picture import tasks
  15 from StringIO import StringIO
  16 import jsonfield
  17 import itertools
  18 import logging
  19 from sorl.thumbnail import get_thumbnail, default
  20 from .engine import CustomCroppingEngine
  21
  22 from PIL import Image
  23
  24 from django.utils.translation import get_language, ugettext_lazy as _
  25 from newtagging import managers
  26 from os import path
  27
  28
  29 permanent_cache = get_cache('permanent')
  30
  31 picture_storage = FileSystemStorage(location=path.join(
  32         settings.MEDIA_ROOT, 'pictures'),
  33         base_url=settings.MEDIA_URL + "pictures/")
  34
  35
  36 class PictureArea(models.Model):
  37     picture = models.ForeignKey('picture.Picture', related_name='areas')
  38     area = jsonfield.JSONField(_('area'), default={}, editable=False)
  39     kind = models.CharField(_('kind'), max_length=10, blank=False,
  40                            null=False, db_index=True,
  41                            choices=(('thing', _('thing')),
  42                                     ('theme', _('theme'))))
  43
  44     objects     = models.Manager()
  45     tagged      = managers.ModelTaggedItemManager(catalogue.models.Tag)
  46     tags        = managers.TagDescriptor(catalogue.models.Tag)
  47
  48     @classmethod
  49     def rectangle(cls, picture, kind, coords):
  50         pa = PictureArea()
  51         pa.picture = picture
  52         pa.kind = kind
  53         pa.area = coords
  54         return pa
  55
  56     def reset_short_html(self):
  57         if self.id is None:
  58             return
  59
  60         cache_key = "PictureArea.short_html/%d/%s"
  61         for lang, langname in settings.LANGUAGES:
  62             permanent_cache.delete(cache_key % (self.id, lang))
  63
  64
  65     def short_html(self):
  66         if self.id:
  67             cache_key = "PictureArea.short_html/%d/%s" % (self.id, get_language())
  68             short_html = permanent_cache.get(cache_key)
  69         else:
  70             short_html = None
  71
  72         if short_html is not None:
  73             return mark_safe(short_html)
  74         else:
  75             theme = self.tags.filter(category='theme')
  76             theme = theme and theme[0] or None
  77             thing = self.tags.filter(category='thing')
  78             thing = thing and thing[0] or None
  79             area = self
  80             short_html = unicode(render_to_string(
  81                     'picture/picturearea_short.html', locals()))
  82             if self.id:
  83                 permanent_cache.set(cache_key, short_html)
  84             return mark_safe(short_html)
  85
  86
  87 class Picture(models.Model):
  88     """
  89     Picture resource.
  90
  91     """
  92     title       = models.CharField(_('title'), max_length=120)
  93     slug        = models.SlugField(_('slug'), max_length=120, db_index=True, unique=True)
  94     sort_key    = models.CharField(_('sort key'), max_length=120, db_index=True, editable=False)
  95     sort_key_author = models.CharField(_('sort key by author'), max_length=120, db_index=True, editable=False, default=u'')
  96     created_at  = models.DateTimeField(_('creation date'), auto_now_add=True, db_index=True)
  97     changed_at  = models.DateTimeField(_('creation date'), auto_now=True, db_index=True)
  98     xml_file    = models.FileField('xml_file', upload_to="xml", storage=picture_storage)
  99     image_file  = ImageField(_('image_file'), upload_to="images", storage=picture_storage)
 100     html_file   = models.FileField('html_file', upload_to="html", storage=picture_storage)
 101     areas_json       = jsonfield.JSONField(_('picture areas JSON'), default={}, editable=False)
 102     extra_info    = jsonfield.JSONField(_('extra information'), default={})
 103     culturepl_link   = models.CharField(blank=True, max_length=240)
 104     wiki_link     = models.CharField(blank=True, max_length=240)
 105
 106     _related_info = jsonfield.JSONField(blank=True, null=True, editable=False)
 107
 108     width       = models.IntegerField(null=True)
 109     height      = models.IntegerField(null=True)
 110
 111     objects     = models.Manager()
 112     tagged      = managers.ModelTaggedItemManager(catalogue.models.Tag)
 113     tags        = managers.TagDescriptor(catalogue.models.Tag)
 114
 115     class AlreadyExists(Exception):
 116         pass
 117
 118     class Meta:
 119         ordering = ('sort_key',)
 120
 121         verbose_name = _('picture')
 122         verbose_name_plural = _('pictures')
 123
 124     def save(self, force_insert=False, force_update=False, reset_short_html=True, **kwargs):
 125         from sortify import sortify
 126
 127         self.sort_key = sortify(self.title)
 128
 129         ret = super(Picture, self).save(force_insert, force_update)
 130
 131         if reset_short_html:
 132             self.reset_short_html()
 133
 134         return ret
 135
 136     def __unicode__(self):
 137         return self.title
 138
 139     @permalink
 140     def get_absolute_url(self):
 141         return ('picture.views.picture_detail', [self.slug])
 142
 143     @classmethod
 144     def from_xml_file(cls, xml_file, image_file=None, image_store=None, overwrite=False):
 145         """
 146         Import xml and it's accompanying image file.
 147         If image file is missing, it will be fetched by librarian.picture.ImageStore
 148         which looks for an image file in the same directory the xml is, with extension matching
 149         its mime type.
 150         """
 151         from sortify import sortify
 152         from django.core.files import File
 153         from librarian.picture import WLPicture, ImageStore
 154         close_xml_file = False
 155         close_image_file = False
 156
 157
 158         if image_file is not None and not isinstance(image_file, File):
 159             image_file = File(open(image_file))
 160             close_image_file = True
 161
 162         if not isinstance(xml_file, File):
 163             xml_file = File(open(xml_file))
 164             close_xml_file = True
 165
 166         try:
 167             # use librarian to parse meta-data
 168             if image_store is None:
 169                 image_store = ImageStore(picture_storage.path('images'))
 170             picture_xml = WLPicture.from_file(xml_file, image_store=image_store)
 171
 172             picture, created = Picture.objects.get_or_create(slug=picture_xml.slug)
 173             if not created and not overwrite:
 174                 raise Picture.AlreadyExists('Picture %s already exists' % picture_xml.slug)
 175
 176             picture.areas.all().delete()
 177             picture.title = unicode(picture_xml.picture_info.title)
 178             picture.extra_info = picture_xml.picture_info.to_dict()
 179
 180             picture_tags = set(catalogue.models.Tag.tags_from_info(picture_xml.picture_info))
 181             motif_tags = set()
 182             thing_tags = set()
 183
 184             area_data = {'themes':{}, 'things':{}}
 185
 186             for part in picture_xml.partiter():
 187                 if picture_xml.frame:
 188                     c = picture_xml.frame[0]
 189                     part['coords'] = [[p[0] - c[0], p[1] - c[1]] for p in part['coords']]
 190                 if part.get('object', None) is not None:
 191                     objname = part['object']
 192                     tag, created = catalogue.models.Tag.objects.get_or_create(slug=slughifi(objname), category='thing')
 193                     if created:
 194                         tag.name = objname
 195                         tag.sort_key = sortify(tag.name)
 196                         tag.save()
 197                     #thing_tags.add(tag)
 198                     area_data['things'][tag.slug] = {
 199                         'object': part['object'],
 200                         'coords': part['coords'],
 201                         }
 202                     area = PictureArea.rectangle(picture, 'thing', part['coords'])
 203                     area.save()
 204                     _tags = set()
 205                     _tags.add(tag)
 206                     area.tags = _tags
 207                 else:
 208                     _tags = set()
 209                     for motif in part['themes']:
 210                         tag, created = catalogue.models.Tag.objects.get_or_create(slug=slughifi(motif), category='theme')
 211                         if created:
 212                             tag.name = motif
 213                             tag.sort_key = sortify(tag.name)
 214                             tag.save()
 215                         #motif_tags.add(tag)
 216                         _tags.add(tag)
 217                         area_data['themes'][tag.slug] = {
 218                             'theme': motif,
 219                             'coords': part['coords']
 220                             }
 221
 222                     logging.debug("coords for theme: %s" % part['coords'])
 223                     area = PictureArea.rectangle(picture, 'theme', part['coords'])
 224                     area.save()
 225                     area.tags = _tags.union(picture_tags)
 226
 227             picture.tags = picture_tags.union(motif_tags).union(thing_tags)
 228             picture.areas_json = area_data
 229
 230             if image_file is not None:
 231                 img = image_file
 232             else:
 233                 img = picture_xml.image_file()
 234
 235             modified = cls.crop_to_frame(picture_xml, img)
 236             modified = cls.add_source_note(picture_xml, modified)
 237
 238             picture.width, picture.height = modified.size
 239
 240             modified_file = StringIO()
 241             modified.save(modified_file, format='png', quality=95)
 242             # FIXME: hardcoded extension - detect from DC format or orginal filename
 243             picture.image_file.save(path.basename(picture_xml.image_path), File(modified_file))
 244
 245             picture.xml_file.save("%s.xml" % picture.slug, File(xml_file))
 246             picture.save()
 247             tasks.generate_picture_html(picture.id)
 248
 249         except Exception, ex:
 250             logging.exception("Exception during import, rolling back")
 251             transaction.rollback()
 252             raise ex
 253
 254         finally:
 255             if close_xml_file:
 256                 xml_file.close()
 257             if close_image_file:
 258                 image_file.close()
 259
 260         transaction.commit()
 261
 262         return picture
 263
 264     @classmethod
 265     def crop_to_frame(cls, wlpic, image_file):
 266         img = Image.open(image_file)
 267         if wlpic.frame is None:
 268             return img
 269         img = img.crop(itertools.chain(*wlpic.frame))
 270         return img
 271
 272     @staticmethod
 273     def add_source_note(wlpic, img):
 274         from PIL import ImageDraw, ImageFont
 275         from librarian import get_resource
 276
 277         annotated = Image.new(img.mode,
 278                 (img.size[0], img.size[1] + 40),
 279                 (255, 255, 255)
 280             )
 281         annotated.paste(img, (0, 0))
 282         annotation = Image.new(img.mode, (3000, 120), (255, 255, 255))
 283         ImageDraw.Draw(annotation).text(
 284             (30, 15),
 285             wlpic.picture_info.source_name,
 286             (0, 0, 0),
 287             font=ImageFont.truetype(get_resource("fonts/DejaVuSerif.ttf"), 75)
 288         )
 289         annotated.paste(annotation.resize((1000, 40), Image.ANTIALIAS), (0, img.size[1]))
 290         return annotated
 291
 292     @classmethod
 293     def picture_list(cls, filter=None):
 294         """Generates a hierarchical listing of all pictures
 295         Pictures are optionally filtered with a test function.
 296         """
 297
 298         pics = cls.objects.all().order_by('sort_key')\
 299             .only('title', 'slug', 'image_file')
 300
 301         if filter:
 302             pics = pics.filter(filter).distinct()
 303
 304         pics_by_author = SortedDict()
 305         orphans = []
 306         for tag in catalogue.models.Tag.objects.filter(category='author'):
 307             pics_by_author[tag] = []
 308
 309         for pic in pics.iterator():
 310             authors = list(pic.tags.filter(category='author'))
 311             if authors:
 312                 for author in authors:
 313                     pics_by_author[author].append(pic)
 314             else:
 315                 orphans.append(pic)
 316
 317         return pics_by_author, orphans
 318
 319     @property
 320     def info(self):
 321         if not hasattr(self, '_info'):
 322             from librarian import dcparser
 323             from librarian import picture
 324             info = dcparser.parse(self.xml_file.path, picture.PictureInfo)
 325             self._info = info
 326         return self._info
 327
 328     def reset_short_html(self):
 329         if self.id is None:
 330             return
 331
 332         type(self).objects.filter(pk=self.pk).update(_related_info=None)
 333         for area in self.areas.all().iterator():
 334             area.reset_short_html()
 335
 336         try:
 337             author = self.tags.filter(category='author')[0].sort_key
 338         except IndexError:
 339             author = u''
 340         type(self).objects.filter(pk=self.pk).update(sort_key_author=author)
 341
 342         cache_key = "Picture.short_html/%d/%s"
 343         for lang, langname in settings.LANGUAGES:
 344             permanent_cache.delete(cache_key % (self.id, lang))
 345
 346     def short_html(self):
 347         if self.id:
 348             cache_key = "Picture.short_html/%d/%s" % (self.id, get_language())
 349             short_html = get_cache('permanent').get(cache_key)
 350         else:
 351             short_html = None
 352
 353         if short_html is not None:
 354             return mark_safe(short_html)
 355         else:
 356             tags = self.tags.filter(category__in=('author', 'kind', 'epoch', 'genre'))
 357             tags = split_tags(tags)
 358
 359             short_html = unicode(render_to_string(
 360                     'picture/picture_short.html',
 361                     {'picture': self, 'tags': tags}))
 362
 363             if self.id:
 364                 get_cache('permanent').set(cache_key, short_html)
 365             return mark_safe(short_html)
 366
 367     def pretty_title(self, html_links=False):
 368         picture = self
 369         # TODO Add translations (related_tag_info)
 370         names = [(tag.name,
 371                   catalogue.models.Tag.create_url('author', tag.slug))
 372                  for tag in self.tags.filter(category='author')]
 373         names.append((self.title, self.get_absolute_url()))
 374
 375         if html_links:
 376             names = ['<a href="%s">%s</a>' % (tag[1], tag[0]) for tag in names]
 377         else:
 378             names = [tag[0] for tag in names]
 379         return ', '.join(names)
 380
 381     def related_info(self):
 382         """Keeps info about related objects (tags) in cache field."""
 383         if self._related_info is not None:
 384             return self._related_info
 385         else:
 386             rel = {'tags': {}}
 387
 388             tags = self.tags.filter(category__in=(
 389                     'author', 'kind', 'genre', 'epoch'))
 390             tags = split_tags(tags)
 391             for category in tags:
 392                 cat = []
 393                 for tag in tags[category]:
 394                     tag_info = {'slug': tag.slug, 'name': tag.name}
 395                     for lc, ln in settings.LANGUAGES:
 396                         tag_name = getattr(tag, "name_%s" % lc)
 397                         if tag_name:
 398                             tag_info["name_%s" % lc] = tag_name
 399                     cat.append(tag_info)
 400                 rel['tags'][category] = cat
 401
 402
 403             if self.pk:
 404                 type(self).objects.filter(pk=self.pk).update(_related_info=rel)
 405             return rel
 406
 407     # copied from book.py, figure out
 408     def related_themes(self):
 409         # self.theme_counter hides a computation, so a line below actually makes sense
 410         theme_counter = self.theme_counter
 411         picture_themes = list(catalogue.models.Tag.objects.filter(pk__in=theme_counter.keys()))
 412         for tag in picture_themes:
 413             tag.count = theme_counter[tag.pk]
 414         return picture_themes
 415
 416     def reset_tag_counter(self):
 417         if self.id is None:
 418             return
 419
 420         cache_key = "Picture.tag_counter/%d" % self.id
 421         permanent_cache.delete(cache_key)
 422         if self.parent:
 423             self.parent.reset_tag_counter()
 424
 425     @property
 426     def tag_counter(self):
 427         if self.id:
 428             cache_key = "Picture.tag_counter/%d" % self.id
 429             tags = permanent_cache.get(cache_key)
 430         else:
 431             tags = None
 432
 433         if tags is None:
 434             tags = {}
 435             # do we need to do this? there are no children here.
 436             for tag in self.tags.exclude(category__in=('book', 'theme', 'thing', 'set')).order_by().iterator():
 437                 tags[tag.pk] = 1
 438
 439             if self.id:
 440                 permanent_cache.set(cache_key, tags)
 441         return tags
 442
 443     def reset_theme_counter(self):
 444         if self.id is None:
 445             return
 446
 447         cache_key = "Picture.theme_counter/%d" % self.id
 448         permanent_cache.delete(cache_key)
 449
 450     @property
 451     def theme_counter(self):
 452         if self.id:
 453             cache_key = "Picture.theme_counter/%d" % self.id
 454             tags = permanent_cache.get(cache_key)
 455         else:
 456             tags = None
 457
 458         if tags is None:
 459             tags = {}
 460             for area in PictureArea.objects.filter(picture=self).order_by().iterator():
 461                 for tag in area.tags.filter(category__in=('theme','thing')).order_by().iterator():
 462                     tags[tag.pk] = tags.get(tag.pk, 0) + 1
 463
 464             if self.id:
 465                 permanent_cache.set(cache_key, tags)
 466         return tags