velocity-python 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- velocity/__init__.py +1 -1
- velocity/aws/handlers/mixins/workflow_actions.py +343 -0
- velocity/misc/pdf.py +35 -6
- velocity/misc/qr.py +410 -0
- velocity/workflow/__init__.py +9 -3
- velocity/workflow/contract.py +21 -0
- velocity/workflow/engine.py +19 -1
- velocity/workflow/hooks.py +101 -0
- velocity/workflow/traveler.py +555 -0
- {velocity_python-0.8.0.dist-info → velocity_python-0.9.0.dist-info}/METADATA +1 -1
- {velocity_python-0.8.0.dist-info → velocity_python-0.9.0.dist-info}/RECORD +15 -13
- {velocity_python-0.8.0.dist-info → velocity_python-0.9.0.dist-info}/WHEEL +0 -0
- {velocity_python-0.8.0.dist-info → velocity_python-0.9.0.dist-info}/entry_points.txt +0 -0
- {velocity_python-0.8.0.dist-info → velocity_python-0.9.0.dist-info}/licenses/LICENSE +0 -0
- {velocity_python-0.8.0.dist-info → velocity_python-0.9.0.dist-info}/top_level.txt +0 -0
velocity/__init__.py
CHANGED
|
@@ -32,6 +32,9 @@ in ``client_actions`` (``client_actions = MINE | WORKFLOW_ACTIONS``)::
|
|
|
32
32
|
workflow-route-publish {route_id, revision, effective_from, comment?, request_key}
|
|
33
33
|
-> {ok, replayed, in_flight, version}
|
|
34
34
|
workflow-route-archive {route_id} -> {ok, replayed, version}
|
|
35
|
+
workflow-traveler {docket, kind?} -> {ok, filename, content_type, data_base64}
|
|
36
|
+
workflow-travelers {dockets: [id <= 200], kind?} -> the same (one PDF)
|
|
37
|
+
workflow-traveler-kinds {docket?} -> {kinds}
|
|
35
38
|
|
|
36
39
|
and :class:`WorkflowQueueMixin` to its queue handler (never reachable over
|
|
37
40
|
HTTP): ``workflow-program`` (a program station's job), ``workflow-drain``
|
|
@@ -84,12 +87,21 @@ the route's entity AND owning the route — by the version in force, never
|
|
|
84
87
|
the draft's own owner role; recorded). A version the person may not open is
|
|
85
88
|
refused exactly like one that does not exist. Masquerade forbids every
|
|
86
89
|
designer write. Simulations and tests write nothing.
|
|
90
|
+
|
|
91
|
+
**The traveler** (:mod:`velocity.workflow.traveler`): printing is seeing —
|
|
92
|
+
``workflow.docket.view`` on every docket printed, drawn from the docket as
|
|
93
|
+
the viewer sees it. One docket the person may not see is refused like the
|
|
94
|
+
docket view; in a batch it prints as a "Restricted" page, the same whether
|
|
95
|
+
it is hidden or missing. Each docket printed gets a ``print`` mark (in a
|
|
96
|
+
masquerade session it names the real person). The PDF fetches nothing
|
|
97
|
+
external.
|
|
87
98
|
"""
|
|
88
99
|
|
|
89
100
|
from __future__ import annotations
|
|
90
101
|
|
|
91
102
|
import dataclasses
|
|
92
103
|
import logging
|
|
104
|
+
import re
|
|
93
105
|
|
|
94
106
|
from velocity.aws import authz
|
|
95
107
|
from velocity.aws.handlers.exceptions import AccessError
|
|
@@ -115,6 +127,42 @@ def _workflow():
|
|
|
115
127
|
return workflow
|
|
116
128
|
|
|
117
129
|
|
|
130
|
+
_SITE_URL = re.compile(r"^https?://[A-Za-z0-9.-]+(:[0-9]{1,5})?(/[A-Za-z0-9._~/-]*)?$")
|
|
131
|
+
_ID = re.compile(r"[0-9]{1,18}")
|
|
132
|
+
_DOCKET_PATH = re.compile(r"^/[A-Za-z0-9._~/{}-]*$")
|
|
133
|
+
|
|
134
|
+
|
|
135
|
+
def _docket_ids(value, limit):
|
|
136
|
+
"""A batch's docket ids: 1..``limit`` integers (duplicates dropped,
|
|
137
|
+
order kept)."""
|
|
138
|
+
if not isinstance(value, list) or not value:
|
|
139
|
+
raise _Refusal(
|
|
140
|
+
BAD_REQUEST,
|
|
141
|
+
[{"code": "dockets", "text": "Say which dockets to print."}],
|
|
142
|
+
)
|
|
143
|
+
if len(value) > limit:
|
|
144
|
+
raise _Refusal(
|
|
145
|
+
BAD_REQUEST,
|
|
146
|
+
[{"code": "dockets", "text": f"Print at most {limit} at a time."}],
|
|
147
|
+
)
|
|
148
|
+
out, seen = [], set()
|
|
149
|
+
for item in value:
|
|
150
|
+
if isinstance(item, bool) or not isinstance(item, (int, str)):
|
|
151
|
+
raise _Refusal(
|
|
152
|
+
BAD_REQUEST, [{"code": "dockets", "text": "dockets must be ids."}]
|
|
153
|
+
)
|
|
154
|
+
text = str(item).strip()
|
|
155
|
+
if not _ID.fullmatch(text):
|
|
156
|
+
raise _Refusal(
|
|
157
|
+
BAD_REQUEST, [{"code": "dockets", "text": "dockets must be ids."}]
|
|
158
|
+
)
|
|
159
|
+
ident = int(text)
|
|
160
|
+
if ident not in seen:
|
|
161
|
+
seen.add(ident)
|
|
162
|
+
out.append(ident)
|
|
163
|
+
return out
|
|
164
|
+
|
|
165
|
+
|
|
118
166
|
class _Refusal(Exception):
|
|
119
167
|
def __init__(self, status, reasons):
|
|
120
168
|
super().__init__(status)
|
|
@@ -669,6 +717,301 @@ class WorkflowMixin:
|
|
|
669
717
|
|
|
670
718
|
self._wf_guarded(tx, context, work)
|
|
671
719
|
|
|
720
|
+
# ── printing (the traveler) ────────────────────────────────────────────
|
|
721
|
+
|
|
722
|
+
# where the traveler's QR code points, after the site URL ("{id}": the
|
|
723
|
+
# docket's id)
|
|
724
|
+
workflow_docket_path = "/app/docket/{id}"
|
|
725
|
+
# the largest PDF answered (base64 adds a third: under the 6 MB a
|
|
726
|
+
# Lambda response may carry)
|
|
727
|
+
workflow_traveler_max_bytes = 4_000_000
|
|
728
|
+
|
|
729
|
+
def workflow_site_url(self, tx, context):
|
|
730
|
+
"""The site's URL the traveler's QR code opens (the ``SiteUrl``
|
|
731
|
+
configuration key, SSM first). None: no QR code."""
|
|
732
|
+
from velocity.aws import ssm_config
|
|
733
|
+
|
|
734
|
+
return ssm_config.getenv("SiteUrl")
|
|
735
|
+
|
|
736
|
+
def workflow_pdf(self, html):
|
|
737
|
+
"""The PDF bytes of a traveler's HTML (override to change the page
|
|
738
|
+
or the engine); :func:`velocity.workflow.traveler.to_pdf` by
|
|
739
|
+
default: ``html_to_pdf``, fetching nothing external."""
|
|
740
|
+
return _workflow().traveler.to_pdf(html)
|
|
741
|
+
|
|
742
|
+
def _wf_site_url(self, tx, context):
|
|
743
|
+
try:
|
|
744
|
+
value = self.workflow_site_url(tx, context)
|
|
745
|
+
except Exception:
|
|
746
|
+
logger.warning("workflow: SiteUrl could not be read", exc_info=True)
|
|
747
|
+
return None
|
|
748
|
+
text = str(value or "").strip().rstrip("/")
|
|
749
|
+
if not text:
|
|
750
|
+
return None
|
|
751
|
+
if not _SITE_URL.match(text):
|
|
752
|
+
logger.warning("workflow: SiteUrl is not an http(s) URL; no QR code")
|
|
753
|
+
return None
|
|
754
|
+
return text
|
|
755
|
+
|
|
756
|
+
def _wf_docket_path(self):
|
|
757
|
+
path = str(self.workflow_docket_path or "")
|
|
758
|
+
if not _DOCKET_PATH.match(path) or "{id}" not in path:
|
|
759
|
+
logger.warning("workflow: workflow_docket_path is invalid; default used")
|
|
760
|
+
return _workflow().traveler.DEFAULT_PATH
|
|
761
|
+
return path
|
|
762
|
+
|
|
763
|
+
def _wf_print_kind(self, payload):
|
|
764
|
+
wf = _workflow()
|
|
765
|
+
kind = (payload or {}).get("kind")
|
|
766
|
+
if kind is None:
|
|
767
|
+
kind = wf.traveler.DEFAULT_KIND
|
|
768
|
+
found = (
|
|
769
|
+
wf.hooks.traveler(kind)
|
|
770
|
+
if isinstance(kind, str) and wf.hooks.CODE.match(kind)
|
|
771
|
+
else None
|
|
772
|
+
)
|
|
773
|
+
if found is None:
|
|
774
|
+
raise _Refusal(
|
|
775
|
+
BAD_REQUEST,
|
|
776
|
+
[
|
|
777
|
+
{
|
|
778
|
+
"code": "kind",
|
|
779
|
+
"text": "That is not a kind of paper this site prints.",
|
|
780
|
+
}
|
|
781
|
+
],
|
|
782
|
+
)
|
|
783
|
+
return found
|
|
784
|
+
|
|
785
|
+
def _wf_printable(self, tx, context, docket_id, principal, seats):
|
|
786
|
+
"""The docket as the viewer sees it (refused, exactly like the
|
|
787
|
+
docket view, when they may not see it), the viewer, and the
|
|
788
|
+
stations of its open positions."""
|
|
789
|
+
wf = _workflow()
|
|
790
|
+
try:
|
|
791
|
+
docket, route = self._wf_docket(tx, {"docket": docket_id})
|
|
792
|
+
except wf.WorkflowError:
|
|
793
|
+
# a route that cannot be read says no more than a missing docket
|
|
794
|
+
raise AccessError(authz.REFUSED) from None
|
|
795
|
+
viewer = self._wf_viewer(tx, context, docket, route, principal, seats)
|
|
796
|
+
body = wf.contract.build_docket(tx, docket["sys_id"], viewer)
|
|
797
|
+
body["entity"] = docket.get("entity")
|
|
798
|
+
# what the viewer may read beyond the flow, decided like the docket
|
|
799
|
+
# view's own cuts (site templates ask this, never permissions alone)
|
|
800
|
+
body["readable"] = wf.contract.readable(tx, docket["sys_id"], viewer)
|
|
801
|
+
stations = {
|
|
802
|
+
p["station"]
|
|
803
|
+
for p in body.get("positions") or ()
|
|
804
|
+
if p.get("state") in wf.engine.OPEN_STATES
|
|
805
|
+
}
|
|
806
|
+
return body, viewer, stations
|
|
807
|
+
|
|
808
|
+
def _wf_print_actor(self, tx, principal, seats):
|
|
809
|
+
"""Who the print mark names: the person, or in a masquerade session
|
|
810
|
+
the real person acting as them (never the impersonated one). The
|
|
811
|
+
real identity is the mark's ``actor`` (the audit record); the name
|
|
812
|
+
every viewer of the timeline reads is "An administrator (acting as
|
|
813
|
+
<name>)", never the administrator's address. A masquerade with no
|
|
814
|
+
real identity prints nothing."""
|
|
815
|
+
wf = _workflow()
|
|
816
|
+
if not self._wf_masquerading(principal):
|
|
817
|
+
return wf.engine.Actor.person(seats), None
|
|
818
|
+
real = principal.real_user
|
|
819
|
+
real = " ".join(str(real).split())[:120] if real is not True else ""
|
|
820
|
+
if not real:
|
|
821
|
+
raise AccessError(authz.REFUSED)
|
|
822
|
+
shown = seats.name or wf.hooks.person_label(tx, seats.person)
|
|
823
|
+
return (
|
|
824
|
+
wf.engine.Actor(
|
|
825
|
+
"person",
|
|
826
|
+
f"masquerade:{real}",
|
|
827
|
+
f"An administrator (acting as {shown})",
|
|
828
|
+
),
|
|
829
|
+
real,
|
|
830
|
+
)
|
|
831
|
+
|
|
832
|
+
def _wf_print(self, tx, context, principal, seats, kind, ids, *, single):
|
|
833
|
+
"""Draw ``ids`` (in order) as ``kind``, convert to PDF, and record a
|
|
834
|
+
print mark on every docket printed."""
|
|
835
|
+
import base64
|
|
836
|
+
|
|
837
|
+
wf = _workflow()
|
|
838
|
+
printed_at = _now()
|
|
839
|
+
dockets, viewers, refused = [], [], []
|
|
840
|
+
for ident in ids:
|
|
841
|
+
try:
|
|
842
|
+
body, viewer, stations = self._wf_printable(
|
|
843
|
+
tx, context, ident, principal, seats
|
|
844
|
+
)
|
|
845
|
+
except AccessError:
|
|
846
|
+
if single:
|
|
847
|
+
raise
|
|
848
|
+
# not visible and not there print the same: restricted
|
|
849
|
+
dockets.append(None)
|
|
850
|
+
continue
|
|
851
|
+
if not kind.applies_to(stations):
|
|
852
|
+
refused.append(body.get("number") or str(body["id"]))
|
|
853
|
+
dockets.append(body)
|
|
854
|
+
viewers.append(viewer)
|
|
855
|
+
if refused:
|
|
856
|
+
where = ", ".join(sorted(kind.stations or ()))
|
|
857
|
+
raise _Refusal(
|
|
858
|
+
CONFLICT,
|
|
859
|
+
[
|
|
860
|
+
{
|
|
861
|
+
"code": "not_applicable",
|
|
862
|
+
"text": (
|
|
863
|
+
f"{kind.label} prints only at {where}: "
|
|
864
|
+
+ ", ".join(refused[:10])
|
|
865
|
+
+ (" and more" if len(refused) > 10 else "")
|
|
866
|
+
+ "."
|
|
867
|
+
),
|
|
868
|
+
}
|
|
869
|
+
],
|
|
870
|
+
)
|
|
871
|
+
actor, real = self._wf_print_actor(tx, principal, seats)
|
|
872
|
+
printed_for = seats.name or wf.hooks.person_label(tx, seats.person)
|
|
873
|
+
print_context = wf.traveler.PrintContext(
|
|
874
|
+
kind=kind.kind,
|
|
875
|
+
label=kind.label,
|
|
876
|
+
printed_at=printed_at,
|
|
877
|
+
printed_for=printed_for,
|
|
878
|
+
printed_by=real or printed_for,
|
|
879
|
+
masquerade=real is not None,
|
|
880
|
+
site_url=self._wf_site_url(tx, context),
|
|
881
|
+
docket_path=self._wf_docket_path(),
|
|
882
|
+
restricted=sum(1 for d in dockets if d is None),
|
|
883
|
+
request=context,
|
|
884
|
+
)
|
|
885
|
+
viewer = (
|
|
886
|
+
viewers[0]
|
|
887
|
+
if single
|
|
888
|
+
else wf.contract.Viewer(
|
|
889
|
+
seats=seats,
|
|
890
|
+
principal=principal,
|
|
891
|
+
view_decider=self._wf_decider(context),
|
|
892
|
+
)
|
|
893
|
+
)
|
|
894
|
+
html = wf.traveler.render_html(tx, kind, dockets, viewer, print_context)
|
|
895
|
+
try:
|
|
896
|
+
pdf = self.workflow_pdf(html)
|
|
897
|
+
except (ImportError, OSError, RuntimeError, ValueError):
|
|
898
|
+
logger.warning("workflow: traveler PDF failed", exc_info=True)
|
|
899
|
+
raise _Refusal(
|
|
900
|
+
503,
|
|
901
|
+
[
|
|
902
|
+
{
|
|
903
|
+
"code": "pdf_unavailable",
|
|
904
|
+
"text": "Printing is not available right now.",
|
|
905
|
+
}
|
|
906
|
+
],
|
|
907
|
+
) from None
|
|
908
|
+
if not isinstance(pdf, (bytes, bytearray)):
|
|
909
|
+
raise _Refusal(
|
|
910
|
+
503,
|
|
911
|
+
[
|
|
912
|
+
{
|
|
913
|
+
"code": "pdf_unavailable",
|
|
914
|
+
"text": "Printing is not available right now.",
|
|
915
|
+
}
|
|
916
|
+
],
|
|
917
|
+
)
|
|
918
|
+
if len(pdf) > int(self.workflow_traveler_max_bytes):
|
|
919
|
+
raise _Refusal(
|
|
920
|
+
413,
|
|
921
|
+
[
|
|
922
|
+
{
|
|
923
|
+
"code": "too_large",
|
|
924
|
+
"text": "That is too much to print at once; print fewer.",
|
|
925
|
+
}
|
|
926
|
+
],
|
|
927
|
+
)
|
|
928
|
+
printed = [d for d in dockets if d is not None]
|
|
929
|
+
for body in printed:
|
|
930
|
+
wf.engine.record_print(tx, body["id"], actor, kind.kind, now=printed_at)
|
|
931
|
+
return {
|
|
932
|
+
"ok": True,
|
|
933
|
+
"filename": wf.traveler.filename(kind.kind, dockets, printed_at),
|
|
934
|
+
"content_type": "application/pdf",
|
|
935
|
+
"data_base64": base64.b64encode(bytes(pdf)).decode("ascii"),
|
|
936
|
+
"printed": len(printed),
|
|
937
|
+
"restricted": print_context.restricted,
|
|
938
|
+
}
|
|
939
|
+
|
|
940
|
+
def OnActionWorkflowTraveler(self, tx, context):
|
|
941
|
+
payload = context.payload() or {}
|
|
942
|
+
principal = self._wf_principal(context)
|
|
943
|
+
seats = self._wf_seats(tx, context, principal)
|
|
944
|
+
|
|
945
|
+
def work():
|
|
946
|
+
kind = self._wf_print_kind(payload)
|
|
947
|
+
body = self._wf_print(
|
|
948
|
+
tx,
|
|
949
|
+
context,
|
|
950
|
+
principal,
|
|
951
|
+
seats,
|
|
952
|
+
kind,
|
|
953
|
+
[payload.get("docket")],
|
|
954
|
+
single=True,
|
|
955
|
+
)
|
|
956
|
+
context.response().set_body(body)
|
|
957
|
+
|
|
958
|
+
self._wf_guarded(tx, context, work)
|
|
959
|
+
|
|
960
|
+
def OnActionWorkflowTravelers(self, tx, context):
|
|
961
|
+
wf = _workflow()
|
|
962
|
+
payload = context.payload() or {}
|
|
963
|
+
principal = self._wf_principal(context)
|
|
964
|
+
authz.require(self, tx, context, wf.access.TRAY)
|
|
965
|
+
seats = self._wf_seats(tx, context, principal)
|
|
966
|
+
|
|
967
|
+
def work():
|
|
968
|
+
kind = self._wf_print_kind(payload)
|
|
969
|
+
ids = _docket_ids(payload.get("dockets"), wf.traveler.MAX_BATCH)
|
|
970
|
+
body = self._wf_print(
|
|
971
|
+
tx, context, principal, seats, kind, ids, single=False
|
|
972
|
+
)
|
|
973
|
+
context.response().set_body(body)
|
|
974
|
+
|
|
975
|
+
self._wf_guarded(tx, context, work)
|
|
976
|
+
|
|
977
|
+
def OnActionWorkflowTravelerKinds(self, tx, context):
|
|
978
|
+
wf = _workflow()
|
|
979
|
+
payload = context.payload() or {}
|
|
980
|
+
principal = self._wf_principal(context)
|
|
981
|
+
authz.require(self, tx, context, wf.access.TRAY)
|
|
982
|
+
seats = self._wf_seats(tx, context, principal)
|
|
983
|
+
|
|
984
|
+
def work():
|
|
985
|
+
kinds = wf.hooks.travelers()
|
|
986
|
+
if payload.get("docket") is not None:
|
|
987
|
+
docket, route = self._wf_docket(tx, payload)
|
|
988
|
+
relations = wf.access.view_relations(tx, docket, route, seats)
|
|
989
|
+
self._wf_require(tx, context, wf.access.VIEW, docket, relations)
|
|
990
|
+
stations = {
|
|
991
|
+
p["station"]
|
|
992
|
+
for p in wf.engine.positions_of(
|
|
993
|
+
tx, docket["sys_id"], open_only=True
|
|
994
|
+
)
|
|
995
|
+
}
|
|
996
|
+
kinds = [k for k in kinds if k.applies_to(stations)]
|
|
997
|
+
context.response().set_body(
|
|
998
|
+
{
|
|
999
|
+
"kinds": [
|
|
1000
|
+
{
|
|
1001
|
+
"kind": k.kind,
|
|
1002
|
+
"label": k.label,
|
|
1003
|
+
"batch": k.batch is not None,
|
|
1004
|
+
"stations": (
|
|
1005
|
+
sorted(k.stations) if k.stations is not None else None
|
|
1006
|
+
),
|
|
1007
|
+
}
|
|
1008
|
+
for k in kinds
|
|
1009
|
+
]
|
|
1010
|
+
}
|
|
1011
|
+
)
|
|
1012
|
+
|
|
1013
|
+
self._wf_guarded(tx, context, work)
|
|
1014
|
+
|
|
672
1015
|
# ── leading a station ──────────────────────────────────────────────────
|
|
673
1016
|
|
|
674
1017
|
def _wf_lead_write(self, tx, context, payload, principal, seats, kind, write):
|
velocity/misc/pdf.py
CHANGED
|
@@ -6,7 +6,7 @@ Public surface
|
|
|
6
6
|
``html_to_pdf(html, **page_options)`` — the facade every consumer should call.
|
|
7
7
|
It picks a renderer (see *Engine selection*) and returns PDF bytes. Keywords:
|
|
8
8
|
``page_size``, ``orientation``, ``margin*``, ``footer_*``, ``engine``,
|
|
9
|
-
``base_url``, ``extra_css``.
|
|
9
|
+
``base_url``, ``extra_css``, ``offline``.
|
|
10
10
|
|
|
11
11
|
``BasePdfRenderer`` — the adapter interface. A renderer turns
|
|
12
12
|
``(html, PageOptions, base_url, extra_css)`` into bytes. One ships here:
|
|
@@ -46,6 +46,7 @@ Usage::
|
|
|
46
46
|
|
|
47
47
|
from __future__ import annotations
|
|
48
48
|
|
|
49
|
+
import inspect
|
|
49
50
|
import logging
|
|
50
51
|
import os
|
|
51
52
|
import re
|
|
@@ -232,7 +233,7 @@ class WeasyPrintRenderer(BasePdfRenderer):
|
|
|
232
233
|
def available(self) -> bool:
|
|
233
234
|
return _load_weasyprint() is not None
|
|
234
235
|
|
|
235
|
-
def render(self, html, page, *, base_url=None, extra_css=None):
|
|
236
|
+
def render(self, html, page, *, base_url=None, extra_css=None, offline=False):
|
|
236
237
|
weasyprint = _load_weasyprint()
|
|
237
238
|
if weasyprint is None:
|
|
238
239
|
raise ImportError(
|
|
@@ -246,13 +247,28 @@ class WeasyPrintRenderer(BasePdfRenderer):
|
|
|
246
247
|
if extra_css:
|
|
247
248
|
css_text += "\n" + extra_css
|
|
248
249
|
try:
|
|
249
|
-
|
|
250
|
+
options = {"string": html, "base_url": base_url}
|
|
251
|
+
if offline:
|
|
252
|
+
options["url_fetcher"] = _offline_fetcher(weasyprint)
|
|
253
|
+
document = weasyprint.HTML(**options)
|
|
250
254
|
return document.write_pdf(stylesheets=[weasyprint.CSS(string=css_text)])
|
|
251
255
|
except Exception as exc:
|
|
252
256
|
logger.exception("WeasyPrint PDF generation failed")
|
|
253
257
|
raise RuntimeError(f"PDF generation failed: {exc}") from exc
|
|
254
258
|
|
|
255
259
|
|
|
260
|
+
def _offline_fetcher(weasyprint):
|
|
261
|
+
"""A WeasyPrint ``url_fetcher`` that loads only inline ``data:`` URIs:
|
|
262
|
+
nothing in the document reaches the network or the file system."""
|
|
263
|
+
|
|
264
|
+
def fetch(url, *args, **kwargs):
|
|
265
|
+
if str(url).startswith("data:"):
|
|
266
|
+
return weasyprint.default_url_fetcher(url, *args, **kwargs)
|
|
267
|
+
raise ValueError("an offline PDF loads no external resources")
|
|
268
|
+
|
|
269
|
+
return fetch
|
|
270
|
+
|
|
271
|
+
|
|
256
272
|
# ── Registry + facade ──────────────────────────────────────────────────────────
|
|
257
273
|
|
|
258
274
|
#: Preference order for auto-selection.
|
|
@@ -319,10 +335,14 @@ def html_to_pdf(
|
|
|
319
335
|
engine: Optional[str] = None,
|
|
320
336
|
base_url: Optional[str] = None,
|
|
321
337
|
extra_css: Optional[str] = None,
|
|
338
|
+
offline: bool = False,
|
|
322
339
|
) -> bytes:
|
|
323
340
|
"""Convert an HTML string to PDF bytes via the selected renderer.
|
|
324
341
|
|
|
325
|
-
See the module docstring for engine selection.
|
|
342
|
+
See the module docstring for engine selection. ``offline=True`` loads no
|
|
343
|
+
external resource the HTML names (only inline ``data:`` URIs): for
|
|
344
|
+
documents built from stored data. A renderer that cannot promise that
|
|
345
|
+
is refused (``ValueError``).
|
|
326
346
|
"""
|
|
327
347
|
page = PageOptions(
|
|
328
348
|
page_size=page_size,
|
|
@@ -336,8 +356,17 @@ def html_to_pdf(
|
|
|
336
356
|
footer_center=footer_center,
|
|
337
357
|
footer_font_size=footer_font_size,
|
|
338
358
|
)
|
|
339
|
-
|
|
340
|
-
|
|
359
|
+
renderer = get_renderer(engine)
|
|
360
|
+
if not offline:
|
|
361
|
+
return renderer.render(html, page, base_url=base_url, extra_css=extra_css)
|
|
362
|
+
try:
|
|
363
|
+
takes_offline = "offline" in inspect.signature(renderer.render).parameters
|
|
364
|
+
except (TypeError, ValueError):
|
|
365
|
+
takes_offline = False
|
|
366
|
+
if not takes_offline:
|
|
367
|
+
raise ValueError(f"the {renderer.name!r} PDF engine cannot render offline")
|
|
368
|
+
return renderer.render(
|
|
369
|
+
html, page, base_url=base_url, extra_css=extra_css, offline=True
|
|
341
370
|
)
|
|
342
371
|
|
|
343
372
|
|