252 lines
6.6 KiB
Python
252 lines
6.6 KiB
Python
import logging
|
|
import os
|
|
import tempfile
|
|
import asyncio
|
|
|
|
from typing import Optional, List
|
|
|
|
import settings
|
|
from db import collection
|
|
from sync.data import request, list_images
|
|
from sync.models import Model
|
|
from utils.hash import md5, hash_str
|
|
from utils.image import image_magick_resize
|
|
from utils.text.transform import url_encode_text
|
|
|
|
logger = logging.getLogger(settings.name + '.Image')
|
|
|
|
store = collection(settings.collection_images)
|
|
|
|
|
|
def get_upload_url(url):
|
|
return os.path.join(settings.image_url_upload, os.path.basename(url))
|
|
|
|
|
|
def default_url_factory(file, size, ext):
|
|
url = settings.image_url_base + '{}-{}{}'
|
|
return url.format(md5(file), size, ext.lower())
|
|
|
|
|
|
class Image(Model):
|
|
@staticmethod
|
|
async def find_one(query):
|
|
document = store.find_one(query)
|
|
return document
|
|
|
|
@staticmethod
|
|
async def find(query):
|
|
return store.find(query)
|
|
|
|
@staticmethod
|
|
async def delete(query):
|
|
return store.find_one_and_delete(query)
|
|
|
|
@staticmethod
|
|
async def new(provider, file, sizes, url_factory=None):
|
|
url_factory = url_factory if url_factory else default_url_factory
|
|
|
|
img = Image(provider, file, data=None, url_factory=url_factory)
|
|
changed = await img.is_changed()
|
|
if changed:
|
|
await img.build(sizes=sizes)
|
|
await img.upload()
|
|
await img.save()
|
|
else:
|
|
doc = await Image.find_one({'file': file})
|
|
img = Image(provider, file, doc['data'], url_factory)
|
|
img.ref = doc['_id']
|
|
|
|
return img
|
|
|
|
@staticmethod
|
|
async def scan(provider):
|
|
scan_path = settings.dir_images
|
|
documents = list_images(provider, scan_path)
|
|
|
|
return [Image.read_path(provider, i) for i in documents]
|
|
|
|
@staticmethod
|
|
def read_path(provider, path):
|
|
return Image(
|
|
provider,
|
|
path,
|
|
data=None,
|
|
url_factory=default_url_factory
|
|
)
|
|
|
|
def __init__(self, provider, file, data, url_factory):
|
|
self.__hash_salt = settings.hash_salt_images
|
|
|
|
self.origin = None
|
|
|
|
self.data = data
|
|
self.url_factory = url_factory
|
|
|
|
super().__init__(provider, store, file)
|
|
|
|
def init(self):
|
|
self.id = self.__get_id()
|
|
self.hash = self.__get_hash()
|
|
|
|
self.origin = f"{settings.origin}:{os.path.dirname(self.file)}"
|
|
|
|
async def is_changed(self):
|
|
i = await Image.find_one({'file': self.file})
|
|
return self._is_changed_hash(i)
|
|
|
|
async def build(self, sizes):
|
|
logger.info(f'Building Image {self._get_abs(self.file)}')
|
|
|
|
img_in = self._get_image_file()
|
|
img_out = tempfile.mkdtemp()
|
|
|
|
images = await create_image(img_in, sizes, self.url_factory, img_out)
|
|
if not images:
|
|
raise Exception('Failed to create Image {}'.format(img_in))
|
|
data = {}
|
|
for i in images:
|
|
if i:
|
|
size_name = i['size']
|
|
data[size_name] = {
|
|
**i,
|
|
}
|
|
self.data = data
|
|
|
|
async def upload(self):
|
|
if self.data:
|
|
async def fn(i):
|
|
url = get_upload_url(i['url'])
|
|
file = i['file']
|
|
|
|
logger.info('Uploading to {}'.format(url))
|
|
await request.upload(url, file)
|
|
|
|
await asyncio.wait([fn(i) for i in self.data.values()])
|
|
|
|
async def save(self):
|
|
c = sync_image(self.bake())
|
|
self.ref = c['_id']
|
|
|
|
def bake(self):
|
|
return {
|
|
'id': self.id,
|
|
'file': self.file,
|
|
'origin': self.origin,
|
|
'hash': self.hash,
|
|
'data': self.data,
|
|
}
|
|
|
|
def get_size(self, size):
|
|
if size in self.data:
|
|
return self.data[size]
|
|
return None
|
|
|
|
def _get_image_file(self):
|
|
return self._get_abs(self.file)
|
|
|
|
def __filename(self):
|
|
return os.path.basename(self.file)
|
|
|
|
def __get_id(self):
|
|
return md5(self.file)
|
|
|
|
def __get_hash(self):
|
|
file_hash = self.provider.hash(self.file)
|
|
return hash_str(self.__hash_salt + file_hash)
|
|
|
|
def __str__(self):
|
|
return '<Image hash={} file={}>'.format(self.hash, self.file)
|
|
|
|
|
|
def sync_image(record):
|
|
from db import db
|
|
|
|
q = {'hash': record['hash']}
|
|
try:
|
|
db().images.update_one(q, {'$set': record}, upsert=True)
|
|
i = db().images.find_one({'hash': record['hash']})
|
|
return i
|
|
except ValueError:
|
|
pass
|
|
|
|
return None
|
|
|
|
|
|
async def create_image(file: str, sizes: [()], url_fn, output_dir: str) -> Optional[List[dict]]:
|
|
"""
|
|
|
|
:param file: Image path to process
|
|
:param sizes: list of sizes to generate image (<size_name>, <width>, <height>)
|
|
:param url_fn: function (size_name, ext) for creating image url
|
|
:param output_dir: path to local folder for thumbs storing
|
|
:return:
|
|
"""
|
|
if not os.path.exists(file):
|
|
return None
|
|
|
|
_, ext = os.path.splitext(file)
|
|
images = []
|
|
|
|
async def fn(size):
|
|
size_name, width, height = size
|
|
|
|
image_url = url_fn(file, size_name, ext)
|
|
image_filename = os.path.basename(image_url)
|
|
local_image_path = os.path.join(output_dir, image_filename)
|
|
|
|
# if settings.image_processing_enabled:
|
|
image = await process_image(file, local_image_path, size)
|
|
if not image:
|
|
logger.warning('Failed to process image {}'.format(file))
|
|
return None
|
|
width, height = image.size
|
|
|
|
images.append({
|
|
'file': local_image_path,
|
|
'url': image_url,
|
|
'size': size_name,
|
|
'width': width,
|
|
'height': height
|
|
})
|
|
|
|
await asyncio.wait([fn(s) for s in sizes])
|
|
|
|
return images
|
|
|
|
|
|
async def process_image(input_file, output_file, size):
|
|
size_name, width, height = size
|
|
|
|
if size_name == 'original':
|
|
return await optimize(input_file, output_file, quality=90)
|
|
else:
|
|
image = await read_image(input_file)
|
|
if not image:
|
|
return None
|
|
image_width, image_height = image.size
|
|
if image_height > image_width:
|
|
width, height = height, width
|
|
return await thumbnail(input_file, output_file, (width, height), quality=90)
|
|
|
|
|
|
async def read_image(src):
|
|
import aiofiles
|
|
from PIL import Image
|
|
import io
|
|
|
|
async with aiofiles.open(src, mode='rb') as f:
|
|
image_data = await f.read()
|
|
image = Image.open(io.BytesIO(image_data))
|
|
return image
|
|
|
|
|
|
async def thumbnail(src, dest, size, quality):
|
|
await image_magick_resize(src, dest, size, quality)
|
|
return await read_image(dest)
|
|
|
|
|
|
async def optimize(src, dest, quality):
|
|
image = await read_image(src)
|
|
image.save(dest, quality=quality)
|
|
return image
|