Waitrerss веб-сервис под Windows

serve(app, host = '10.ХХ.Х.162', port = 5000)

serve(app)

serve(app, port=4646)

app = Flask(__name__)
#........
 
if __name__ == '__main__':
    #app.run()
    #app.run(host='10.XX.X.162', port='5000')
    serve(app)
    #serve(app, port = 5000)
    #serve(app, host = '10.XX.X.162', port = 5000)

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Python 2.7.11 64bit
 
#region import
import sys; sys.coinit_flags = 0
import base64
import io
import os
import tempfile
from datetime import datetime
 
import mysql.connector
import win32com.client as Win32
from flask import Flask, Response, request
from PIL import Image as PilImage
from PIL import ImageDraw, ImageFont, ImageSequence
from PyPDF2 import PdfFileReader, PdfFileWriter
from waitress import serve
 
from wand.image import Image as WandImage
#endregion
 
app = Flask(__name__)
 
#region VIEWER
def viewer_response(file_body, file_page_count):
    response = Response(response = file_body, status = 200)
    response.headers.add('Content-type', 'image/png')
    response.headers.add('X_Pages_count', file_page_count)
    return response
 
def pdf_page_count(pdf_file):
    pdf = PdfFileReader(pdf_file, strict = False)
    page_count = pdf.getNumPages()
    return page_count
 
def pdf_converter(file_type, blob):
    extension = file_type.lower()
    if(extension == 'pdf'):
        with tempfile.TemporaryFile(suffix='.pdf', delete=False) as f:
            f.write(blob)
            return f.name
    else:
        if extension in ['doc','docx','rtf']:
            return convert_word_to_pdf(file_type, blob)
        elif extension in ['xls','xlsx']:
            return convert_excel_to_pdf(file_type, blob)
        elif extension in ['tiff', 'tif']:
            return convert_tiff_to_pdf(file_type, blob)
        else:
            return None
 
def convert_word_to_pdf(file_type, file_body):
    tmp = create_file(file_type, file_body)
    pdf = create_file('pdf')
 
    word = Win32.gencache.EnsureDispatch('Word.Application')
    word.Visible = False
    word.DisplayAlerts = False
    doc = word.Documents.Open(tmp)
    doc.ActiveWindow.View.RevisionsView = 0
    doc.ActiveWindow.View.ShowRevisionsAndComments = False
    doc.SaveAs2(pdf, 17)
    doc.Close(False)
    word.Application.Quit()
    os.remove(tmp)
    return pdf
 
def convert_excel_to_pdf(file_type, file_body):
    tmp = create_file(file_type, file_body)
    pdf = create_file('pdf')
 
    excel = Win32.gencache.EnsureDispatch('Excel.Application')
    excel.Visible = False
    excel.DisplayAlerts = False
    doc = excel.Workbooks.Open(tmp)
    doc.ExportAsFixedFormat(0, pdf, 0)
    doc.Close()
    excel.Application.Quit()
    os.remove(tmp)
    return pdf
 
def convert_tiff_to_pdf(file_type, file_body):
    tmp = create_file(file_type, file_body)
    pdf = create_file('pdf')
 
    with open(tmp, 'rb') as tiff:
        tiff_image = PilImage.open(tiff)
        
        pages = []
        for page in ImageSequence.Iterator(tiff_image):
            pages.append(page.convert('RGB'))
 
        pages[0].save(pdf, save_all = True, append_images = pages[1:])
    
    os.remove(tmp)
    return pdf
 
def convert_pdf_to_png(source_file, file_page, file_page_count):
    if(file_page <= file_page_count):
        pdf_blob = io.BytesIO()
 
        pdf_writer = PdfFileWriter()
        pdf_page = PdfFileReader(source_file, strict = False).getPage(file_page - 1)
        pdf_writer.addPage(pdf_page)
        pdf_writer.write(pdf_blob)
        pdf_blob.seek(0)
 
        with WandImage(blob = pdf_blob, resolution = 100) as thumb:
            image = WandImage(width = thumb.width, height = thumb.height)
            image.composite(thumb.sequence[0], top = 0, left = 0)
            return image.make_blob('png')
 
