def main(self, model: db.Base, item_id: int,
image_size: enums.ImageSize) -> db.Profile:
self.model = model
if image_size == enums.ImageSize.Original:
image_size = utils.ImageSize(0, 0)
else:
image_size = utils.ImageSize(
*constants.image_sizes[image_size.name.lower()])
with self.models.call() as plg:
for p in plg.all(default=True):
self._supported_models.update(p)
if self.model not in self._supported_models:
raise exceptions.CommandError(
utils.this_command(self),
"Model '{}' is not supported".format(model))
img_hash = io_cmd.ImageItem.gen_hash(model, image_size, item_id)
generate = True
sess = constants.db_session()
profile_size = str(tuple(image_size))
self.cover = sess.query(db.Profile).filter(
db.and_op(db.Profile.data == img_hash,
db.Profile.size == profile_size)).first()
old_img_hash = None
if self.cover:
if io_cmd.CoreFS(self.cover.path).exists:
generate = False
else:
old_img_hash = self.cover.data
self.next_progress()
if not generate:
model_name = db.model_name(model)
with self.invalidate.call_capture(model_name, model_name, item_id,
image_size) as plg:
if plg.first_or_default():
generate = True
self.next_progress()
if generate:
constants.task_command.thumbnail_cleaner.wake_up()
self.cover = self.run_native(self._generate_and_add, img_hash,
old_img_hash, generate, model,
item_id, image_size,
profile_size).get()
self.cover_event.emit(self.cover)
return self.cover
def main(self, model: db.Base, item_id: int,
image_size: enums.ImageSize) -> db.Profile:
self.model = model
if image_size == enums.ImageSize.Original:
image_size = utils.ImageSize(0, 0)
else:
image_size = utils.ImageSize(
*constants.image_sizes[image_size.name.lower()])
with self.models.call() as plg:
for p in plg.all(default=True):
self._supported_models.update(p)
if self.model not in self._supported_models:
raise exceptions.CommandError(
utils.this_command(self),
"Model '{}' is not supported".format(model))
img_hash = io_cmd.ImageItem.gen_hash(model, image_size, item_id)
generate = True
sess = constants.db_session()
self.cover = sess.query(
db.Profile).filter(db.Profile.data == img_hash).one_or_none()
if self.cover:
if io_cmd.CoreFS(self.cover.path).exists:
generate = False
else:
self.cover = db.Profile()
if generate:
model_name = db.model_name(model)
with self.generate.call_capture(model_name, model_name, item_id,
image_size) as plg:
self.cover.path = plg.first()
self.cover.data = img_hash
self.cover.size = str(tuple(image_size))
if self.cover.path and generate:
i = GetModelItemByID().run(model, {item_id})[0]
i.profiles.append(self.cover)
sess.commit()
elif not self.cover.path:
self.cover = None
self.cover_event.emit(self.cover)
return self.cover
def main(self, model: db.Base, item_id: int,
image_size: enums.ImageSize) -> db.Profile:
self.model = model
if image_size == enums.ImageSize.Original:
image_size = utils.ImageSize(0, 0)
else:
image_size = utils.ImageSize(
*constants.image_sizes[image_size.name.lower()])
with self.models.call() as plg:
for p in plg.all(default=True):
self._supported_models.update(p)
if self.model not in self._supported_models:
raise exceptions.CommandError(
utils.this_command(self),
"Model '{}' is not supported".format(model))
img_hash = io_cmd.ImageItem.gen_hash(model, image_size, item_id)
cover_path = ""
generate = True
sess = constants.db_session()
self.cover = sess.query(
db.Profile).filter(db.Profile.data == img_hash).one_or_none()
if self.cover:
if io_cmd.CoreFS(self.cover.path).exists:
generate = False
else:
cover_path = self.cover.path
if generate:
self.cover = self.run_native(self._generate_and_add, img_hash,
generate, cover_path, model, item_id,
image_size).get()
self.cover_event.emit(self.cover)
return self.cover
from rarfile import RarFile
from collections import namedtuple
from contextlib import contextmanager
from gevent import fileobject
from happypanda.common import hlogger, exceptions, utils, constants
from happypanda.core.command import CoreCommand, CommandEntry, AsyncCommand
from happypanda.core.services import ImageService
from happypanda.core import db
log = hlogger.Logger(__name__)
ImageProperties = namedtuple(
"ImageProperties",
['size', 'radius', 'output_dir', 'output_path', 'name', 'create_symlink'])
ImageProperties.__new__.__defaults__ = (utils.ImageSize(
*constants.image_sizes['medium']), 0, None, None, None, True)
class ImageItem(AsyncCommand):
"""
Returns:
a path to generated image
"""
def __init__(self, service, filepath_or_bytes, properties):
assert isinstance(service, ImageService) or service is None
assert isinstance(properties, ImageProperties)
super().__init__(service, priority=constants.Priority.Low)
self.properties = properties
self._image = filepath_or_bytes