def ready(self):
image_path = getattr(settings, "PINAX_EVENTS_IMAGE_THUMBNAIL_SPEC",
"pinax.events.specs.ImageThumbnail")
secondary_image_path = getattr(
settings, "PINAX_EVENTS_SECONDARY_IMAGE_THUMBNAIL_SPEC",
"pinax.events.specs.SecondaryImageThumbnail")
image_spec_class = load_path_attr(image_path)
secondary_image_spec_class = load_path_attr(secondary_image_path)
register.generator("pinax_events:image:thumb", image_spec_class)
register.generator("pinax_events:secondary_image:thumb",
secondary_image_spec_class)
def ready(self):
thumbnail_path = getattr(
settings,
"PINAX_IMAGES_THUMBNAIL_SPEC",
"pinax.images.specs.ImageThumbnail"
)
thumbnail_spec_class = load_path_attr(thumbnail_path)
register.generator("pinax_images:image:thumbnail", thumbnail_spec_class)
list_thumbnail_path = getattr(
settings,
"PINAX_IMAGES_LIST_THUMBNAIL_SPEC",
"pinax.images.specs.ImageListThumbnail"
)
list_thumbnail_spec_class = load_path_attr(list_thumbnail_path)
register.generator("pinax_images:image:list_thumbnail", list_thumbnail_spec_class)
small_thumbnail_path = getattr(
settings,
"PINAX_IMAGES_SMALL_THUMBNAIL_SPEC",
"pinax.images.specs.ImageSmallThumbnail"
)
small_thumbnail_spec_class = load_path_attr(small_thumbnail_path)
register.generator("pinax_images:image:small_thumbnail", small_thumbnail_spec_class)
medium_thumbnail_path = getattr(
settings,
"PINAX_IMAGES_MEDIUM_THUMBNAIL_SPEC",
"pinax.images.specs.ImageMediumThumbnail"
)
medium_thumbnail_spec_class = load_path_attr(medium_thumbnail_path)
register.generator("pinax_images:image:medium_thumbnail", medium_thumbnail_spec_class)
def ready(self):
image_path = getattr(
settings,
"PINAX_NEWS_IMAGE_THUMBNAIL_SPEC",
"pinax.news.specs.ImageThumbnail"
)
secondary_image_path = getattr(
settings,
"PINAX_NEWS_SECONDARY_IMAGE_THUMBNAIL_SPEC",
"pinax.news.specs.SecondaryImageThumbnail"
)
image_spec_class = load_path_attr(image_path)
secondary_image_spec_class = load_path_attr(secondary_image_path)
register.generator("pinax_news:image:thumb", image_spec_class)
register.generator("pinax_news:secondary_image:thumb", secondary_image_spec_class)
def ready(self):
thumbnail_path = getattr(
settings,
"USERS_IMAGES_THUMBNAIL_SPEC",
"users.specs.ImageThumbnail"
)
thumbnail_spec_class = load_path_attr(thumbnail_path)
register.generator("users:avatar:thumbnail", thumbnail_spec_class)
list_thumbnail_path = getattr(
settings,
"USERS_IMAGES_LIST_THUMBNAIL_SPEC",
"users.specs.ImageListThumbnail"
)
list_thumbnail_spec_class = load_path_attr(list_thumbnail_path)
register.generator("users:avatar:list_thumbnail", list_thumbnail_spec_class)
small_thumbnail_path = getattr(
settings,
"USERS_IMAGES_SMALL_THUMBNAIL_SPEC",
"users.specs.ImageSmallThumbnail"
)
small_thumbnail_spec_class = load_path_attr(small_thumbnail_path)
register.generator("users:avatar:small_thumbnail", small_thumbnail_spec_class)
medium_thumbnail_path = getattr(
settings,
"USERS_IMAGES_MEDIUM_THUMBNAIL_SPEC",
"users.specs.ImageMediumThumbnail"
)
medium_thumbnail_spec_class = load_path_attr(medium_thumbnail_path)
register.generator("users:avatar:medium_thumbnail", medium_thumbnail_spec_class)
try:
pass
#import users.signals # noqa F401
except ImportError:
pass
from imagekit import ImageSpec, register
from imagekit.processors import SmartResize
class PopupThumbnail(ImageSpec):
processors = [SmartResize(width=380, height=100, upscale=False)]
format = 'PNG'
options = {'quality': 90}
register.generator('growing_places:popupthumbnail', PopupThumbnail)
def __str__(self):
return self.name
class Meta:
ordering = ['name']
verbose_name = 'produkt'
verbose_name_plural = 'produkty'
class ImageThumbnail(ImageSpec):
@property
def processors(self):
model, field_name = get_field_info(self.source)
return [ResizeToFill(model.THUMB_WIDTH, model.THUMB_HEIGHT)]
register.generator('mainapp:image:image_thumbnail', ImageThumbnail)
def upload_to(instance, filename):
switch = {ArticleImage: 'articles', ProductImage: 'shop'}
directory = switch.pop(instance.__class__, '')
return '/'.join([directory, filename])
class Image(models.Model):
THUMB_WIDTH = 100
THUMB_HEIGHT = 70
image = models.ImageField(upload_to=upload_to, null=True)
image_thumbnail = ImageSpecField(source='image',
id='mainapp:image:image_thumbnail',
format='JPEG',
from imagekit import ImageSpec, register
from imagekit.processors import SmartResize
"""image kit module spec"""
class RecipeDetail(ImageSpec):
processors = [SmartResize(230, 230)]
format = 'PNG'
class RecipeList(ImageSpec):
processors = [SmartResize(120, 160)]
format = 'PNG'
register.generator('recipe:detail', RecipeDetail)
register.generator('recipe:list', RecipeList)
try:
from imagekit import register
from .contrib.imagekit.generatorlibrary import OriginResolution, Thumbnail
except ImportError:
pass
else:
register.generator('cdn:thumbnail', Thumbnail)
register.generator('cdn:origin_resolution', OriginResolution)
verbose_name = _(u"Image")
verbose_name_plural = _(u"Images")
def __unicode__(self):
return self.description
class WinePicture(models.Model):
image = models.ImageField(upload_to="images/%Y/%m/%d/%h %i %s")
thumbnail = ImageSpecField(source='image',
processors=[ResizeToFill(100, 100)],
format='JPEG',
options={'quality': 60})
description = models.CharField(_(u"Description"), max_length=50)
class Meta:
verbose_name = _(u"Image")
verbose_name_plural = _(u"Images")
def __unicode__(self):
return self.description
class Thumbnail(ImageSpec):
processors = [ResizeToFill(100, 100)]
format = 'JPEG'
options = {'quality': 60}
register.generator('images:thumbnail', Thumbnail)
from django.db.models.signals import pre_delete
from django.template.defaultfilters import slugify
from imagekit import ImageSpec, register
from imagekit.processors import ResizeToFill
from smart_selects.db_fields import GroupedForeignKey, ChainedForeignKey
from django.utils.translation import ugettext as _
import twitter
"""
Property thumbnail
"""
class Thumbnail(ImageSpec):
processors = [ResizeToFill(300, 150)]
format = 'JPEG'
options = {'quality': 60}
register.generator('myapp:thumbnail', Thumbnail)
"""
Category model - RENT, SALE, FEATURED etc.
"""
@python_2_unicode_compatible
class Category(models.Model):
category = models.CharField(max_length=30)
def __unicode__(self):
return unicode(self.category)
class Meta:
verbose_name = 'category'
verbose_name_plural = 'categories'
def __getitem__(self,items):
from imagekit import ImageSpec
from imagekit import register
from imagekit.processors import Thumbnail
class InvestmentCard(ImageSpec):
processors = [Thumbnail(400, 400, crop=True, upscale=True)]
format = 'JPEG'
options = {'quality': 75}
class InvestmentDetail(ImageSpec):
processors = [Thumbnail(400, 999, crop=False, upscale=False)]
format = 'JPEG'
options = {'quality': 75}
register.generator('constriction.investments:card', InvestmentCard)
register.generator('constriction.investments:detail', InvestmentDetail)
from imagekit import ImageSpec, register
from imagekit.processors import ResizeToFill
class Thumbnail(ImageSpec):
processors = [ResizeToFill(100, 50)]
format = 'JPEG'
options = {'quality': 100}
register.generator('CGTA:thumbnail', Thumbnail)
add_introspection_rules([], [r"core.\thumb.\ImageSpecField"])
# Create your models here.
class ImageThumbnail(ImageSpec):
format = "JPEG"
options = {"quality": 80}
cache_to="thumbnails"
@property
def processors(self):
model, field = get_field_info(self.source)
return [ResizeToFit(400)]
register.generator("core:image:image_thumbnail", ImageThumbnail)
class UserProfile(models.Model):
user = models.OneToOneField(User, related_name="profile")
homepage = models.TextField(blank=True)
avatar = ProcessedImageField(upload_to="avatars",
blank=True,
processors=[SmartResize(100, 100)],
format="JPEG",
options={"quality": 80})
def delete(self, *args, **kwargs):
self.avarar.delete(False)
super(UserProfile, self).delete(*args, **kwargs)
from imagekit import ImageSpec, register
from imagekit.processors import ResizeToFill
class Slide(ImageSpec):
processors = [ResizeToFill(1110, 400)]
format = "WEBP"
options = {"quality": 70}
register.generator("LZK:slide", Slide)
from imagekit import ImageSpec, register
from imagekit.processors import SmartResize
class DetailPageThumbnail(ImageSpec):
processors = [SmartResize(100, 100)]
format = 'PNG'
options = {'quality': 80}
register.generator('lots:detail_page_thumbnail', DetailPageThumbnail)
from accounts.models import Account
class LogoProcessor(ImageSpec):
format = 'JPEG'
options = {'quality': 90}
@property
def processors(self):
logoimage = self.source
image = Image.open(logoimage)
rgb_image = image.convert('RGB')
background_color = rgb_image.getpixel((1, 1))
if background_color == (0, 0, 0):
background_color = (255,255,255)
return [ResizeToFit(300, 300,mat_color=(background_color))]
register.generator('logo_processor', LogoProcessor)
class Company(models.Model):
account = models.ForeignKey('accounts.Account',blank=True,null=True)
company_name = models.CharField(max_length=200,default='')
company_slug = models.SlugField(max_length=255, blank=True)
company_url = models.URLField(max_length=200,default='')
company_logo = models.ImageField(upload_to=settings.MEDIA_ROOT,default='')
company_logo_thumb = ImageSpecField(
source='company_logo',
id='logo_processor'
)
company_featured_image = models.ImageField(upload_to=settings.MEDIA_ROOT,default='',blank=True)
company_featured_image_thumb = ImageSpecField(
source='company_featured_image',
processors=[ResizeToFill(1200, 500)],
self.slug = slugify(self.title)
super(Panel, self).save(*args, **kwargs)
def get_absolute_url(self):
return "{}#{}".format(self.page.get_absolute_url(), self.slug)
from imagekit import ImageSpec, register
from imagekit.processors import ResizeToFill
class SlideImage(ImageSpec):
processors = [ResizeToFill(800, 700)]
format = 'JPEG'
options = {'quality': 60}
register.generator('mb:slideimage', SlideImage)
class SlideShow(models.Model):
class Meta:
ordering = ['title']
title = models.CharField(max_length=128, blank=True, default='')
slug = models.SlugField(max_length=200)
content = models.TextField(blank=True, default='')
css = models.TextField(blank=True, default='')
static_content = models.BooleanField(default=False)
delay = models.IntegerField(default=3)
def save(self, *args, **kwargs):
self.slug = slugify(self.title)
super(SlideShow, self).save(*args, **kwargs)
from imagekit import ImageSpec, register
from pilkit.processors import ResizeToFill
class ChildThumbnail(ImageSpec):
processors = [ResizeToFill(100, 100)]
format = 'JPEG'
options = {'quality': 80}
class GalleryThumbnail(ImageSpec):
processors = [ResizeToFill(80, 80)]
format = 'JPEG'
options = {'quality': 80}
register.generator('child:thumbnail', ChildThumbnail)
register.generator('gallery:thumbnail', GalleryThumbnail)
from imagekit import ImageSpec, register
from imagekit.processors import ResizeToFill
class Thumbnail(ImageSpec):
processors = [ResizeToFill(100, 50)]
format = 'JPEG'
options = {'quality': 60}
class ProfilePic(ImageSpec):
processors = [ResizeToFill(300, 300)]
format = 'JPEG'
options = {'quality': 60}
register.generator('accounts:thumbnail', Thumbnail)
register.generator('accounts:profile_pic', ProfilePic)
resize it appropriately.
"""
format = 'JPEG'
options = {'quality': 60}
@property
def processors(self):
""" Dynamically create the list of image processors using the model
instance. """
instance, field_name = get_field_info(self.source)
return [
ExifGpsExtractor(instance),
ResizeToFit(1000, 1000, False),
]
register.generator('plantshare:screenedimage:plantsharegpsimage',
PlantshareGpsImage)
class ScreenedImage(models.Model):
image = ProcessedImageField(upload_to=rename_image_by_type,
storage=upload_storage,
spec_id='plantshare:screenedimage:plantsharegpsimage')
thumb = ImageSpecField(source='image', format='JPEG',
options={'quality': 60},
processors=[ResizeToFit(128, 128, upscale=True)])
# Add another thumbnail, cropped and centered with consistent
# dimensions regardless of portrait or landscape orientation.
thumb_cropped = ImageSpecField(source='image', format='JPEG',
options={'quality': 60},
processors=[SmartResize(183, 149, upscale=True)])
format = "JPEG"
options = {"quality": 60}
class SightingImageSmall(ImageSpec):
processors = [SmartResize(300, 300)]
format = "JPEG"
options = {"quality": 80}
class SightingImageMedium(ImageSpec):
processors = [SmartResize(750, 750)]
format = "JPEG"
options = {"quality": 80}
# try:
register.generator("sighting:thumbnail", SightingImageThumbnail)
# except imagekit.exceptions.AlreadyRegistered:
# pass
# try:
register.generator("sighting:small", SightingImageSmall)
# except imagekit.exceptions.AlreadyRegistered:
# pass
# try:
register.generator("sighting:medium", SightingImageMedium)
# except imagekit.exceptions.AlreadyRegistered:
# pass
class IThumbnail(ImageSpec):
processors = [ResizeToFit(90, 130)]
format = 'JPEG'
options = {'quality': 80}
class IDetail(ImageSpec):
processors = [ResizeToFit(364, 520)]
format = 'JPEG'
options = {'quality': 80}
class IList(ImageSpec):
processors = [ResizeToFit(182, 260)]
format = 'JPEG'
options = {'quality': 80}
class IStamp(ImageSpec):
processors = [ResizeToFit(45, 65)]
format = 'JPEG'
options = {'quality': 80}
class ILarge(ImageSpec):
processors = [ResizeToFit(768, 1024)]
format = 'JPEG'
options = {'quality': 80}
register.generator('base:thumbnail', IThumbnail)
register.generator('base:detail', IDetail)
register.generator('base:list', IList)
register.generator('base:stamp', IStamp)
register.generator('base:large', ILarge)
class NomadPost(Post):
summary = models.TextField()
image = models.ImageField(upload_to="images/posts/%Y/%m/%d", max_length=500, blank=True)
# Imagekit specs
pic = ImageSpecField([Adjust(contrast=1.2, sharpness=1.1), ResizeToFit(720)], source='image', format='PNG', options={'quality': 90})
listed_pic = ImageSpecField([Adjust(contrast=1.2, sharpness=1.1), ResizeToFill(720, 300)], source='image', format='PNG', options={'quality': 90})
def __unicode__(self):
return self.title
def get_absolute_url(self):
# URLconf for non-country blog configurations
category = self.categories.latest('id')
return reverse('post_detail', kwargs={'category_slug': category.slug, 'slug': self.slug})
# This code here to be used along with the {% generateimage %} imagekit template tag
# http://django-imagekit.readthedocs.org/en/latest/#generateimage
# https://github.com/matthewwithanm/django-imagekit/issues/202
class BlogUserAvatarThumbnail(ImageSpec):
processors = [ResizeToFill(80, 80)]
format = 'PNG'
options = {'quality': 90}
register.generator('nomadblog:bloguser', BlogUserAvatarThumbnail)
from django.utils import timezone
from django.utils.encoding import python_2_unicode_compatible
from django.utils.translation import ugettext_lazy as _
from django.db import models
from taggit_autosuggest.managers import TaggableManager
from imagekit import ImageSpec, register
from imagekit.processors import ResizeToFill
class Thumbnail(ImageSpec):
processors = [ResizeToFill(100, 50)]
format = 'JPEG'
options = {'quality': 60}
register.generator('thoughts:thumbnail', Thumbnail)
# Create your models here.
AUTH_USER_MODEL = getattr(settings, 'AUTH_USER_MODEL', 'auth.User')
class bella(models.Model):
content = models.CharField(max_length=1500)
user = models.ForeignKey(User, related_name="user")
creation_date = models.DateTimeField(auto_now=True, blank=True)
tags = TaggableManager()
image = models.ImageField(upload_to='avatars')
likes = models.ManyToManyField(User, related_name='likes')
@property
def total_likes(self):
super().__init__(source)
# The 'Large' size appears to be the original image, so we're not using
# Imagekit to generate these.
#class Large(TwitterSpec):
#pass
#
#register.generator('ditto_twitter:large', Large)
class Medium(TwitterSpec):
width = 1200
height = 1200
register.generator('ditto_twitter:medium', Medium)
class Small(TwitterSpec):
width = 680
height = 680
register.generator('ditto_twitter:small', Small)
class Thumbnail(ImageSpec):
width = 150
height = 150
upscale = True
def __init__(self, source):
class LogoProcessor(ImageSpec):
format = 'JPEG'
options = {'quality': 90}
@property
def processors(self):
logoimage = self.source
image = Image.open(logoimage)
rgb_image = image.convert('RGB')
background_color = rgb_image.getpixel((1, 1))
if background_color == (0, 0, 0):
background_color = (255, 255, 255)
return [ResizeToFit(300, 300, mat_color=(background_color))]
register.generator('logo_processor', LogoProcessor)
class Company(models.Model):
account = models.ForeignKey('accounts.Account', blank=True, null=True)
company_name = models.CharField(max_length=200, default='')
company_slug = models.SlugField(max_length=255, blank=True)
company_url = models.URLField(max_length=200, default='')
company_logo = models.ImageField(upload_to=settings.MEDIA_ROOT, default='')
company_logo_thumb = ImageSpecField(source='company_logo',
id='logo_processor')
company_featured_image = models.ImageField(upload_to=settings.MEDIA_ROOT,
default='',
blank=True)
company_featured_image_thumb = ImageSpecField(
source='company_featured_image',
# cannot save any extracted latitude or longitude coordinates.
# TODO: debug and resolve, or else extract and save coordinates
# another way (such as client side).
print 'processors(): self.source:', self.source
print 'processors(): type(self.source):', type(self.source)
instance, field_name = get_field_info(self.source)
print 'processors() instance:', instance
print 'processors() field_name:', field_name
return [
ExifGpsExtractor(instance),
ResizeToFit(1000, 1000, False),
]
register.generator('plantshare:screenedimage:plantsharegpsimage',
PlantshareGpsImage)
class ScreenedImage(models.Model):
image = ProcessedImageField(upload_to=rename_image_by_type,
storage=upload_storage,
spec_id='plantshare:screenedimage:plantsharegpsimage')
thumb = ImageSpecField(source='image', format='JPEG',
options={'quality': 60},
processors=[ResizeToFit(128, 128, upscale=True)])
# Add another thumbnail, cropped and centered with consistent
# dimensions regardless of portrait or landscape orientation.
thumb_cropped = ImageSpecField(source='image', format='JPEG',
options={'quality': 60},
processors=[SmartResize(183, 149, upscale=True)])
from imagekit import ImageSpec, register
from imagekit.processors import ResizeToFill,ResizeToFit,SmartResize,ResizeToCover,ResizeCanvas
class Thumbnail300(ImageSpec):
processors = [ResizeToFit(300,200)]
format = 'PNG'
options = {'quality': 90}
register.generator('accounts:thumbnail300', Thumbnail300)
class Thumbnail200(ImageSpec):
processors = [ResizeToFit(200, 200),ResizeCanvas(200,200)]
format = 'PNG'
options = {'quality': 90}
register.generator('accounts:thumbnail200', Thumbnail200)
class Thumbnail50(ImageSpec):
processors = [ResizeToFit(50, 40),ResizeCanvas(50,40)]
format = 'PNG'
options = {'quality': 80}
register.generator('accounts:thumbnail50', Thumbnail50)
class Thumbnail80(ImageSpec):
processors = [ResizeToFit(80, 65),ResizeCanvas(80,65)]
format = 'PNG'
options = {'quality': 90}
register.generator('accounts:thumbnail80', Thumbnail80)
from imagekit import ImageSpec, register
from imagekit.processors import ResizeToFill
class ExplicitCrop(object):
def __init__(self, top, right, bottom, left):
self.top = top
self.right = right
self.bottom = bottom
self.left = left
def process(self, img):
(w, h) = img.size
return img.crop((self.left, self.top, w - self.right, h - self.bottom))
class StatementPageHeadshot(ImageSpec):
processors = [ExplicitCrop(10, 10, 68, 10), # should give us 122x152
ResizeToFill(100, 125)]
format = 'JPEG'
options = {'quality': 80}
register.generator('op:statement_headshot', StatementPageHeadshot)
class GiantFillWide(ImageSpec):
"""Giant fill wide."""
processors = [processors.ResizeToFill(1600, 400)]
format = "JPEG"
options = {"quality": 80}
class GiantFitWide(ImageSpec):
"""Giant fill wide."""
processors = [processors.ResizeToFit(1600, 400)]
format = "JPEG"
options = {"quality": 80}
register.generator("header:thumbnail", HeaderThumbnail)
register.generator("iframe:thumbnail", iFrameThumbnail)
register.generator("common:thumbnail", Thumbnail)
register.generator("common:thumbnail_wide", ThumbnailWide)
register.generator("common:thumbnail_big", ThumbnailBig)
register.generator("common:thumbnail_bigger", ThumbnailBigger)
register.generator("common:avatar_thumbnail", AvatarThumbnail)
register.generator("common:medium_fill", MediumFill)
register.generator("common:medium_fill_wide", MediumFillWide)
register.generator("common:medium_fit", MediumFit)
register.generator("common:large", Large)
register.generator("common:giant_fill_wide", GiantFillWide)
register.generator("common:giant_fit_wide", GiantFitWide)
from imagekit import ImageSpec, register
from imagekit.processors import SmartResize
class ListThumbnail(ImageSpec):
# Weird dimensions to match videos in the story list view
processors = [SmartResize(width=236, height=145, upscale=False)]
format = 'PNG'
options = {'quality': 90}
register.generator('howtos:listthumbnail', ListThumbnail)
address1 = models.CharField(max_length=100, blank=True, null=True)
address2 = models.CharField(max_length=100, blank=True, null=True)
city = models.CharField(max_length=40, blank=True, null=True)
state = models.CharField(max_length=20, blank=True, null=True)
zip = models.CharField(max_length=10, blank=True, null=True)
website = models.CharField(max_length=300, blank=True, null=True)
contact_email = models.CharField(max_length=300, blank=True, null=True)
phone_number = models.CharField(max_length=20, blank=True, null=True)
history = HistoricalRecords()
def __str__(self):
return self.description
register.generator('member:image:thumbnail_image', ThumbnailSpec)
register.generator('member:image:profile_image', ProfileSpec)
class Member(models.Model):
user = models.OneToOneField(User)
address1 = models.CharField(verbose_name="Address", max_length=100, blank=True, null=True)
address2 = models.CharField(verbose_name="Address line 2", max_length=100, blank=True, null=True)
city = models.CharField(verbose_name="City", max_length=40, blank=True, null=True)
state = models.CharField(verbose_name="State", max_length=20, blank=True, null=True)
zip = models.CharField(verbose_name="Zip Code", max_length=10, blank=True, null=True)
phone_number = models.CharField(verbose_name="Phone number", max_length=20, blank=True, null=True)
ghin = models.CharField(verbose_name="GHIN", max_length=7, blank=True, null=True)
handicap = models.DecimalField(verbose_name="Handicap index", max_digits=3, decimal_places=1, blank=True, null=True)
handicap_revision_date = models.DateField(verbose_name="Handicap revision date", blank=True, null=True)
birth_date = models.DateField(verbose_name="Birth date", blank=True, null=True)
(ACTIVE, 'Activa'),
(SIGNUP, 'En proceso de acogida'),
(INITIAL_PAYMENT, 'Pendiente de pago inicial'),
(PENDING_PAYMENT, 'Pago de cuota pendiente'),
(CANCELED, 'Anulada por impago'),
(OPTED_OUT, 'Baja'),
)
class MaxResize(ImageSpec):
processors = [ResizeToFit(1024, 1024)]
format = 'JPEG'
options = {'quality': 80}
register.generator('mes:profile:max_resize', MaxResize)
class AccountsManager(PolymorphicManager):
def active(self):
qs = self.get_queryset()
return qs.filter( Q(status=ACTIVE) | Q(status=INITIAL_PAYMENT) | Q(status=PENDING_PAYMENT) )
class Account(PolymorphicModel):
status = models.CharField(null=False, default=ACTIVE, max_length=20, choices=ACCOUNT_STATUSES, verbose_name=_('Estado'))
cif = models.CharField(max_length=30, null=False, blank=False, verbose_name=_('NIF/CIF'), unique=True)
legal_form = models.ForeignKey(LegalForm, null=True, verbose_name=_('Forma legal'), on_delete=models.SET_NULL)
format = 'JPEG'
options = {'quality': 60}
@property
def processors(self):
model, field_name = get_field_info(self.source)
min_dim = min(model.image_file.width, model.image_file.height)
return [
Crop(width=min_dim,
height=min_dim,
x=int(-1 * model.image_x * model.image_file.width),
y=int(-1 * model.image_y * model.image_file.height))
]
register.generator('profile_image', Profile_Image)
class Header_Image(ImageSpec):
format = 'JPEG'
options = {'quality': 60}
@property
def processors(self):
model, field_name = get_field_info(self.source)
crop_width = int(model.original.width)
crop_height = min(model.original.height, int(crop_width * 3.0 / 5.0))
return [SmartCrop(width=crop_width, height=crop_height)]
register.generator('header_image', Header_Image)
def __init__(self, source, specs):
super(InstanceFormatSpec, self).__init__(source, specs)
self.update_format()
#HACK TO UPDATE FORMAT BASED ON MODEL VALUE
def get_format(self):
if hasattr(self, 'instance') and hasattr(self, 'format_field'):
return getattr(self.instance, self.format_field)
return self.format
def update_format(self):
self.format = self.get_format()
def generate(self):
self.update_format()
return super(InstanceFormatSpec, self).generate()
def get_hash(self):
self.update_format()
return super(InstanceFormatSpec, self).get_hash()
register.generator('imagekit_cropper:instance_spec', InstanceSpec)
register.generator('imagekit_cropper:instance_format_spec', InstanceFormatSpec)
image_sizes['xlarge'],
image_sizes['xlarge'],
anchor=processors.Anchor.TOP)
])
original_cropped = ImageSpecField(
source='image',
id='books:book:squared_original')
class SquaredOriginal(ImageSpec):
@property
def processors(self):
model, field_name = get_field_info(self.source)
return [processors.Crop(model.width, model.width, anchor=processors.Anchor.TOP)]
register.generator('books:book:squared_original', SquaredOriginal)
class ReadingOrder(models.Model):
name = models.TextField()
source = models.URLField(
max_length=1024,
blank=True)
books = models.ManyToManyField(
to='Book',
related_name='reading_orders',
through='ReadingOrderBook')
def __str__(self):
return self.name
import os
from pilkit.lib import Image, ImageDraw
from imagekit import ImageSpec, register
from imagekit.processors import ResizeToFill, ResizeToFit, SmartResize
from storages.backends.s3boto3 import S3Boto3Storage
from tempfile import SpooledTemporaryFile
class UserAccountAvatar(ImageSpec):
processors = [
ResizeToFill(208, 208),
]
register.generator('user-account-avatar', UserAccountAvatar)
# coding=utf-8
from django.db import models
from imagekit import register
from imagekit.models import ImageSpecField
from imagekit.processors import ResizeToFit
from .generateimages import ThumbnailSpec, WatermarkSpec
register.generator('web:portfolioimage:thumbnail_image', ThumbnailSpec)
register.generator('web:portfolioimage:watermark_image', WatermarkSpec)
class Message(models.Model):
from_name = models.CharField(verbose_name="Full Name", max_length=100)
from_phone = models.CharField(verbose_name="Phone Number", max_length=20, blank=True)
from_email = models.EmailField(verbose_name="Email Address")
message_text = models.TextField(verbose_name="Message")
message_date = models.DateTimeField(verbose_name="Message date", auto_now=True)
class SiteSetting(models.Model):
home_page_image = models.ImageField(verbose_name="Home page main image")
facebook_address = models.CharField(verbose_name="Facebook url", max_length=200, blank=True)
linkedin_address = models.CharField(verbose_name="LinkedIn url", max_length=200, blank=True)
dribble_address = models.CharField(verbose_name="Dribble url", max_length=200, blank=True)
about_page_image = models.ImageField(verbose_name="About page main image")
about_page_image2 = models.ImageField(verbose_name="About page secondary image", blank=True)
about_page_text = models.TextField(verbose_name="About page main text")
about_page_services = models.TextField(verbose_name="About page service text", blank=True)
about_page_title = models.CharField(verbose_name="About page title", max_length=40)
about_page_subtitle = models.CharField(verbose_name="About page sub-title", max_length=100, blank=True)
contact_page_image = models.ImageField(verbose_name="Contact page main image")
from django.template.defaultfilters import slugify
from smart_selects.db_fields import GroupedForeignKey, ChainedForeignKey
from imagekit import ImageSpec, register
from imagekit.models import ImageSpecField
from imagekit.processors import ResizeToFill
from property.models import Type, Borough, Neighborhood, Category, Status, Room
"""
Property thumbnail
"""
class Thumbnail(ImageSpec):
processors = [ResizeToFill(300, 150)]
format = 'JPEG'
options = {'quality': 60}
register.generator('dashboard:thumbnail', Thumbnail)
class ImageWithThumbnail(models.Model):
name = models.CharField(max_length = 255)
image = models.ImageField(upload_to='images/',max_length=500,blank=True,null=True)
thumbnail = models.ImageField(upload_to='iamges/',max_length=500,blank=True,null=True)
def create_thumbnail(self):
# original code for this method came from
# http://snipt.net/danfreak/generate-thumbnails-in-django-with-pil/
# If there is no image associated with this.
# do not create thumbnail
if not self.image:
return
from imagekit import ImageSpec, register
from imagekit.processors import ResizeToFill, SmartResize
class Landscape(ImageSpec):
processors = [SmartResize(1200, 700)]
format = 'JPEG'
options = {'quality': 80}
class Portrait(ImageSpec):
processors = [SmartResize(500, 700)]
format = 'JPEG'
options = {'quality': 80}
class Thumbnail(ImageSpec):
processors = [ResizeToFill(100, 50)]
format = 'JPEG'
options = {'quality': 60}
register.generator('portfolio:landscape', Landscape)
register.generator('portfolio:portrait', Portrait)
register.generator('portfolio:thumbnail', Thumbnail)
class ProductSmallThumbnailSpec(ImageSpec):
processors = [ResizeToFill(120, 80)]
format = 'JPEG'
options = {'quality': 60}
class ProductMediumThumbnailSpec(ImageSpec):
processors = [ResizeToFill(300, 200)]
format = 'JPEG'
options = {'quality': 60}
class ProductBigThumbnailSpec(ImageSpec):
processors = [ResizeToFill(450, 300)]
format = 'JPEG'
options = {'quality': 80}
class AdminThumbnailSpec(ImageSpec):
processors = [ResizeToFill(90, 60)]
format = 'JPEG'
options = {'quality': 60}
register.generator('products:product_big_thumbnail', ProductBigThumbnailSpec)
register.generator('products:product_medium_thumbnail',
ProductMediumThumbnailSpec)
register.generator('products:product_small_thumbnail',
ProductSmallThumbnailSpec)
from imagekit.processors import SmartResize
class ThumbnailLarge(ImageSpec):
processors = [SmartResize(900, 600)]
format = 'JPEG'
options = {'quality': 85}
class ThumbnailMedium(ImageSpec):
processors = [SmartResize(600, 400)]
format = 'JPEG'
options = {'quality': 85}
class ThumbnailSmall(ImageSpec):
processors = [SmartResize(200, 133)]
format = 'JPEG'
options = {'quality': 70}
class ThumbnailNoPre(ImageSpec):
format = 'JPEG'
options = {'quality': 85}
register.generator('cookbox_webui:thumbnail_large', ThumbnailLarge)
register.generator('cookbox_webui:thumbnail_medium', ThumbnailMedium)
register.generator('cookbox_webui:thumbnail_small', ThumbnailSmall)
register.generator('cookbox_webui:thumbnail_no_pre', ThumbnailNoPre)
Q(redditorflairs__ended__isnull=True) | Q(redditorflairs__ended__lt=timezone.now()-timedelta(days=7)),
redditorflairs__started__lt=timezone.now() - timedelta(days=5),
),
then=1
),
default=0,
output_field=models.IntegerField()
)
)
class Thumbnail(ImageSpec):
processors = [ResizeToFill(38, 38)]
format = 'PNG'
options = {'quality': 90}
register.generator('core:logo', Thumbnail)
@cache_page(60 * 60)
def all_top100_stats(request):
alliances = Alliance.objects.filter(
active=True
).annotate(
flair_count=redditorflair_filter,
flair_lastweek=redditorflair_lastweek
).order_by(
'-flair_count',
'name'
)
corps = Corp.objects.filter(
active=True
grad_data = Person.objects.filter(member_type=2).order_by('sortorder')
under_data = Person.objects.filter(member_type=3).order_by('sortorder')
collab_data = Person.objects.filter(member_type=4).order_by('sortorder')
alumni_data = Person.objects.filter(member_type=5).order_by('sortorder')
postdoc_alumni_data = Person.objects.filter(member_type=6).order_by('sortorder')
undergrad_alumni_data = Person.objects.filter(member_type=7).order_by('sortorder')
graduate_alumni_data = Person.objects.filter(member_type=8).order_by('sortorder')
return render_to_response('people/list.html', {'faculty_data': faculty_data,'postdoc_data': postdoc_data,
'grad_data': grad_data,'under_data': under_data,'collab_data': collab_data,
'alumni_data': alumni_data, 'postdoc_alumni_data': postdoc_alumni_data, 'undergrad_alumni_data': undergrad_alumni_data,
'graduate_alumni_data': graduate_alumni_data }, context_instance=RequestContext(request))
def person_detail(request, person):
person_data = Person.objects.get(id=person)
return render_to_response('people/detail.html', {'person_data': person_data}, context_instance=RequestContext(request))
from imagekit import ImageSpec, register
from imagekit.processors import ResizeToFill
class PeopleThumbnail(ImageSpec):
processors = [ResizeToFill(100, 50)]
format = 'JPEG'
options = {'quality': 60}
register.generator('people:thumbnail', PeopleThumbnail)
@property
def processors(self):
model, field_name = get_field_info(self.source)
min_dim = min(model.image_file.width, model.image_file.height)
return [
Crop(
width=min_dim,
height=min_dim,
x=int(-1 * model.image_x * model.image_file.width),
y=int(-1 * model.image_y * model.image_file.height),
)
]
register.generator("profile_image", Profile_Image)
class Header_Image(ImageSpec):
format = "JPEG"
options = {"quality": 60}
@property
def processors(self):
model, field_name = get_field_info(self.source)
crop_width = int(model.original.width)
crop_height = min(model.original.height, int(crop_width * 3.0 / 5.0))
return [SmartCrop(width=crop_width, height=crop_height)]
register.generator("header_image", Header_Image)
from imagekit import ImageSpec, register
from imagekit.processors import ResizeToFill
class Thumbnail(ImageSpec):
processors = [ResizeToFill(60, 80)]
# print('OKOKOKOKOKOKOK')
register.generator('user_profile:thumbnail', Thumbnail)
from imagekit import ImageSpec, register
from imagekit.processors import ResizeToFit
'''
We are generating different image sizes for use across
our website. We stick to these image sizes to improve performance.
To call an image within a template, use the following code:
% generateimage 'vetcove:mediumthumbnail' source=image -- alt="alt text" class="class names" %
'''
class SmallThumbnail(ImageSpec):
processors = [ResizeToFit(50, 50)]
format = 'PNG'
register.generator('vetcove:smallthumbnail', SmallThumbnail)
class MediumThumbnail(ImageSpec):
processors = [ResizeToFit(100, 100)]
format = 'PNG'
register.generator('vetcove:mediumthumbnail', MediumThumbnail)
class LargeThumbnail(ImageSpec):
processors = [ResizeToFit(200, 200)]
format = 'PNG'
register.generator('vetcove:largethumbnail', LargeThumbnail)
class SmallImage(ImageSpec):
processors = [ResizeToFit(300, 300)]
format = 'PNG'
("CA", "Cash"),
)
def photo_directory_path(instance, filename):
# file will be uploaded to MEDIA_ROOT/documents/year/<filename>
return "photos/course-logos/{0}".format(filename)
class WebSpec(ImageSpec):
format = 'JPEG'
options = {'quality': 80}
processors = [ResizeToFit(192, 192)]
register.generator("clubs:golf_course:web_logo", WebSpec)
class GolfCourse(models.Model):
class Meta:
ordering = [
"name",
]
name = models.CharField(verbose_name="Golf Course Name", max_length=200)
address_txt = models.CharField(verbose_name="Street Address",
max_length=200,
blank=True)
city = models.CharField(verbose_name="City", max_length=40, blank=True)
state = models.CharField(verbose_name="State",
max_length=2,
"""
Saves and then checks for the resized versions and runs
imagekit's generate on them if they do not exist. This is done
rather than using ProcessedImageField for the sake of cleaner
migrations which do not rely on imagekit being installed by referencing ProcessedImageField.
Django 1.7 migrations may work more cleanly with ProcessedImageField
:param generate_images: Automatically generate the resized images on save if True. This can be problematic
with the async backend and atomic transactions
:type generate_images: bool
"""
super(SightingImage, self).save(*args, **kwargs)
if generate_images:
self.generate_images()
# stuff that isn't really models, but works with models and needs to reference them
# and causes django 1.8+ to complain if it is loaded by __init__ because the models
# have not yet been loaded and so app_label cannot be determined
def cleanup_sightingimage(sender, instance, **kwargs):
instance.thumbnail.delete(save=False)
instance.small.delete(save=False)
instance.medium.delete(save=False)
instance.original.delete(save=False)
post_delete.connect(cleanup_sightingimage, sender=SightingImage, dispatch_uid='cleanup_sightingimage_post_delete')
register.generator('sighting:thumbnail', SightingImageThumbnail)
register.generator('sighting:small', SightingImageSmall)
register.generator('sighting:medium', SightingImageMedium)
format = 'JPEG'
options = {'quality': 75}
class Watermarki(ImageSpec):
processors = [WatermarkProcessor()]
format = 'JPEG'
options = {'quality': 75}
class HiddenWatermark(ImageSpec):
processors = [HiddenWatermarkProcessor()]
format = 'PNG'
register.generator('items:text-overlay', TextOverlay)
#register.generator('items:watermark', Watermark)
register.generator('items:hidden-watermark', HiddenWatermark)
class Watermark():
def __init__(self, text):
self.text = text
def process(self, image):
#text = "DEI X"
font = ImageFont.truetype(settings.DEFAULT_FONT, 350)
rgba_image = image.convert('RGBA')
text_overlay = Image.new('RGBA', rgba_image.size, (255, 255, 255, 0))
image_draw = ImageDraw.Draw(text_overlay)
text_size_x, text_size_y = image_draw.textsize(self.text, font=font)
from imagekit import ImageSpec, register
from imagekit.processors import ResizeToFill, Adjust
class Suggestion_thumb(ImageSpec):
processors = [ResizeToFill(256, 256),Adjust(brightness = 0.5, contrast = 0.9)]
format = 'JPEG'
options = {'quality': 80}
register.generator('library:suggestion_thumb', Suggestion_thumb)
from imagekit import ImageSpec, register
from imagekit.processors import ResizeToFill
class Thumbnail(ImageSpec):
processors = [ResizeToFill(600, 315)]
format = 'JPEG'
options = {'quality': 60}
register.generator('project:app:thumbnail', Thumbnail)
sp_choice = (('Y', 'YES'), ('N', 'NO'))
le_choice = (
('PART1', 'LANGUAGE PART-I'),
('PART2', 'LANGUAGE PART-II'),
)
class Thumbnail(ImageSpec):
processors = [ResizeToFill(150, 150)]
format = 'JPEG'
options = {'quality': 60}
register.generator('students:thumbnail', Thumbnail)
class Child_detail(caching.base.CachingMixin, models.Model):
def save(self):
if not self.unique_id_no:
self.unique_id_no = (self.school.school_code *
100000) + (self.school.student_id_count + 1)
super(Child_detail, self).save()
def validate_image(fieldfile_obj):
filesize = fieldfile_obj.file.size
kb_limit = 50
Kilobyte_limit = 1024 * 50
if filesize > Kilobyte_limit:
from imagekit import ImageSpec, register
from imagekit.processors import ResizeToFit
'''
We are generating different image sizes for use across
our website. We stick to these image sizes to improve performance.
To call an image within a template, use the following code:
% generateimage 'vetcove:mediumthumbnail' source=image -- alt="alt text" class="class names" %
'''
class SmallThumbnail(ImageSpec):
processors = [ResizeToFit(50, 50)]
format = 'PNG'
register.generator('vetcove:smallthumbnail', SmallThumbnail)
class MediumThumbnail(ImageSpec):
processors = [ResizeToFit(100, 100)]
format = 'PNG'
register.generator('vetcove:mediumthumbnail', MediumThumbnail)
class LargeThumbnail(ImageSpec):
processors = [ResizeToFit(200, 200)]
format = 'PNG'
from imagekit import ImageSpec, register
from imagekit.processors import SmartResize
class DetailPageThumbnail(ImageSpec):
processors = [SmartResize(100, 100)]
format = 'PNG'
options = {'quality': 80}
register.generator('lots:detail_page_thumbnail', DetailPageThumbnail)
options = {'quality' : 80}
cachefile_strategy = strategies.Optimistic
# put thumbnails into the "photos/thumbs" folder and
# name them the same as the source file
@property
def cachefile_name (self) :
source_filename = getattr(self.source, 'name', None) # type: str
if source_filename == "": return ""
s = "photos/thumbs/" + source_filename.split('photos/original/')[1]
return s
register.generator('enhueco:thumbnail', ThumbnailSpec)
class UserManager(models.Manager):
def create_user(self, login, first_names, last_names):
user = self.create(login=login, firstNames = first_names, lastNames = last_names)
user.save()
ImmediateEvent.objects.create(user=user)
return user
def create_user_and_token(self, login, first_names, last_names):
user = self.create_user(login,first_names, last_names)
token = Tokenizer.assignToken(user)
return (user,token)
class MobileSpec(ImageSpec):
format = 'JPEG'
options = {'quality': 80}
processors = [Transpose(Transpose.AUTO), ResizeToFit(900, 900)]
class WebSpec(ImageSpec):
format = 'JPEG'
options = {'quality': 90}
processors = [
Transpose(Transpose.AUTO),
ResizeToFit(1600, 1600, upscale=False)
]
register.generator("documents:photo:mobile_image", MobileSpec)
register.generator("documents:photo:web_image", WebSpec)
class Document(models.Model):
document_type = models.CharField(verbose_name="Type",
choices=DOCUMENT_TYPE_CHOICES,
max_length=1,
default="R")
year = models.IntegerField(verbose_name="Golf Season",
blank=True,
null=True)
title = models.CharField(verbose_name="Title", max_length=120)
event = models.ForeignKey(verbose_name="Event",
to=Event,
null=True,
import os
from uuid import uuid4
import exifread as ef
from django.conf import settings
from django.db import models
from django.dispatch import receiver
from django.utils import timezone
from imagekit import register
from imagekit.models.fields import ImageSpecField
from . import processors
register.generator('hh:photo:img_large', processors.LargeOrientedImage)
register.generator('hh:photo:img_medium', processors.MediumOrientedImage)
register.generator('hh:photo:img_small', processors.SmallOrientedImage)
def path_and_rename(instance, filename):
path = 'photos'
ext = filename.split('.')[-1]
if instance.year is not None:
year = instance.year
else:
if instance.decade is not None:
year = str(instance.decade) + 's'
else:
year = '0000'
filename = '{}_{}_{}.{}'.format('pic', year, uuid4().hex[:16], ext)
