10821350919

Committed 11 Sep 2024 11:39PM CUT coverage: 99.969%. Remained the same

Build # 10821350919

Build Type

push

github

Committed by

web-flow

Commit Message

Up docs (#74)

Run Details

3250 of 3251 relevant lines covered (99.97%)

1.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

100.0

/src/faker_file/contrib/image/weasyprint_snippets.py

import base64

from pdf2image import convert_from_bytes
from weasyprint import HTML

from ...base import DEFAULT_FORMAT_FUNC

__author__ = "Artur Barseghyan <artur.barseghyan@gmail.com>"
__copyright__ = "2022-2023 Artur Barseghyan"
__license__ = "MIT"


def create_data_url(image_bytes: bytes, image_format: str) -> str:
    """Create data URL."""
    encoded_image = base64.b64encode(image_bytes).decode("utf-8")
    return f"data:image/{image_format};base64,{encoded_image}"


def add_table(
    provider,
    generator,
    document,
    data,
    counter,
    **kwargs,
):
    """Callable responsible for the table generation using pdfkit."""
    rows = kwargs.get("rows", 3)
    cols = kwargs.get("cols", 4)

    # Begin the HTML table
    table_html = "<table>"

    for row_num in range(rows):
        table_html += "<tr>"

        for col_num in range(cols):
            text = provider.generator.paragraph()
            table_html += f"<td>{text}</td>"

            # Meta-data
            data.setdefault("content_modifiers", {})
            data["content_modifiers"].setdefault("add_table", {})
            data["content_modifiers"]["add_table"].setdefault(counter, [])
            data["content_modifiers"]["add_table"][counter].append(text)

        table_html += "</tr>"

    # End the HTML table
    table_html += "</table>"

    pdf_bytes = HTML(string=generator.wrap(table_html)).write_pdf()
    generator.pages.extend(convert_from_bytes(pdf_bytes))


def add_picture(
    provider,
    generator,
    document,
    data,
    counter,
    **kwargs,
):
    """Callable responsible for the picture generation using pdfkit."""
    image = kwargs.get("image", provider.generator.image())
    data_url = create_data_url(image, "png")
    image_html = f"<img src='{data_url}' alt='Inline Image' />"

    pdf_bytes = HTML(string=generator.wrap(image_html)).write_pdf()
    generator.pages.extend(convert_from_bytes(pdf_bytes))


def add_page_break(
    provider,
    generator,
    document,
    data,
    counter,
    **kwargs,
):
    """Callable responsible for the page break insertion using pdfkit."""
    page_break_html = "<div style='page-break-before: always;'></div>"
    pdf_bytes = HTML(string=generator.wrap(page_break_html)).write_pdf()
    generator.pages.extend(convert_from_bytes(pdf_bytes))


def add_paragraph(
    provider,
    generator,
    document,
    data,
    counter,
    **kwargs,
):
    """Callable responsible for paragraph generation using pdfkit."""
    content = kwargs.get("content", None)
    max_nb_chars = kwargs.get("content", 5_000)
    wrap_chars_after = kwargs.get("wrap_chars_after", None)
    format_func = kwargs.get("format_func", DEFAULT_FORMAT_FUNC)

    _content = provider._generate_text_content(
        max_nb_chars=max_nb_chars,
        wrap_chars_after=wrap_chars_after,
        content=content,
        format_func=format_func,
    )

    paragraph_html = f"<div><p>{_content}</p></div>"
    pdf_bytes = HTML(string=generator.wrap(paragraph_html)).write_pdf()
    generator.pages.extend(convert_from_bytes(pdf_bytes))

    # Meta-data
    data.setdefault("content_modifiers", {})
    data["content_modifiers"].setdefault("add_paragraph", {})
    data["content_modifiers"]["add_paragraph"].setdefault(counter, [])
    data["content_modifiers"]["add_paragraph"][counter].append(_content)
    data["content"] += "\r\n" + _content


def add_heading(
    provider,
    generator,
    document,
    data,
    counter,
    **kwargs,
):
    """Callable responsible for heading generation using pdfkit."""
    content = kwargs.get("content", None)
    max_nb_chars = kwargs.get("max_nb_chars", 30)
    wrap_chars_after = kwargs.get("wrap_chars_after", None)
    format_func = kwargs.get("format_func", DEFAULT_FORMAT_FUNC)
    level = kwargs.get("level", 1)
    if level < 1 or level > 6:
        level = 1

    _content = provider._generate_text_content(
        max_nb_chars=max_nb_chars,
        wrap_chars_after=wrap_chars_after,
        content=content,
        format_func=format_func,
    )

    heading_html = f"<div><h{level}>{_content}</h{level}></div>"
    pdf_bytes = HTML(string=generator.wrap(heading_html)).write_pdf()
    generator.pages.extend(convert_from_bytes(pdf_bytes))

    # Meta-data
    data.setdefault("content_modifiers", {})
    data["content_modifiers"].setdefault("add_heading", {})
    data["content_modifiers"]["add_heading"].setdefault(counter, [])
    data["content_modifiers"]["add_heading"][counter].append(_content)
    data["content"] += "\r\n" + _content


def add_h1_heading(provider, generator, document, data, counter, **kwargs):
    """Callable responsible for the h1 heading generation."""
    return add_heading(
        provider, generator, document, data, counter, level=1, **kwargs
    )


def add_h2_heading(provider, generator, document, data, counter, **kwargs):
    """Callable responsible for the h2 heading generation."""
    return add_heading(
        provider, generator, document, data, counter, level=2, **kwargs
    )


def add_h3_heading(provider, generator, document, data, counter, **kwargs):
    """Callable responsible for the h3 heading generation."""
    return add_heading(
        provider, generator, document, data, counter, level=3, **kwargs
    )


def add_h4_heading(provider, generator, document, data, counter, **kwargs):
    """Callable responsible for the h4 heading generation."""
    return add_heading(
        provider, generator, document, data, counter, level=4, **kwargs
    )


def add_h5_heading(provider, generator, document, data, counter, **kwargs):
    """Callable responsible for the h5 heading generation."""
    return add_heading(
        provider, generator, document, data, counter, level=5, **kwargs
    )


def add_h6_heading(provider, generator, document, data, counter, **kwargs):
    """Callable responsible for the h6 heading generation."""
    return add_heading(
        provider, generator, document, data, counter, level=6, **kwargs
    )

1	import base64	1✔
2
3	from pdf2image import convert_from_bytes	1✔
4	from weasyprint import HTML	1✔
5
6	from ...base import DEFAULT_FORMAT_FUNC	1✔
7
8	__author__ = "Artur Barseghyan <artur.barseghyan@gmail.com>"	1✔
9	__copyright__ = "2022-2023 Artur Barseghyan"	1✔
10	__license__ = "MIT"	1✔
11
12
13	def create_data_url(image_bytes: bytes, image_format: str) -> str:	1✔
14	"""Create data URL."""
15	encoded_image = base64.b64encode(image_bytes).decode("utf-8")	1✔
16	return f"data:image/{image_format};base64,{encoded_image}"	1✔
17
18
19	def add_table(	1✔
20	provider,
21	generator,
22	document,
23	data,
24	counter,
25	**kwargs,
26	):
27	"""Callable responsible for the table generation using pdfkit."""
28	rows = kwargs.get("rows", 3)	1✔
29	cols = kwargs.get("cols", 4)	1✔
30
31	# Begin the HTML table
32	table_html = "<table>"	1✔
33
34	for row_num in range(rows):	1✔
35	table_html += "<tr>"	1✔
36
37	for col_num in range(cols):	1✔
38	text = provider.generator.paragraph()	1✔
39	table_html += f"<td>{text}</td>"	1✔
40
41	# Meta-data
42	data.setdefault("content_modifiers", {})	1✔
43	data["content_modifiers"].setdefault("add_table", {})	1✔
44	data["content_modifiers"]["add_table"].setdefault(counter, [])	1✔
45	data["content_modifiers"]["add_table"][counter].append(text)	1✔
46
47	table_html += "</tr>"	1✔
48
49	# End the HTML table
50	table_html += "</table>"	1✔
51
52	pdf_bytes = HTML(string=generator.wrap(table_html)).write_pdf()	1✔
53	generator.pages.extend(convert_from_bytes(pdf_bytes))	1✔
54
55
56	def add_picture(	1✔
57	provider,
58	generator,
59	document,
60	data,
61	counter,
62	**kwargs,
63	):
64	"""Callable responsible for the picture generation using pdfkit."""
65	image = kwargs.get("image", provider.generator.image())	1✔
66	data_url = create_data_url(image, "png")	1✔
67	image_html = f"<img src='{data_url}' alt='Inline Image' />"	1✔
68
69	pdf_bytes = HTML(string=generator.wrap(image_html)).write_pdf()	1✔
70	generator.pages.extend(convert_from_bytes(pdf_bytes))	1✔
71
72
73	def add_page_break(	1✔
74	provider,
75	generator,
76	document,
77	data,
78	counter,
79	**kwargs,
80	):
81	"""Callable responsible for the page break insertion using pdfkit."""
82	page_break_html = "<div style='page-break-before: always;'></div>"	1✔
83	pdf_bytes = HTML(string=generator.wrap(page_break_html)).write_pdf()	1✔
84	generator.pages.extend(convert_from_bytes(pdf_bytes))	1✔
85
86
87	def add_paragraph(	1✔
88	provider,
89	generator,
90	document,
91	data,
92	counter,
93	**kwargs,
94	):
95	"""Callable responsible for paragraph generation using pdfkit."""
96	content = kwargs.get("content", None)	1✔
97	max_nb_chars = kwargs.get("content", 5_000)	1✔
98	wrap_chars_after = kwargs.get("wrap_chars_after", None)	1✔
99	format_func = kwargs.get("format_func", DEFAULT_FORMAT_FUNC)	1✔
100
101	_content = provider._generate_text_content(	1✔
102	max_nb_chars=max_nb_chars,
103	wrap_chars_after=wrap_chars_after,
104	content=content,
105	format_func=format_func,
106	)
107
108	paragraph_html = f"<div><p>{_content}</p></div>"	1✔
109	pdf_bytes = HTML(string=generator.wrap(paragraph_html)).write_pdf()	1✔
110	generator.pages.extend(convert_from_bytes(pdf_bytes))	1✔
111
112	# Meta-data
113	data.setdefault("content_modifiers", {})	1✔
114	data["content_modifiers"].setdefault("add_paragraph", {})	1✔
115	data["content_modifiers"]["add_paragraph"].setdefault(counter, [])	1✔
116	data["content_modifiers"]["add_paragraph"][counter].append(_content)	1✔
117	data["content"] += "\r\n" + _content	1✔
118
119
120	def add_heading(	1✔
121	provider,
122	generator,
123	document,
124	data,
125	counter,
126	**kwargs,
127	):
128	"""Callable responsible for heading generation using pdfkit."""
129	content = kwargs.get("content", None)	1✔
130	max_nb_chars = kwargs.get("max_nb_chars", 30)	1✔
131	wrap_chars_after = kwargs.get("wrap_chars_after", None)	1✔
132	format_func = kwargs.get("format_func", DEFAULT_FORMAT_FUNC)	1✔
133	level = kwargs.get("level", 1)	1✔
134	if level < 1 or level > 6:	1✔
135	level = 1	1✔
136
137	_content = provider._generate_text_content(	1✔
138	max_nb_chars=max_nb_chars,
139	wrap_chars_after=wrap_chars_after,
140	content=content,
141	format_func=format_func,
142	)
143
144	heading_html = f"<div><h{level}>{_content}</h{level}></div>"	1✔
145	pdf_bytes = HTML(string=generator.wrap(heading_html)).write_pdf()	1✔
146	generator.pages.extend(convert_from_bytes(pdf_bytes))	1✔
147
148	# Meta-data
149	data.setdefault("content_modifiers", {})	1✔
150	data["content_modifiers"].setdefault("add_heading", {})	1✔
151	data["content_modifiers"]["add_heading"].setdefault(counter, [])	1✔
152	data["content_modifiers"]["add_heading"][counter].append(_content)	1✔
153	data["content"] += "\r\n" + _content	1✔
154
155
156	def add_h1_heading(provider, generator, document, data, counter, **kwargs):	1✔
157	"""Callable responsible for the h1 heading generation."""
158	return add_heading(	1✔
159	provider, generator, document, data, counter, level=1, **kwargs
160	)
161
162
163	def add_h2_heading(provider, generator, document, data, counter, **kwargs):	1✔
164	"""Callable responsible for the h2 heading generation."""
165	return add_heading(	1✔
166	provider, generator, document, data, counter, level=2, **kwargs
167	)
168
169
170	def add_h3_heading(provider, generator, document, data, counter, **kwargs):	1✔
171	"""Callable responsible for the h3 heading generation."""
172	return add_heading(	1✔
173	provider, generator, document, data, counter, level=3, **kwargs
174	)
175
176
177	def add_h4_heading(provider, generator, document, data, counter, **kwargs):	1✔
178	"""Callable responsible for the h4 heading generation."""
179	return add_heading(	1✔
180	provider, generator, document, data, counter, level=4, **kwargs
181	)
182
183
184	def add_h5_heading(provider, generator, document, data, counter, **kwargs):	1✔
185	"""Callable responsible for the h5 heading generation."""
186	return add_heading(	1✔
187	provider, generator, document, data, counter, level=5, **kwargs
188	)
189
190
191	def add_h6_heading(provider, generator, document, data, counter, **kwargs):	1✔
192	"""Callable responsible for the h6 heading generation."""
193	return add_heading(	1✔
194	provider, generator, document, data, counter, level=6, **kwargs
195	)

barseghyanartur / faker-file / 10821350919

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous