def test_do_convert_success_but_no_images(self):
doc_path = get_latex_file_dir("xelatex")
filename = os.listdir(doc_path)[0]
file_path = os.path.join(doc_path, filename)
tex_source = get_file_content(file_path).decode("utf-8")
with mock.patch(
"latex.converter.get_number_of_pdf_file") as mock_get_n_images:
mock_get_n_images.return_value = 0
with self.assertRaises(ImageConvertError) as cm:
unzipped_folder_to_pdf_converter(
"xelatex", tex_source, "png").get_converted_data_url()
self.assertIn("No image was generated", str(cm.exception))
def test_more_than_one_pages_error(self):
latex_doc_path = get_latex_file_dir("pdflatex_multilple_pages")
for filename in os.listdir(latex_doc_path):
file_path = os.path.join(latex_doc_path, filename)
image_format = "png"
with self.subTest(filename=filename,
test_name="pdflatex",
image_format=image_format):
tex_source = get_file_content(file_path).decode("utf-8")
with self.assertRaises(ImageConvertError):
unzipped_folder_to_pdf_converter(
"pdflatex", tex_source,
image_format).get_converted_data_url()
def test_get_data_url_error(self):
doc_path = get_latex_file_dir("xelatex")
filename = os.listdir(doc_path)[0]
file_path = os.path.join(doc_path, filename)
tex_source = get_file_content(file_path).decode("utf-8")
expected_error = "some error"
with mock.patch("latex.converter.get_data_url") as mock_get_data_url:
mock_get_data_url.side_effect = RuntimeError(expected_error)
with self.assertRaises(ImageConvertError) as cm:
unzipped_folder_to_pdf_converter(
"xelatex", tex_source, "svg").get_converted_data_url()
self.assertIn(expected_error, str(cm.exception))
def test_compile_no_error_but_no_compiled_pdf_file(self):
doc_path = get_latex_file_dir("xelatex")
filename = os.listdir(doc_path)[0]
file_path = os.path.join(doc_path, filename)
tex_source = get_file_content(file_path).decode("utf-8")
with mock.patch("latex.converter.Tex2ImgBase.compile_popen"
) as mock_compile_subprocess:
mock_compile_subprocess.return_value = ["foo", "", 0]
with self.assertRaises(UnknownCompileError) as cm:
unzipped_folder_to_pdf_converter(
"xelatex", tex_source, "png").get_converted_data_url()
self.assertIn("No pdf file was generated.", str(cm.exception))
def test_convert_error(self):
doc_path = get_latex_file_dir("xelatex")
filename = os.listdir(doc_path)[0]
file_path = os.path.join(doc_path, filename)
tex_source = get_file_content(file_path).decode("utf-8")
expected_error = "some error"
with mock.patch("latex.converter.ImageConverter.convert_popen"
) as mock_compile_subprocess:
mock_compile_subprocess.return_value = ["bar", expected_error, 1]
with self.assertRaises(ImageConvertError) as cm:
unzipped_folder_to_pdf_converter(
"xelatex", tex_source, "svg").get_converted_data_url()
self.assertIn(expected_error, str(cm.exception))
def test_pdfsvg(self):
pdf2svg_doc_path = get_latex_file_dir("pdf2svg")
for filename in os.listdir(pdf2svg_doc_path):
file_path = os.path.join(pdf2svg_doc_path, filename)
with self.subTest(filename=filename, test_name="xelatex_svg"):
tex_source = get_file_content(file_path).decode("utf-8")
data_url = unzipped_folder_to_pdf_converter(
"xelatex", tex_source, "svg").get_converted_data_url()
self.assertIsNotNone(data_url)
self.assertTrue(data_url.startswith("data:image/svg"))
def test_latex_png_tizk_got_svg(self):
latex_doc_path = get_latex_file_dir("latex2png")
for image_format in ["png"]:
for filename in os.listdir(latex_doc_path):
file_path = os.path.join(latex_doc_path, filename)
with self.subTest(filename=filename,
test_name="latex",
image_format=image_format):
tex_source = get_file_content(file_path).decode("utf-8")
data_url = unzipped_folder_to_pdf_converter(
"latex", tex_source,
image_format).get_converted_data_url()
self.assertIsNotNone(data_url)
self.assertTrue(
data_url.startswith("data:image/%s" % image_format))
def create(self, request, *args, **kwargs):
try:
req_params = MultiPartParser().parse(request)
compiler = req_params.pop("compiler")
tex_source = req_params.pop("tex_source")
tex_key = req_params.pop("tex_key", None)
field_str = req_params.pop("fields", None)
except Exception:
from traceback import print_exc
print_exc()
tp, e, __ = sys.exc_info()
error = "%s: %s" % (tp.__name__, str(e))
return Response({"error": error},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
if field_str and tex_key:
cached_result = (get_cached_results_from_field_and_tex_key(
tex_key, field_str, request))
if cached_result:
return Response(cached_result, status=status.HTTP_200_OK)
data_url = None
error = None
try:
_converter = unzipped_folder_to_pdf_converter(
compiler, tex_source, image_format, tex_key, **req_params)
except Exception as e:
from traceback import print_exc
print_exc()
tp, e, __ = sys.exc_info()
error = "%s: %s" % (tp.__name__, str(e))
return Response({"error": error},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
qs = LatexPdf.objects.filter(
project__zip_file_hash=_converter.zip_file_hash)
if qs.count():
instance = qs[0]
image_serializer = self.get_serializer(instance, fields=field_str)
return Response(image_serializer.data, status=status.HTTP_200_OK)
try:
data_url = _converter.get_converted_data_url()
except Exception as e:
if isinstance(e, LatexCompileError):
error = "%s: %s" % (type(e).__name__, str(e))
else:
from traceback import print_exc
print_exc()
tp, e, __ = sys.exc_info()
error = "%s: %s" % (tp.__name__, str(e))
return Response({"error": error},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
assert not all([data_url is None, error is None])
data = {"tex_key": _converter.zip_file_hash}
if data_url is not None:
data["data_url"] = data_url
else:
data["compile_error"] = error
data["creator"] = self.request.user.pk
image_serializer = self.get_serializer(data=data)
if image_serializer.is_valid():
instance = image_serializer.save()
return Response(self.get_serializer(instance,
fields=field_str).data,
status=status.HTTP_201_CREATED)
return Response(
# For example, tex_key already exists.
image_serializer.errors,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def compile_project(request, project_identifier):
pdf_instances = None
collection = None
ctx = {}
unknown_error = None
if request.method == "POST":
form = CollectionCreateForm(request.POST, request.FILES)
if form.is_valid():
form_zip_file = request.FILES.get("zip_file")
compiler = form.cleaned_data["compiler"]
_md5 = hashlib.md5(form_zip_file.read()).hexdigest()
zip_file_hash = "%s_%s" % (_md5, compiler)
project, created = LatexProject.objects.get_or_create(
identifier=project_identifier, creator=request.user)
collection_qset = LatexCollection.objects.filter(
project=project, zip_file_hash=zip_file_hash)
collection = None
pdf_instances = None
if collection_qset.count():
assert collection_qset.count() == 1
collection = collection_qset[0]
pdf_instances = LatexPdf.objects.filter(project=project,
collection=collection)
if collection is None:
collection = LatexCollection(project=project,
zip_file_hash=zip_file_hash)
working_dir = tempfile.mkdtemp()
print(working_dir)
with zipfile.ZipFile(form_zip_file, "r") as zf:
zf.extractall(working_dir)
try:
compiled_pdf_dict = unzipped_folder_to_pdf_converter(
working_dir, compiler=compiler)
except Exception as e:
from traceback import print_exc
print_exc()
tp, err, __ = sys.exc_info()
error_str = "%s: %s" % (tp.__name__, str(err))
if isinstance(e, LatexCompileError):
collection.compile_error = error_str
with atomic():
collection.save()
else:
unknown_error = ctx["unknown_error"] = error_str
else:
with atomic():
collection.save()
for (filename, filepath) in compiled_pdf_dict.items():
with open(filepath, "rb") as f:
buff = io.BytesIO(f.read())
pdf = InMemoryUploadedFile(
file=buff,
field_name='file',
name=filename,
content_type="application/pdf",
size=buff.tell(),
charset=None)
mediabox = get_pdf_mediabox(filepath)
print(mediabox)
pdf = LatexPdf(project=project,
collection=collection,
name=filename,
pdf=pdf,
mediabox=mediabox)
with atomic():
pdf.save()
pdf_instances = LatexPdf.objects.filter(
project=project, collection=collection)
finally:
shutil.rmtree(working_dir)
else:
form = CollectionCreateForm()
ctx["form"] = form
ctx["form_description"] = _("Convert Zipped LaTeX code to Pdf")
ctx["collection"] = collection
ctx["pdfs"] = pdf_instances
render_kwargs = {
"request": request,
"template_name": "latex/project_update.html",
"context": ctx
}
if collection is not None:
if collection.compile_error:
render_kwargs["status"] = status.HTTP_400_BAD_REQUEST
if unknown_error:
render_kwargs["status"] = status.HTTP_500_INTERNAL_SERVER_ERROR
return render(**render_kwargs)