def create_file(file_type, file_body = None):
    with tempfile.TemporaryFile(suffix = ('.' + file_type), delete = False) as f:
        file_path = f.name
        if(file_body != None):
            f.write(file_body)
    return file_path
 
@app.route('/viewer', methods = ['POST'])
def viewer_method():
    file_page = int(request.args.get(u'numpage'))
    file_type = request.args.get(u'type')
    file_md5 = request.args.get(u'HASH')
 
    db_row_id = db_get_by_md5(file_md5)
    if(db_row_id == None):
        file_data = request.files[u'fieldNameHere'].read() # prod: datafile | fiddler: fieldNameHere
        file_decoded_data = file_data # prod: base64.decodestring(file_data) | fiddler: file_data
 
        thumb_pdf = pdf_converter(file_type, file_decoded_data)
        with open(thumb_pdf, 'rb') as f:
            thumb_pdf_page_count = pdf_page_count(f)
            data_dict = {'pages': thumb_pdf_page_count}
            thumb_png_body = convert_pdf_to_png(f, file_page, thumb_pdf_page_count)
        
        db_insert(file_md5, file_type, file_decoded_data, thumb_pdf_page_count, datetime.now())
    else:
        data_dict = db_get_data(db_row_id)
        thumb_pdf = pdf_converter(file_type, data_dict['blob'])
        with open(thumb_pdf, 'rb') as f:
            thumb_png_body = convert_pdf_to_png(f, file_page, data_dict['pages'])
    
    #os.remove(thumb_pdf)
    db_delete_old()
    response = viewer_response(thumb_png_body, data_dict['pages'])
    create_file('png', thumb_png_body)
    return response
#endregion
 
#region MySql
def db_init():
    return mysql.connector.connect(
        host = '10.XX.X.162', 
        user = 'remoter', 
        password = 'g4zuCC', 
        database = 'pdfservice'
    )
 
def db_close(cursor, connection):
    cursor.close()
    connection.close()
    pass
 
def db_get_by_md5(md5):
    conn = db_init()
    cur = conn.cursor()
    query = 'SELECT file_id FROM dbcache WHERE file_md5 = %s LIMIT 1 '
    params = (md5, )
    cur.execute(query, params)
    row_id = cur.fetchone()
    db_close(cur, conn)
 
    if (row_id == None):
        return None
    else:
        return row_id[0]
 
def db_get_data(row_id):
    conn = db_init()
    cur = conn.cursor()
    query = 'SELECT file_type, file_blob, file_pages FROM dbcache WHERE file_id = %s '
    cur.execute(query, (row_id,))
    result = cur.fetchone()
 
    data = {'blob': result[1], 'pages': result[2]}
    db_close(cur, conn)
    return data
 
def db_insert(md5, ftype, blob, pages, dt):
    conn = db_init()
    cur = conn.cursor()
    dt_str = dt.strftime('%Y-%m-%d %H:%M:%S')
    query = 'INSERT INTO dbcache (file_md5, file_type, file_blob, file_created, file_pages) VALUES (%s, %s, %s, %s, %s) '
    params = (md5, ftype, blob, dt_str, pages)
    cur.execute(query, params)
    conn.commit()
    db_close(cur, conn)
    pass
 
def db_delete_old():
    conn = db_init()
    cur = conn.cursor()
    cur.execute('DELETE FROM dbcache WHERE file_created < (NOW() - INTERVAL 1 HOUR) ')
    conn.commit()
    cur.close()
    conn.close()
    pass
#endregion
 
@app.route('/', methods = ['GET', 'POST'])
def not_found():
    return 'PDF Service: call correct web-service method.'
 
if __name__ == '__main__':
    #app.run()
    #app.run(host='10.XX.X.162', port='5000')
    #serve(app, port = 5000)
    serve(app, host = '10.XX.X.162', port = 5000)