249 lines
8.2 KiB
Python
249 lines
8.2 KiB
Python
"""
|
|
Fabrique à documents
|
|
Copyright (C) 2023 François Pelletier
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Affero General Public License as published
|
|
by the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Affero General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Affero General Public License
|
|
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
"""
|
|
|
|
import datetime
|
|
import logging
|
|
|
|
from fastapi import FastAPI, UploadFile
|
|
from fastapi.responses import FileResponse
|
|
import pypandoc
|
|
import json
|
|
from fastapi.testclient import TestClient
|
|
import os
|
|
import shutil
|
|
import cv2
|
|
|
|
from DocumentSpecs import DocumentSpecs
|
|
from FormatParameters import FormatParameters
|
|
from convert_pdf import convert_pdf
|
|
from extract_emojis import replace_emojis
|
|
from list_dir import list_dir
|
|
from responses import Styles, Formats, App
|
|
|
|
|
|
def convert_video(images_path, output_path, width, height, fps, stilltime):
|
|
"""
|
|
Convert images in output_path into a mp4 file usine OpenCV.
|
|
:param images_path:
|
|
:param output_path:
|
|
:param images_path:
|
|
:param width:
|
|
:param height:
|
|
:return:
|
|
"""
|
|
|
|
# define a frame array
|
|
frame_array = []
|
|
|
|
# list all files in images_path
|
|
files = [f for f in os.listdir(images_path) if os.path.isfile(os.path.join(images_path, f))]
|
|
# sort the files
|
|
files.sort()
|
|
|
|
# create a video writer object
|
|
|
|
for i in range(len(files)):
|
|
file = os.path.join(images_path, files[i])
|
|
logging.log(logging.INFO, f'Converting {file} to mp4')
|
|
img = cv2.imread(file)
|
|
for j in range(fps * stilltime):
|
|
frame_array.append(img)
|
|
|
|
fourcc = cv2.VideoWriter_fourcc(*'X264')
|
|
video_writer = cv2.VideoWriter(output_path,
|
|
fourcc,
|
|
fps,
|
|
(width, height))
|
|
|
|
for i in range(len(frame_array)):
|
|
# writing to a image array
|
|
video_writer.write(frame_array[i])
|
|
|
|
video_writer.release()
|
|
logging.log(logging.INFO, f'Finished converting {output_path}')
|
|
|
|
|
|
app = FastAPI()
|
|
|
|
|
|
@app.get("/")
|
|
async def get_root():
|
|
app = App(app='fabriquedoc')
|
|
return app
|
|
|
|
|
|
@app.get("/styles/")
|
|
async def get_styles():
|
|
styles = Styles(styles=list_dir("./styles"))
|
|
return styles
|
|
|
|
|
|
@app.get("/formats/{style}/")
|
|
async def get_formats(style: str):
|
|
formats = Formats(formats=list_dir(f"./styles/{style}/"))
|
|
return formats
|
|
|
|
|
|
@app.get("/format_parameters/{style}/{format}/")
|
|
async def get_format_parameters(style: str, format: str):
|
|
# open styles/format_parameters.json as a dictionary
|
|
with open(f"./styles/{style}/format_parameters.json", "r") as f:
|
|
format_data = json.load(f).get(format)
|
|
logging.log(logging.INFO, str(format_data))
|
|
# load data from format_data into the FormatParameters object
|
|
parameters = FormatParameters(**format_data)
|
|
return parameters
|
|
|
|
|
|
@app.get("/images/")
|
|
async def get_images():
|
|
# list all files in resources/images
|
|
files = [f for f in os.listdir("./resources/images") if os.path.isfile(os.path.join("./resources/images", f))]
|
|
# sort the files
|
|
files.sort()
|
|
return {"images": files}
|
|
|
|
|
|
@app.get("/images/{nom_image}")
|
|
async def get_image(nom_image: str):
|
|
return FileResponse(f"./resources/images/{nom_image}")
|
|
|
|
|
|
@app.post("/images/")
|
|
async def ajouter_image(file: UploadFile):
|
|
"""
|
|
Add an image to the images folder.
|
|
:param file:
|
|
:return:
|
|
"""
|
|
image_path = f"{os.getcwd()}/resources/images/{file.filename}"
|
|
try:
|
|
contents = file.file.read()
|
|
with open(image_path, 'wb') as f:
|
|
f.write(contents)
|
|
except Exception as e:
|
|
return {"message": f"There was an error uploading the file: {e}"}
|
|
finally:
|
|
file.file.close()
|
|
|
|
return {"message": f"Successfully uploaded all files"}
|
|
|
|
|
|
@app.delete("/images/{nom_image}")
|
|
async def supprimer_image(nom_image: str):
|
|
"""
|
|
Delete an image from the images folder.
|
|
:param nom_image:
|
|
:return:
|
|
"""
|
|
image_path = f"{os.getcwd()}/resources/images/{nom_image}"
|
|
try:
|
|
os.remove(image_path)
|
|
except Exception as e:
|
|
return {"message": f"There was an error deleting the file: {e}"}
|
|
finally:
|
|
return {"message": f"Successfully deleted {nom_image}"}
|
|
|
|
|
|
@app.get("/generer/")
|
|
async def generer(specs: DocumentSpecs):
|
|
header_file = f'{os.getcwd()}/styles/{specs.style}/{specs.format}/header.tex'
|
|
cover_file = f'{os.getcwd()}/styles/{specs.style}/{specs.format}/cover.tex'
|
|
datef = datetime.datetime.now().strftime("%Y-%m-%d")
|
|
os.makedirs("out", exist_ok=True)
|
|
filters = ['latex-emoji.lua', 'centered.lua']
|
|
pdoc_args = [
|
|
f'--include-in-header={header_file}',
|
|
f'--include-after-body={cover_file}',
|
|
'--listings',
|
|
'--dpi=300',
|
|
f'--toc-depth={specs.tocdepth}',
|
|
f'--pdf-engine={specs.pdfengine}',
|
|
f'--resource-path={os.getcwd()}/resources/',
|
|
'-V', f'linkcolor={specs.linkcolor}',
|
|
'-V', f'fontsize={specs.fontsize}pt',
|
|
'-V', f'geometry:paperwidth={round(specs.paperwidth * specs.ratio / 100, -1) / 300}in',
|
|
'-V', f'geometry:paperheight={round(specs.paperheight * specs.ratio / 100, -1) / 300}in',
|
|
'-V', f'geometry:left={specs.margin / 300}in',
|
|
'-V', f'geometry:right={specs.margin / 300}in',
|
|
'-V', f'geometry:top={specs.vmargin / 300}in',
|
|
'-V', f'geometry:bottom={specs.vmargin / 300}in'
|
|
]
|
|
pdf_file_path = f"./out/{specs.style}-{specs.format}-{datef}-output.pdf"
|
|
images_path = f"./out/{specs.style}-{specs.format}-{datef}-images"
|
|
try:
|
|
logging.info("Dossier courant = " + os.getcwd())
|
|
|
|
text_to_convert = replace_emojis(specs.content)
|
|
|
|
pypandoc.convert_text(source=text_to_convert,
|
|
to='pdf',
|
|
format='markdown+implicit_figures+smart+emoji',
|
|
encoding='utf-8',
|
|
extra_args=pdoc_args,
|
|
filters=filters,
|
|
cworkdir=os.getcwd(),
|
|
outputfile=pdf_file_path
|
|
)
|
|
|
|
except RuntimeError as rerr:
|
|
logging.exception(rerr)
|
|
except OSError as oerr:
|
|
logging.exception(oerr)
|
|
if specs.extension in ["jpg", "mp4"]:
|
|
filename = os.path.join("out", os.path.splitext(os.path.basename(pdf_file_path))[0])
|
|
if not os.path.exists(images_path):
|
|
os.mkdir(images_path)
|
|
conversion_extension = specs.extension
|
|
output_extension = specs.extension
|
|
if specs.extension in ["mp4"]:
|
|
conversion_extension = "jpg"
|
|
try:
|
|
convert_pdf(pdf_file_path,
|
|
conversion_extension,
|
|
images_path,
|
|
resolution=300)
|
|
if specs.extension in ["jpg"]:
|
|
shutil.make_archive(base_name=filename,
|
|
format='zip',
|
|
root_dir=images_path)
|
|
output_extension = "zip"
|
|
shutil.rmtree(images_path)
|
|
if specs.extension in ["mp4"]:
|
|
output_extension = "mp4"
|
|
convert_video(images_path=images_path,
|
|
output_path=f"{filename}.{output_extension}",
|
|
width=specs.paperwidth,
|
|
height=specs.paperheight,
|
|
fps=specs.fps,
|
|
stilltime=specs.stilltime)
|
|
except Exception as e:
|
|
logging.exception(e)
|
|
return FileResponse(f"{filename}.{output_extension}")
|
|
elif specs.extension == "pdf":
|
|
return FileResponse(pdf_file_path)
|
|
else:
|
|
return 0
|
|
|
|
|
|
client = TestClient(app)
|
|
|
|
|
|
def test_getroot():
|
|
response = client.get("/")
|
|
assert response.status_code == 200
|