def __enter__(self):
self._tempdir_path = Path(
tempfile.mkdtemp(prefix='opengever.core.doxcmerge_'))
self._index = 0
self._composer = Composer(self._as_document(self._master))
return self
def mergeDocuments(documents):
if not documents:
return
composer = Composer(documents[0])
for i in range(1, len(documents)):
composer.append(documents[i])
return composer
def merge_docs(first_doc, second_doc):
if not first_doc:
return second_doc
if not second_doc:
return first_doc
composer = Composer(first_doc)
composer.append(second_doc)
return composer.doc
def merge_documents(documents):
for document in documents[:-1]:
document.add_page_break()
composer = Composer(documents[0])
for document in documents[1:]:
composer.append(document)
return composer.doc
def composeDoc(composer, i, rows):
new_doc = Document(TEMP_DOC)
if (i < rows - 1):
new_doc.add_page_break()
if composer is None:
composer = Composer(new_doc)
else:
composer.append(new_doc)
return composer
def gen_doc(graph_data, style, template=None, max_processes=os.cpu_count()+1):
if template is None:
doc = Document()
else:
doc = Document(template)
composer = Composer(doc)
workers = []
progress = 0
for i in range(len(graph_data)):
process = multiprocessing.Process(target=task, args=(i, graph_data[i], style))
workers.append(process)
process.start()
if i == max_processes:
for elt in workers:
elt.join()
composer.append(Document('docx/tmp/part{}.docx'.format(progress)))
progress += 1
workers = []
for elt in workers:
elt.join()
composer.append(Document('docx/tmp/part{}.docx'.format(progress)))
progress += 1
composer.save('docx/final.docx')
print("Document generated in docx/final.docx.\n")
def merge(input_dir):
logger.info('Gather files..')
files = os.listdir(input_dir)
files = filter(
lambda x: not x.startswith(('.', '~')) and x.endswith('.docx'), files)
files = sorted([os.path.join(input_dir, file_) for file_ in files])
logger.info('Merging files..')
master = Document(files.pop(0))
composer = Composer(master)
for file_ in files:
composer.append(Document(file_))
return composer
def concat_docx(dir_p, dst_p, suffix, name='codes'):
docxs = finder(dir_p)
up_bound = len(docxs)
d0 = read_docx(docxs[0])
d0.add_page_break()
h0 = head(docxs[0], suffix)
compose = Composer(h0)
compose.append(d0)
for count, docx in enumerate(docxs[1:], start=2):
sub_head = head(docx, suffix)
compose.append(sub_head)
sub_d = read_docx(docx)
if count < up_bound:
sub_d.add_page_break()
compose.append(sub_d)
compose.save(os.path.join(dst_p, f'{name}.docx'))
def combine_resumes_and_other_stuff(resume_list):
number_of_sections = len(resume_list)
master = Document_compose(filename_master)
composer = Composer(master)
for i in range(0, number_of_sections):
doc_temp = Document_compose(resume_list[i])
composer.append(doc_temp)
composer.append(Document_compose(last))
composer.save(resume_master)
def compose_single_equipment(parameters: dict):
doc = docx.Document(ALL_DOCUMENTS["BaseEquipment"])
find_and_replace(doc, parameters)
checkRow = ["test_date", "remark", "testVision", "testFunction", "tester"]
if len(parameters["checks"]) <= 9:
find_and_replace(doc, {"pagenumber": "1"})
parameterChecks: dict = {}
for iterChecks in range(1, 10):
for check, iter in zip(checkRow, range(0, 5)):
try:
parameterChecks[check +
str(iterChecks)] = parameters["checks"][
iterChecks - 1][iter]
except IndexError:
parameterChecks[check + str(iterChecks)] = ""
find_and_replace(doc, parameterChecks)
composed_master = Composer(doc)
else:
find_and_replace(doc, {"pagenumber": str(1)})
parameterChecks: dict = {}
for iterChecks in range(1, 10):
for check, iter in zip(checkRow, range(0, 5)):
try:
parameterChecks[check +
str(iterChecks)] = parameters["checks"][(
(1 - 1) * 9) + (iterChecks - 1)][iter]
except IndexError:
parameterChecks[check + str(iterChecks)] = ""
find_and_replace(doc, parameterChecks)
composed_master = Composer(doc)
for iterPages in range(2,
math.ceil(len(parameters["checks"]) / 9) + 1):
doc = docx.Document(ALL_DOCUMENTS["BaseEquipment"])
find_and_replace(doc, parameters)
find_and_replace(doc, {"pagenumber": str(iterPages)})
parameterChecks: dict = {}
for iterChecks in range(1, 10):
for check, iter in zip(checkRow, range(0, 5)):
try:
parameterChecks[
check + str(iterChecks)] = parameters["checks"][(
(iterPages - 1) * 9) + (iterChecks - 1)][iter]
except IndexError:
parameterChecks[check + str(iterChecks)] = ""
find_and_replace(doc, parameterChecks)
composed_master.append(doc)
composed_master.save(out_path)
return composed_master
def printable_doc(records_list, explicit_template):
'''Generates a Word .docx file with one page for each record. Returns
a Python docx Document object.'''
num_pages = len(records_list)
if num_pages < 1:
return None
template = explicit_template or normal_template()
if not readable(template):
raise InternalError('Cannot find a template file for printing.')
date_time_stamps = current_date_and_time()
# I tried appending directly to the docx and DocxTemplate objects, but
# the results caused Word to complain that the file was corrupted. The
# algorithm below writes out a separate file for each record, then in a
# subsequent loop, uses docxcompose to combine individual docx Document
# objects for each file into one overall docx.
files_list = []
for index, record in enumerate(records_list):
tmpfile = tempfile.TemporaryFile()
doc = DocxTemplate(template)
values = vars(records_list[index])
values = {k: sanitized_string(v) for k, v in values.items()}
values.update(date_time_stamps)
doc.render(values)
if index < (num_pages - 1):
doc.add_page_break()
doc.save(tmpfile)
files_list.append(tmpfile)
if len(files_list) < 2:
return doc
else:
# The only way I found to create a viable single .docx file containing
# multiple pages is to create separate docx Document objects out of
# separate actual files (rather than trying to do it all in memory).
composer = Composer(Document(files_list[0]))
for page in files_list[1:]:
composer.append(Document(page))
return composer
def concatenate_files(path_list):
new_path_list = []
for path in path_list:
mimetype, encoding = mimetypes.guess_type(path)
if mimetype in ('application/rtf', 'application/msword', 'application/vnd.oasis.opendocument.text'):
new_docx_file = tempfile.NamedTemporaryFile(prefix="datemp", mode="wb", suffix=".docx", delete=False)
if mimetype == 'application/rtf':
ext = 'rtf'
elif mimetype == 'application/msword':
ext = 'doc'
elif mimetype == 'application/vnd.oasis.opendocument.text':
ext = 'odt'
docassemble.base.pandoc.convert_file(path, new_docx_file.name, ext, 'docx')
new_path_list.append(new_docx_file.name)
elif mimetype == 'application/vnd.openxmlformats-officedocument.wordprocessingml.document':
new_path_list.append(path)
if len(new_path_list) == 0:
raise DAError("concatenate_files: no valid files to concatenate")
if len(new_path_list) == 1:
return new_path_list[0]
composer = Composer(docx.Document(new_path_list[0]))
for indexno in range(1, len(new_path_list)):
composer.append(docx.Document(new_path_list[indexno]))
docx_file = tempfile.NamedTemporaryFile(prefix="datemp", mode="wb", suffix=".docx", delete=False)
composer.save(docx_file.name)
return docx_file.name
def merge_word_documents(indir,
outfile=search_book_name(),
add_page_break=True,
delete_merged_files=True):
"""
Merge word documents.
:param indir: THe directory where the documents are stored.
:param outfile: THe outfile name of the word documents.
:param add_page_break: flag for adding page breaks between documents.
:param delete_merged_files: flag determining if the files merged files should be deleted.
"""
files = [f"{indir}/{f}" for f in os.listdir(indir) if f.endswith(".docx")]
first, *rest = files
master = Document_compose(first)
if add_page_break:
master.add_page_break()
composer = Composer(master)
for i, f in enumerate(rest):
tmp = Document_compose(f)
if add_page_break and i < len(rest) - 1:
tmp.add_page_break()
composer.append(tmp)
composer.save(f"{indir}/{outfile}")
if delete_merged_files:
for f in files:
os.remove(f)
def make_master_file(docx_filepaths, filename, summ=True):
'''
for now, this takes in a list of filepaths, and creates two master files: one for summaries, and one for the articles
it uses the above functions to:
- create the summaries for the text in each individual article
- formats headings and makes a table of contents for each file
the input moving forward will likely be doc objects - files will be sent to an api endpoint, the api function will convert to docx objects, then sent to this
this means we'll need to change this around a bit
'''
toc = Document()
paragraph = toc.add_paragraph('TABLE OF CONTENTS')
toc = make_toc(toc)
article_list = [toc]
for article in docx_filepaths:
article_list.append(create_doc(article, summ))
master = article_list[0]
composer = Composer(master)
for document in article_list[1:]:
composer.append(document)
composer.save(filename)
update_toc(filename)
def post(self):
"""
Merge multiple docx documents into one
"""
log.info("received a request to merge docx")
contents = request.json['contents']
if len(contents) < 2:
return {"message": "contents must be at least 2 elements"}, 400
tempFolder = generate_temp_folder()
ext = '.docx'
for i, content in enumerate(contents):
base64_decode = base64.b64decode(content)
fp = open(tempFolder + "/file" + str(i) + ext, "wb")
fp.write(base64_decode)
fp.close()
for i in range(len(contents)):
doc = Document(tempFolder + '/file' + str(i) + ext)
if i == 0:
composer = Composer(doc)
else:
composer.append(doc)
output_file = tempFolder + '/final' + ext
composer.save(output_file)
return send_file(output_file, as_attachment=True)
def _combine_docx(target_file, files):
master = Document_compose(files[0])
composer = Composer(master)
for i in range(1, len(files)):
doc_temp = Document_compose(files[i])
composer.append(doc_temp)
composer.save(target_file)
def combine_report(docs_list, output_path):
master = Document(docs_list[0])
composer = Composer(master)
if len(docs_list) > 1:
for item_path in docs_list[1:]:
doc = Document(item_path)
composer.append(doc)
composer.save(output_path)
def mergeDoc(filename_master, files_list):
number_of_sections = len(files_list)
master = Document_compose()
composer = Composer(master)
for i in range(0, number_of_sections):
doc_temp = Document_compose(files_list[i])
composer.append(doc_temp)
composer.save(filename_master)
def compose_files(parser, parsed_args):
composer = Composer(Document(parsed_args.master))
for slave_path in parsed_args.files:
composer.append(Document(slave_path))
composer.save(parsed_args.ouput_document)
parser.exit(message='successfully composed file at {}\n'.format(
parsed_args.ouput_document))
def combine_all_docx(filename_master, files_list):
number_of_sections = len(files_list)
master = Document_compose(filename_master)
composer = Composer(master)
for i in range(0, number_of_sections):
doc_temp = Document_compose(files_list[i])
composer.append(doc_temp)
composer.save("combined_file.docx")
def combine_all_docx(filename_master, files_list):
number_of_sections = len(files_list)
master = Document_compose(filename_master)
composer = Composer(master)
for i in range(0, number_of_sections):
doc_temp = Document_compose(files_list[i])
composer.append(doc_temp)
open('1.txt', 'w')
composer.save("ALL_SERTIFICATES.docx")
def combine_all_docx(filename_master, files_list):
# Функция для объединения документов
number_of_sections = len(files_list)
master = Document_compose(filename_master)
composer = Composer(master)
for i in range(1, number_of_sections):
doc_temp = Document_compose(files_list[i])
composer.append(doc_temp)
composer.save("Все сертификаты в одном файле.docx")
def fusion2(word1, word2, dep):
master = Document(word1)
master.add_page_break()
composer = Composer(master)
doc1 = Document(word2)
composer.append(doc1)
name_fusion = "reports_word/Suivi_Territorial_plan_relance_{}.docx".format(
dep)
composer.save(name_fusion)
return name_fusion
def combine_word_documents(cls,word_files, ds_name):
merged_document = Document(EMPTY_DOC_PATH)
composer = Composer(merged_document)
for file in word_files:
doc_temp = Document(file)
composer.append(doc_temp)
try:
composer.save(os.path.join(os.path.dirname(word_files[0]),f'{ds_name}.docx'))
except PermissionError as e:
print(str(e))
def mergeDocx_pyDocx(destFileName, file_list):
number = len(file_list)
master = Document(file_list[0])
docx_composer = Composer(master)
for x in range(1, number):
docx_tmp = Document(file_list[x])
docx_composer.append(docx_tmp)
docx_composer.save(destFileName)
def append():
masterDoc = Document(documents[0]["path"])
masterDoc.add_page_break()
composer = Composer(masterDoc)
for doc in range(1, len(documents)):
docu = Document(documents[doc]["path"])
docu.add_page_break()
composer.append(docu)
doc += 1
composer.save(os.path.join(path, "combined.docx"))
messagebox.showinfo("POTEITOES!", "Ho finito!")
def combine_all_env(filename_master,files_list):
savepath = os.getcwd() + "\\print\\" + name + "_combined_envelope.docx"
number_of_sections=len(files_list)
master = Document_compose(filename_master)
composer = Composer(master)
for i in range(0, number_of_sections):
if os.path.isfile(files_list[i]) == True:
doc_temp = Document_compose(files_list[i])
composer.append(doc_temp)
composer.save(savepath)
def compose_doc(created, copy, pages):
doc_main = Document()
doc_main.save("temporary_main.docx")
master = Document("temporary_main.docx")
composer = Composer(master)
doc = Document(copy)
for i in range(pages):
composer.append(doc)
composer.save(created)
remove("temporary_main.docx")
remove("temporary_copy.docx")
def merge_documents(files, output_doc, output_pdf):
merger = Composer(Document())
for file in files:
merger.append(Document(file), False)
paragraph_count = len(merger.doc.paragraphs)
if paragraph_count > 0:
delete_paragraph(merger.doc.paragraphs[paragraph_count - 1])
merger.save(output_doc)
if not output_pdf is None:
docx_to_pdf(output_doc, output_pdf)
def combine_all_docx(filename_master, files_list, output):
print('Merging: %s' % filename_master)
number_of_sections = len(files_list)
master = Document_compose(filename_master)
composer = Composer(master)
for i in range(0, number_of_sections):
doc_temp = Document_compose(files_list[i])
composer.append(doc_temp)
print('Merging: %s' % (files_list[i]))
composer.save(output)
hr('OUTPUT:')
print('Output file: %s' % output)
class DocxMergeTool(object):
"""The docx merge tool merges docx documents with the docxcompose composer.
The merge is based on a master document, if remove_property_fields is False
the master's doc-properties will be preserved.
It is used as a context manager and accepts bytes of documents.
Calling the DocxMergeTool object merges the documents and returns the resulting
bytes.
The files are merged in the order they were added or inserted as as
specified by inserts index.
"""
def __init__(self, master, remove_property_fields=True):
self._remove_property_fields = remove_property_fields
self._master = master
def __enter__(self):
self._tempdir_path = Path(tempfile.mkdtemp(prefix='opengever.core.doxcmerge_'))
self._index = 0
self._composer = Composer(self._as_document(self._master))
return self
def __exit__(self, exc_type, exc_value, tb):
self._tempdir_path.rmtree_p()
def __call__(self):
"""Merge the registered docx files and return the resulting bytes.
"""
result_path = self._tempdir_path.joinpath('result.docx')
self._composer.save(result_path)
return result_path.bytes()
def add(self, file_data):
self._composer.append(
self._as_document(file_data),
remove_property_fields=self._remove_property_fields)
def insert(self, index, file_data):
self._composer.insert(
index, self._as_document(file_data),
remove_property_fields=self._remove_property_fields)
def _as_document(self, file_data):
"""Convert bytes to a document.
Also make sure property field value are up to date before they are
removed.
"""
path = self._get_next_path()
path.write_bytes(file_data)
document = Document(path)
if self._remove_property_fields:
CustomProperties(document).update_all()
return document
def _get_next_path(self):
path = self._tempdir_path.joinpath('{0}.docx'.format(self._index))
self._index += 1
return path
def __enter__(self):
self._tempdir_path = Path(tempfile.mkdtemp(prefix='opengever.core.doxcmerge_'))
self._index = 0
self._composer = Composer(self._as_document(self._master))
return self
