FROM python:3.7

COPY requirements.txt ./

RUN pip install -r requirements.txt

RUN set -ex; \

apt-get -y update; \

apt-get -y install imagemagick; \

rm -rf /var/lib/apt/lists/*

ENV APP_HOME /app

WORKDIR $APP_HOME

COPY . ./

CMD exec gunicorn --bind :$PORT --workers 1 --threads 8 main:app

This sample service applies [Cloud Storage](https://cloud.google.com/storage/docs)-triggered image processing with [Cloud Vision API](https://cloud.google.com/vision/docs) analysis and ImageMagick transformation.

Use it with the [Image Processing with Cloud Run tutorial](http://cloud.google.com/run/docs/tutorials/image-processing).

[![Run in Google Cloud][run_img]][run_link]

[run_img]: https://storage.googleapis.com/cloudrun/button.svg

[run_link]: https://deploy.cloud.run/?git_repo=https://github.com/GoogleCloudPlatform/python-docs-samples&dir=run/image-processing

_Note: you may need to install `pytest` using `pip install pytest`._

Cloud Run services can be [configured with Environment Variables](https://cloud.google.com/run/docs/configuring/environment-variables).

Required variables for this sample include:

* `INPUT_BUCKET_NAME`: The Cloud Run service will be notified of images uploaded to this Cloud Storage bucket. The service will then retreive and process the image.

* `BLURRED_BUCKET_NAME`: The Cloud Run service will write blurred images to this Cloud Storage bucket.

* The `image.py` file is copied from the [Cloud Functions ImageMagick sample `main.py`](../../functions/imagemagick/main.py). Region tags are changed.

* The requirements.txt dependencies used in the copied code should track the [Cloud Functions ImageMagick `requirements.txt`](../../functions/imagemagick/requirements.txt)

import os

import tempfile

from google.cloud import storage, vision

from wand.image import Image

storage_client = storage.Client()

vision_client = vision.ImageAnnotatorClient()

def blur_offensive_images(data):

file_data = data

file_name = file_data['name']

bucket_name = file_data['bucket']

blob = storage_client.bucket(bucket_name).get_blob(file_name)

blob_uri = f'gs://{bucket_name}/{file_name}'

blob_source = {'source': {'image_uri': blob_uri}}

# Ignore already-blurred files

if file_name.startswith('blurred-'):

print(f'The image {file_name} is already blurred.')

return

print(f'Analyzing {file_name}.')

result = vision_client.safe_search_detection(blob_source)

detected = result.safe_search_annotation

# Process image

if detected.adult == 5 or detected.violence == 5:

print(f'The image {file_name} was detected as inappropriate.')

return __blur_image(blob)

else:

print(f'The image {file_name} was detected as OK.')

def __blur_image(current_blob):

file_name = current_blob.name

_, temp_local_filename = tempfile.mkstemp()

# Download file from bucket.

current_blob.download_to_filename(temp_local_filename)

print(f'Image {file_name} was downloaded to {temp_local_filename}.')

# Blur the image using ImageMagick.

with Image(filename=temp_local_filename) as image:

image.resize(*image.size, blur=16, filter='hamming')

image.save(filename=temp_local_filename)

print(f'Image {file_name} was blurred.')

# Upload result to a second bucket, to avoid re-triggering the function.

# You could instead re-upload it to the same bucket + tell your function

# to ignore files marked as blurred (e.g. those with a "blurred" prefix)

blur_bucket_name = os.getenv('BLURRED_BUCKET_NAME')

blur_bucket = storage_client.bucket(blur_bucket_name)

new_blob = blur_bucket.blob(file_name)

new_blob.upload_from_filename(temp_local_filename)

print(f'Blurred image uploaded to: gs://{blur_bucket_name}/{file_name}')

# Delete the temporary file.

os.remove(temp_local_filename)

from collections import UserDict

import uuid

from mock import MagicMock, patch

import image

def test_process_offensive_image(

storage_client,

vision_client,

__blur_image,

capsys):

result = UserDict()

result.safe_search_annotation = UserDict()

result.safe_search_annotation.adult = 5

result.safe_search_annotation.violence = 5

vision_client.safe_search_detection = MagicMock(return_value=result)

filename = str(uuid.uuid4())

data = {

'bucket': 'my-bucket',

'name': filename

}

image.blur_offensive_images(data)

out, _ = capsys.readouterr()

assert 'Analyzing %s.' % filename in out

assert 'The image %s was detected as inappropriate.' % filename in out

assert image.__blur_image.called

def test_process_safe_image(

storage_client,

vision_client,

__blur_image,

capsys):

result = UserDict()

result.safe_search_annotation = UserDict()

result.safe_search_annotation.adult = 1

result.safe_search_annotation.violence = 1

vision_client.safe_search_detection = MagicMock(return_value=result)

filename = str(uuid.uuid4())

data = {

'bucket': 'my-bucket',

'name': filename

}

image.blur_offensive_images(data)

out, _ = capsys.readouterr()

assert 'Analyzing %s.' % filename in out

assert 'The image %s was detected as OK.' % filename in out

assert __blur_image.called is False

def test_blur_image(storage_client, image_mock, os_mock, capsys):

filename = str(uuid.uuid4())

blur_bucket = 'blurred-bucket-' + str(uuid.uuid4())

os_mock.remove = MagicMock()

os_mock.path = MagicMock()

os_mock.path.basename = MagicMock(side_effect=(lambda x: x))

os_mock.getenv = MagicMock(return_value=blur_bucket)

image_mock.return_value = image_mock

image_mock.__enter__.return_value = image_mock

blob = UserDict()

blob.name = filename

blob.bucket = UserDict()

blob.download_to_filename = MagicMock()

blob.upload_from_filename = MagicMock()

image.__blur_image(blob)

out, _ = capsys.readouterr()

assert f'Image {filename} was downloaded to' in out

assert f'Image {filename} was blurred.' in out

assert f'Blurred image uploaded to: gs://{blur_bucket}/{filename}' in out

assert os_mock.remove.called

assert image_mock.resize.called

import base64

from flask import Flask, request

import json

import os

import sys

import image

app = Flask(__name__)

def index():

envelope = request.get_json()

if not envelope:

msg = 'no Pub/Sub message received'

print(f'error: {msg}')

return f'Bad Request: {msg}', 400

if not isinstance(envelope, dict) or 'message' not in envelope:

msg = 'invalid Pub/Sub message format'

print(f'error: {msg}')

return f'Bad Request: {msg}', 400

# Decode the Pub/Sub message.

pubsub_message = envelope['message']

if isinstance(pubsub_message, dict) and 'data' in pubsub_message:

try:

data = json.loads(

base64.b64decode(pubsub_message['data']).decode())

except Exception as e:

msg = ('Invalid Pub/Sub message: '

'data property is not valid base64 encoded JSON')

print(f'error: {e}')

return f'Bad Request: {msg}', 400

# Validate the message is a Cloud Storage event.

if not data["name"] or not data["bucket"]:

msg = ('Invalid Cloud Storage notification: '

'expected name and bucket properties')

print(f'error: {msg}')

return f'Bad Request: {msg}', 400

try:

image.blur_offensive_images(data)

# Flush the stdout to avoid log buffering.

sys.stdout.flush()

return ('', 204)

except Exception as e:

print(f'error: {e}')

return ('', 500)

return ('', 500)

# [END run_imageproc_controller]

if __name__ == '__main__':

PORT = int(os.getenv('PORT')) if os.getenv('PORT') else 8080

# This is used when running locally. Gunicorn is used to run the

# application on Cloud Run. See entrypoint in Dockerfile.

app.run(host='127.0.0.1', port=PORT, debug=True)