Repository navigation
Expand file tree
/
Copy pathREADME.html
More file actions
1812 lines (1686 loc) · 162 KB
/
Copy pathREADME.html
File metadata and controls
1812 lines (1686 loc) · 162 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>README Preview</title>
<link rel="stylesheet" href="https://github.githubassets.com/assets/github-markdown.css">
<style>
body {
box-sizing: border-box;
min-width: 200px;
max-width: 980px;
margin: 0 auto;
padding: 45px;
}
.markdown-body {
font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
}
pre { line-height: 125%; }
td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
.highlight .hll { background-color: #49483e }
.highlight { background: #272822; color: #F8F8F2 }
.highlight .c { color: #959077 } /* Comment */
.highlight .err { color: #ED007E; background-color: #1E0010 } /* Error */
.highlight .esc { color: #F8F8F2 } /* Escape */
.highlight .g { color: #F8F8F2 } /* Generic */
.highlight .k { color: #66D9EF } /* Keyword */
.highlight .l { color: #AE81FF } /* Literal */
.highlight .n { color: #F8F8F2 } /* Name */
.highlight .o { color: #FF4689 } /* Operator */
.highlight .x { color: #F8F8F2 } /* Other */
.highlight .p { color: #F8F8F2 } /* Punctuation */
.highlight .ch { color: #959077 } /* Comment.Hashbang */
.highlight .cm { color: #959077 } /* Comment.Multiline */
.highlight .cp { color: #959077 } /* Comment.Preproc */
.highlight .cpf { color: #959077 } /* Comment.PreprocFile */
.highlight .c1 { color: #959077 } /* Comment.Single */
.highlight .cs { color: #959077 } /* Comment.Special */
.highlight .gd { color: #FF4689 } /* Generic.Deleted */
.highlight .ge { color: #F8F8F2; font-style: italic } /* Generic.Emph */
.highlight .ges { color: #F8F8F2; font-weight: bold; font-style: italic } /* Generic.EmphStrong */
.highlight .gr { color: #F8F8F2 } /* Generic.Error */
.highlight .gh { color: #F8F8F2 } /* Generic.Heading */
.highlight .gi { color: #A6E22E } /* Generic.Inserted */
.highlight .go { color: #66D9EF } /* Generic.Output */
.highlight .gp { color: #FF4689; font-weight: bold } /* Generic.Prompt */
.highlight .gs { color: #F8F8F2; font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #959077 } /* Generic.Subheading */
.highlight .gt { color: #F8F8F2 } /* Generic.Traceback */
.highlight .kc { color: #66D9EF } /* Keyword.Constant */
.highlight .kd { color: #66D9EF } /* Keyword.Declaration */
.highlight .kn { color: #FF4689 } /* Keyword.Namespace */
.highlight .kp { color: #66D9EF } /* Keyword.Pseudo */
.highlight .kr { color: #66D9EF } /* Keyword.Reserved */
.highlight .kt { color: #66D9EF } /* Keyword.Type */
.highlight .ld { color: #E6DB74 } /* Literal.Date */
.highlight .m { color: #AE81FF } /* Literal.Number */
.highlight .s { color: #E6DB74 } /* Literal.String */
.highlight .na { color: #A6E22E } /* Name.Attribute */
.highlight .nb { color: #F8F8F2 } /* Name.Builtin */
.highlight .nc { color: #A6E22E } /* Name.Class */
.highlight .no { color: #66D9EF } /* Name.Constant */
.highlight .nd { color: #A6E22E } /* Name.Decorator */
.highlight .ni { color: #F8F8F2 } /* Name.Entity */
.highlight .ne { color: #A6E22E } /* Name.Exception */
.highlight .nf { color: #A6E22E } /* Name.Function */
.highlight .nl { color: #F8F8F2 } /* Name.Label */
.highlight .nn { color: #F8F8F2 } /* Name.Namespace */
.highlight .nx { color: #A6E22E } /* Name.Other */
.highlight .py { color: #F8F8F2 } /* Name.Property */
.highlight .nt { color: #FF4689 } /* Name.Tag */
.highlight .nv { color: #F8F8F2 } /* Name.Variable */
.highlight .ow { color: #FF4689 } /* Operator.Word */
.highlight .pm { color: #F8F8F2 } /* Punctuation.Marker */
.highlight .w { color: #F8F8F2 } /* Text.Whitespace */
.highlight .mb { color: #AE81FF } /* Literal.Number.Bin */
.highlight .mf { color: #AE81FF } /* Literal.Number.Float */
.highlight .mh { color: #AE81FF } /* Literal.Number.Hex */
.highlight .mi { color: #AE81FF } /* Literal.Number.Integer */
.highlight .mo { color: #AE81FF } /* Literal.Number.Oct */
.highlight .sa { color: #E6DB74 } /* Literal.String.Affix */
.highlight .sb { color: #E6DB74 } /* Literal.String.Backtick */
.highlight .sc { color: #E6DB74 } /* Literal.String.Char */
.highlight .dl { color: #E6DB74 } /* Literal.String.Delimiter */
.highlight .sd { color: #E6DB74 } /* Literal.String.Doc */
.highlight .s2 { color: #E6DB74 } /* Literal.String.Double */
.highlight .se { color: #AE81FF } /* Literal.String.Escape */
.highlight .sh { color: #E6DB74 } /* Literal.String.Heredoc */
.highlight .si { color: #E6DB74 } /* Literal.String.Interpol */
.highlight .sx { color: #E6DB74 } /* Literal.String.Other */
.highlight .sr { color: #E6DB74 } /* Literal.String.Regex */
.highlight .s1 { color: #E6DB74 } /* Literal.String.Single */
.highlight .ss { color: #E6DB74 } /* Literal.String.Symbol */
.highlight .bp { color: #F8F8F2 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #A6E22E } /* Name.Function.Magic */
.highlight .vc { color: #F8F8F2 } /* Name.Variable.Class */
.highlight .vg { color: #F8F8F2 } /* Name.Variable.Global */
.highlight .vi { color: #F8F8F2 } /* Name.Variable.Instance */
.highlight .vm { color: #F8F8F2 } /* Name.Variable.Magic */
.highlight .il { color: #AE81FF } /* Literal.Number.Integer.Long */
</style>
</head>
<body>
<article class="markdown-body">
<div class="toc"><div class="toc">
<ul>
<li><a href="#learning-xslt-with-python">Learning XSLT with Python</a></li>
<li><a href="#background-a-tale-of-two-philosophies">Background: A Tale of Two Philosophies</a><ul>
<li><a href="#quick-start">Quick Start</a><ul>
<li><a href="#testing-xpath-patterns">Testing XPath Patterns</a></li>
<li><a href="#evaluating-xslt-programs">Evaluating XSLT programs</a></li>
<li><a href="#testing-schemas">Testing Schemas</a></li>
</ul>
</li>
<li><a href="#thinking-in-trees-a-new-paradigm-for-python-developers">Thinking in Trees: A New Paradigm for Python Developers</a><ul>
<li><a href="#build-a-custom-professor">Build a Custom Professor</a></li>
<li><a href="#hack-to-learn-workflow">Hack-to-Learn Workflow</a></li>
<li><a href="#recommended-curriculum">Recommended Curriculum</a></li>
<li><a href="#build-an-amoury">Build an Amoury</a></li>
<li><a href="#understanding-xslts-default-behavior-and-why-its-so-confusing">Understanding XSLT's Default Behavior (And Why It's So Confusing)</a><ul>
<li><a href="#how-to-take-back-control">How to Take Back Control</a></li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
<li><a href="#installation-instructions">Installation Instructions</a></li>
<li><a href="#running-examples">Running Examples</a><ul>
<li><a href="#how-to-run-specific-examples">How to Run Specific Examples</a></li>
<li><a href="#running-your-own-examples">Running Your Own Examples</a></li>
<li><a href="#json-transform-example-1">JSON Transform Example 1</a></li>
<li><a href="#json-transform-example-2">JSON Transform Example 2</a></li>
</ul>
</li>
<li><a href="#integrating-xslt-30-with-python-in-the-main-thread">Integrating XSLT 3.0 with Python in the main thread</a></li>
<li><a href="#integrating-xslt-30-with-multithreaded-python">Integrating XSLT 3.0 with Multithreaded Python</a></li>
<li><a href="#xml-schemas">XML Schemas</a><ul>
<li><a href="#unspecified-xml-leads-to-disaster-its-a-timebomb">Unspecified XML Leads to Disaster (It's a timebomb)</a></li>
<li><a href="#a-brilliant-trap-the-saxon-give-them-enough-rope-business-model">A Brilliant Trap: The Saxon "Give Them Enough Rope" Business Model</a></li>
<li><a href="#schema-technologies">Schema Technologies</a><ul>
<li><a href="#dtd-document-type-definition">DTD (Document Type Definition)</a></li>
<li><a href="#xds-10">XDS 1.0</a></li>
<li><a href="#relax-ng">RELAX NG</a></li>
<li><a href="#schematron">Schematron</a></li>
<li><a href="#xds-11">XDS 1.1</a></li>
</ul>
</li>
<li><a href="#xds-11-cli-and-training">XDS 1.1 CLI and Training</a></li>
<li><a href="#schematron-cli-and-training">Schematron CLI and Training</a></li>
<li><a href="#xds-11-python-integration">XDS 1.1 Python Integration</a></li>
<li><a href="#scematron-python-integration">Scematron Python Integration</a></li>
<li><a href="#embracing-the-necessary-pain-of-xml-namespaces">Embracing the Necessary Pain of XML Namespaces</a></li>
</ul>
</li>
<li><a href="#testing-xpath">Testing XPath</a></li>
<li><a href="#testing-xpath-axis-features">Testing XPath Axis Features</a></li>
<li><a href="#prototyping-your-xsltxpath-code-in-python">Prototyping your XSLT/XPATH code in Python</a></li>
<li><a href="#useful-links">Useful links</a></li>
</ul>
</div>
</div>
<h1 id="learning-xslt-with-python">Learning XSLT with Python</h1>
<p>This repository is a playground for exploring XSLT, a powerful functional
language for data transformation, from within a modern Python environment. It
provides a declarative, "single-step" paradigm for tackling complex data
plumbing challenges in a way that is fundamentally different from traditional
imperative code.</p>
<p>Here you can learn and experiment with XSLT via the command line, using tools and examples for:</p>
<ul>
<li>Building and debugging XSLT stylesheets.</li>
<li>Validating XML using XDS 1.1 and Schematron.</li>
<li>Testing XPath 3.1 expressions.</li>
<li>Connecting with key training resources (e.g., Michael Kay’s books).</li>
</ul>
<p>The project leverages modern Python libraries like <code>lxml</code> (for <code>XSLT 1.0</code>)
and <code>saxonche</code> (for <code>XSLT +3.0</code>), which adds advanced features like
streaming and native JSON handling.</p>
<h1 id="background-a-tale-of-two-philosophies">Background: A Tale of Two Philosophies</h1>
<p>The histories of Python and XSLT offer a compelling study in how technologies
are shaped. Python's development was famously practitioner-led by Guido van
Rossum, fostering a pragmatic culture that valued <a href="https://www.youtube.com/watch?v=GfH4QL4VqJ0">developer happiness</a>. Its
evolution via the community-driven <a href="https://peps.python.org/pep-0001/">PEP process</a> meant it was built by and for
programmers. In stark contrast, XSLT was born from a top-down W3C committee of
architects. The result was a language that was formally powerful but actively
hostile to the sensibilities of the average developer, burdened by a punishingly
verbose XML-based syntax and a steep, declarative-functional learning curve that
felt extraterrestrial to most practitioners.</p>
<p>This difference had profound consequences and directly explains why XSLT fell
into mainstream obscurity. While Python's flexibility allowed it to find a
"killer app" by <a href="https://www.youtube.com/watch?v=AyenRCJ_4Ww">borg'ing</a> the
scientific world of MATLAB, XSLT's rigidity and poor ergonomics actively
repelled the fast-growing world of web development. As web APIs moved towards
the lightweight, brain-dead simple JSON format, XSLT's heavyweight,
document-centric model felt like using a sledgehammer to crack a nut. While its
champion, Michael Kay, was quietly perfecting it over decades, into a masterpiece
of engineering. The mainstream war had already been lost to tools that were
simply easier, faster, and more enjoyable to use.</p>
<p>Today, however, these two histories have converged. With the advent of libraries
like saxonche, XSLT has effectively borg'd itself into the Python ecosystem,
not as a competitor, but as a specialized engine for the kind of complex data
plumbing it was designed for. Freed from having to be a general-purpose tool,
its difficult nature is less of a barrier. It allows developers to use the right
tool for the job: Python for orchestration, and XSLT for the powerful, if
sometimes brutal, rule-based data transformations at which it remains unmatched.</p>
<h2 id="quick-start">Quick Start</h2>
<p>Clone the repo:</p>
<div class="codehilite"><pre><span></span><code>git<span class="w"> </span>clone<span class="w"> </span>https://github.com/aleph2c/learning_xslt_with_python.git
<span class="nb">cd</span><span class="w"> </span>learning_xslt_with_python
pip<span class="w"> </span>install<span class="w"> </span>-e<span class="w"> </span>.
<span class="nb">source</span><span class="w"> </span>venv/bin/activate
xslt<span class="w"> </span>install-compiler-errors<span class="w"> </span><span class="c1"># installs Java version of sachonche</span>
</code></pre></div>
<h3 id="testing-xpath-patterns">Testing XPath Patterns</h3>
<p>XSLT's power comes from XPath, which uses <strong>axes</strong> like <code>child::</code>,
<code>parent::</code>, and <code>ancestor::</code> to navigate the XML tree. The diagram below
illustrates these relationships. You can experiment with them by running your
own XPath expressions against the corresponding /patterns/axis_testing.xml file,
which represents this exact tree structure.</p>
<p><img alt="xpath 2" src="patterns/xpath_2.svg" /></p>
<p>To see the entire XML file, we could set the context to the "root" node then match
against everything in the document:</p>
<div class="codehilite"><pre><span></span><code>try<span class="w"> </span>-d<span class="w"> </span>patterns/<span class="w"> </span>xpath<span class="w"> </span>-x<span class="s2">"axis_testing.xml"</span><span class="w"> </span>-c<span class="s2">"/"</span><span class="w"> </span>-p<span class="s2">"*"</span>
context:<span class="w"> </span>/
<A<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"1"</span>>
<span class="w"> </span><B<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"2"</span>>
<span class="w"> </span><C<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"3"</span>/>
<span class="w"> </span><D<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"4"</span>/>
<span class="w"> </span><E<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"5"</span>>
<span class="w"> </span><H<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"8"</span>>
<span class="w"> </span><M<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"13"</span>/>
<span class="w"> </span></H>
<span class="w"> </span><I<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"9"</span>/>
<span class="w"> </span><J<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"10"</span>>
<span class="w"> </span><N<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"14"</span>/>
<span class="w"> </span><O<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"15"</span>>
<span class="w"> </span><T<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"20"</span>/>
<span class="w"> </span><U<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"21"</span>/>
<span class="w"> </span></O>
<span class="w"> </span><P<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"16"</span>/>
<span class="w"> </span><Q<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"17"</span>/>
<span class="w"> </span><R<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"18"</span>>
<span class="w"> </span><V<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"22"</span>/>
<span class="w"> </span><W<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"23"</span>/>
<span class="w"> </span></R>
<span class="w"> </span></J>
<span class="w"> </span><K<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"11"</span>/>
<span class="w"> </span><L<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"12"</span>>
<span class="w"> </span><S<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"19"</span>/>
<span class="w"> </span></L>
<span class="w"> </span></E>
<span class="w"> </span><F<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"6"</span>/>
<span class="w"> </span><G<span class="w"> </span><span class="nv">id</span><span class="o">=</span><span class="s2">"7"</span>/>
<span class="w"> </span></B>
</A>
</code></pre></div>
<p>Now let's set <code>J</code> as the node context and perform our first axis experiment:</p>
<div class="codehilite"><pre><span></span><code>try xpath -c "//J" -p "self::*/name()"
context: //J
J
</code></pre></div>
<p>Since the command is lazy, we can query from the <code>J</code> context without
re-specifying it and look back at <code>J's</code> ancestors like this:</p>
<div class="codehilite"><pre><span></span><code>try xpath -p "ancestor::*/name()"
context: //J
J
"A"
"B"
"E"
</code></pre></div>
<blockquote>
<p><strong>Note</strong>
If you are parsing an <code>xhtml</code> doc include the <code>xhtml</code> namespace prefix in your query:
<code>try -d oneal xpath -x example.html -c "/" -p "//xhtml:h1[1]"</code></p>
</blockquote>
<h3 id="evaluating-xslt-programs">Evaluating XSLT programs</h3>
<p>To learn XSLT for transforming XML data, you can use this repository’s
command-line tools and XSLT compilers (installation instructions below). Suppose
you’re working through Chapter 7.4 of Sal Mangano’s XSLT Cookbook and have
transcribed the <code>text-hierarchy.xsl</code> example into
<code>sal/ch07/text-hierarchy.xsl</code>. You want to transform <code>books.xml</code> into
<code>text-hierarchy.txt</code> using this XSLT program.</p>
<p>To do this:</p>
<ul>
<li>Set the working directory as <code>sal/ch07</code>, and</li>
<li>Use the <code>text-hierarchy.xsl</code> XSLT program to transform <code>books.xml</code>.</li>
<li>Pass an <code>indent</code> parameter (four space) to control output formatting</li>
<li>Save the result to <code>text-hierarchy.txt</code> file.</li>
<li>Display verbose output (<code>-v</code>) for debugging.</li>
</ul>
<p>Run the following command:</p>
<div class="codehilite"><pre><span></span><code>try<span class="w"> </span>-d<span class="w"> </span>sal/ch07<span class="w"> </span>ex<span class="w"> </span><span class="se">\</span>
<span class="w"> </span>-x<span class="w"> </span>books.xml<span class="w"> </span><span class="se">\</span>
<span class="w"> </span>-p<span class="w"> </span>saxon<span class="w"> </span><span class="se">\</span>
<span class="w"> </span>-l<span class="w"> </span>text-hierarchy.xsl<span class="w"> </span><span class="se">\</span>
<span class="w"> </span>--params<span class="w"> </span><span class="s2">"indent=' '"</span><span class="w"> </span><span class="se">\</span>
<span class="w"> </span>-o<span class="w"> </span>text.hieracrhy.txt<span class="w"> </span><span class="se">\</span>
<span class="w"> </span>-v
</code></pre></div>
<p>If you’re learning XSLT, you might make mistakes in <code>text-hierarchy.xsl</code>. The
try command caches its inputs, so if you encounter compiler errors, you can edit
the XSLT file and re-run the transformation without retyping
the full command:</p>
<div class="codehilite"><pre><span></span><code>try<span class="w"> </span>ex<span class="w"> </span>-v
</code></pre></div>
<p>Repeat this cycle — edit <code>text-hierarchy.xsl</code>, run try ex -v, and check errors
— until your XSLT program produces the desired <code>text-hierarchy.txt</code> output.</p>
<h3 id="testing-schemas">Testing Schemas</h3>
<p>This training repo contains code and examples for testing the XDS 1.1 and
schematron XML schema technologies. (See <code>schema/xds1.1</code> and
<code>schema/schematron</code> for examples - (only support upto XSLT 2.0))</p>
<div class="codehilite"><pre><span></span><code>try<span class="w"> </span>-d<span class="w"> </span>schema/xsd1.1<span class="w"> </span>check<span class="w"> </span>-x<span class="w"> </span>validate_employees_1.xml<span class="w"> </span>exmployees_1.xsd
PASSED
try<span class="w"> </span>-d<span class="w"> </span>schema/schematron<span class="w"> </span>check<span class="w"> </span>-x<span class="w"> </span>valid_staff_1.xml<span class="w"> </span>staff_rules_1.sch
PASSED
</code></pre></div>
<h2 id="thinking-in-trees-a-new-paradigm-for-python-developers">Thinking in Trees: A New Paradigm for Python Developers</h2>
<p><strong>XSLT is a powerful, declarative language for transforming complex data
structures.</strong> While Python templating libraries like Jinja2 are excellent for
generating text from data, XSLT is a specialized tool designed for the
structural transformation of tree-like data such as XML and JSON.</p>
<p>The fundamental difference lies in its thinking model. Instead of writing
imperative Python code that loops through data, you write declarative XSLT
rules. You define what the output should look like for a given pattern, and the
XSLT processor, powered by the XPath query language, figures out how to apply
those rules across the entire document. This functional, rule-based approach can
be incredibly efficient for handling large or complex data streams.</p>
<p>Python supports XSLT through libraries like <code>lxml</code>, but this is limited to the
older, more basic XSLT 1.0 standard. This repository focuses on the modern XSLT
3.0 via the saxonche library, which provides full support for advanced features,
including native JSON handling.</p>
<p>Because this declarative, rule-based paradigm is so different from imperative
Python, learning it requires a new approach. This repository provides a complete
workflow to become fluent:</p>
<ol>
<li>Build a custom AI "Professor" to act as your personal tutor.</li>
<li>Follow a "hack-to-learn" workflow using the provided code examples.</li>
<li>Use a curated curriculum based on some classic XSLT texts.</li>
<li>Build an Amoury</li>
</ol>
<h3 id="build-a-custom-professor">Build a Custom Professor</h3>
<p>Copy the following markdown into a context file and feed it to the AI which is
training you. If you can't do that, just drop it into the AI's prompt. This
will provide a short hand to turn it into an excellent tutor.</p>
<div class="codehilite"><pre><span></span><code><span class="gh"># AI Interaction Modes for XSLT/XML Development</span>
This document outlines custom interaction modes for consulting on XSLT, XML, and XPath. These modes allow for switching response styles dynamically by using a prefix at the start of a message (e.g., <span class="sb">`TT:1 What is an atomic value?`</span>).
To exit any mode and return to the default, adaptive response style, use the prefix <span class="sb">`NN:`</span> or explicitly ask to leave the current mode.
<span class="gu">## Available Modes</span>
<span class="gu">### TT: Teacher Mode (Using Revised Bloom's Taxonomy)</span>
<span class="k">*</span><span class="w"> </span> <span class="gs">**Purpose**</span>: An educational style to help learn XSLT, XML, or XPath by building cognitive skills step-by-step. The mode focuses on one level of the taxonomy per query, providing prompts to evaluate and advance your understanding.
<span class="k">*</span><span class="w"> </span> <span class="gs">**Activation**</span>: Prefix with <span class="sb">`TT:X`</span>, where <span class="sb">`X`</span> is the level from 1 to 6. If no level is specified (<span class="sb">`TT:`</span>), the mode will default to level 1 or infer from the context.
<span class="k">*</span><span class="w"> </span> <span class="gs">**Levels (Revised Bloom's Taxonomy)**</span>:
<span class="w"> </span><span class="k">1.</span> <span class="gs">**Remembering (TT:1)**</span>: Recall facts and basic concepts. I'll ask questions like, "What is the difference between <span class="sb">`xsl:copy`</span> and <span class="sb">`xsl:copy-of`</span>?" or "What are the seven types of XML nodes?"
<span class="w"> </span><span class="k">2.</span> <span class="gs">**Understanding (TT:2)**</span>: Explain ideas or concepts. I'll ask for explanations like, "Can you describe what a sequence is in your own words?" or "Explain the purpose of the identity transform."
<span class="w"> </span><span class="k">3.</span> <span class="gs">**Applying (TT:3)**</span>: Use information in concrete situations. I'll provide scenarios like, "Show how you would use <span class="sb">`xsl:for-each-group`</span> to group these items by category."
<span class="w"> </span><span class="k">4.</span> <span class="gs">**Analyzing (TT:4)**</span>: Draw connections among ideas. I'll prompt analysis like, "Compare the built-in default templates to an explicit identity transform. What are the tradeoffs?"
<span class="w"> </span><span class="k">5.</span> <span class="gs">**Evaluating (TT:5)**</span>: Justify a stand or decision. I'll ask for critiques like, "Evaluate this template. Is there a more efficient or readable way to write it?"
<span class="w"> </span><span class="k">6.</span> <span class="gs">**Creating (TT:6)**</span>: Produce new or original work. I'll guide creation with prompts like, "Design a recursive function that traces the processing of a document."
<span class="k">*</span><span class="w"> </span> <span class="gs">**Exit**</span>: Use <span class="sb">`NN:`</span> or say "Exit teacher mode."
<span class="gu">### AA: XSLT Architect Mode</span>
<span class="k">*</span><span class="w"> </span> <span class="gs">**Purpose**</span>: High-level architectural and design discussions, focusing on best practices, patterns, and trade-offs without necessarily writing full code solutions. This mode is for exploring the "how" and "why" of a solution's structure.
<span class="k">*</span><span class="w"> </span> <span class="gs">**Activation**</span>: Prefix with <span class="sb">`AA:`</span>. You can add a sub-focus like:
<span class="w"> </span><span class="k">*</span><span class="w"> </span> <span class="sb">`AA:patterns`</span>: Discuss common XSLT design patterns (e.g., identity transform, fill-in-the-blanks).
<span class="w"> </span><span class="k">*</span><span class="w"> </span> <span class="sb">`AA:tradeoffs`</span>: Analyze the pros and cons of different implementation choices (e.g., <span class="sb">`xsl:for-each`</span> vs. <span class="sb">`xsl:apply-templates`</span>).
<span class="w"> </span><span class="k">*</span><span class="w"> </span> <span class="sb">`AA:ideas`</span>: Brainstorm multiple approaches to solving a complex transformation problem.
<span class="k">*</span><span class="w"> </span> <span class="gs">**Style**</span>:
<span class="w"> </span><span class="k">*</span><span class="w"> </span> Starts by restating the core problem to ensure understanding.
<span class="w"> </span><span class="k">*</span><span class="w"> </span> Generates multiple potential solutions with clear pros and cons (e.g., performance, readability, maintainability).
<span class="w"> </span><span class="k">*</span><span class="w"> </span> Includes risks or "gotchas" for each approach.
<span class="w"> </span><span class="k">*</span><span class="w"> </span> Critiques user-provided ideas rigorously, pointing out potential flaws or edge cases and suggesting robust alternatives.
<span class="k">*</span><span class="w"> </span> <span class="gs">**Exit**</span>: Use <span class="sb">`NN:`</span> or say "Exit architect mode."
<span class="gu">### LH: Language Historian Mode</span>
<span class="k">*</span><span class="w"> </span> <span class="gs">**Purpose**</span>: An interdisciplinary discussion exploring the history, design philosophy, and evolution of XSLT/XML and related technologies. This mode focuses on the "why" behind the language's features and its place in the broader history of technology.
<span class="k">*</span><span class="w"> </span> <span class="gs">**Activation**</span>: Prefix with <span class="sb">`LH:`</span>.
<span class="k">*</span><span class="w"> </span> <span class="gs">**Style**</span>:
<span class="w"> </span><span class="k">*</span><span class="w"> </span> Draws parallels and contrasts between XSLT's development and that of other languages (like Python).
<span class="w"> </span><span class="k">*</span><span class="w"> </span> Explains the reasoning behind confusing or non-intuitive language features (e.g., XSLT's default templates).
<span class="w"> </span><span class="k">*</span><span class="w"> </span> Discusses the influence of standards committees (W3C) versus individual or community-led language design.
<span class="w"> </span><span class="k">*</span><span class="w"> </span> Analyzes the industrial and human factors that lead to a technology's adoption or decline.
<span class="k">*</span><span class="w"> </span> <span class="gs">**Exit**</span>: Use <span class="sb">`NN:`</span> or say "Exit historian mode."
<span class="gu">### NN: Normal Mode</span>
<span class="k">*</span><span class="w"> </span> <span class="gs">**Purpose**</span>: Reset to the standard, adaptive response style for direct questions and answers.
<span class="k">*</span><span class="w"> </span> <span class="gs">**Activation**</span>: Prefix with <span class="sb">`NN:`</span> or occurs automatically after exiting another mode.
</code></pre></div>
<h3 id="hack-to-learn-workflow">Hack-to-Learn Workflow</h3>
<p>While new XSLT books are rare, the classic texts contain timeless problems and
patterns. This repository provides the code for those exercises, allowing you to
master XSLT using a modern, AI-driven workflow.</p>
<p>The core learning loop is simple: use this repository's code as a foundation and
an AI assistant as your personal tutor. An effective workflow is:</p>
<ol>
<li><strong>Find an Example</strong>: Navigate to a chapter's code within this repository.</li>
<li><strong>Load the Context</strong>: Copy and paste the source XML and the XSLT (<code>.xsl</code>) file into
your AI session.</li>
<li><strong>Interrogate the Code</strong>: Ask the AI to explain the stylesheet until you
understand it. Use the AA: (Architect) and LH: (Language Historian) prompts
to explore why the code is structured a certain way and the design philosophy
behind it.</li>
<li><strong>Run the Example</strong>: Execute the code using the try command-line helper provided
by this repository to see it in action.</li>
<li><strong>Test Your Knowledge</strong>: Ask the AI to quiz you. Use the TT: (Teacher) prompts to
generate targeted questions at different cognitive levels. (A fast and
<strong>painful</strong> way to learn is to set the TT prompt well beyond your level of
competence. If it hurts you are doing it right.)</li>
</ol>
<h3 id="recommended-curriculum">Recommended Curriculum</h3>
<p>Apply the learning workflow above to this curated training path. The directory names in parentheses correspond to the code in this repository.</p>
<ul>
<li>
<p><strong>1. The Basics (<code>otegem</code>)</strong></p>
<ul>
<li><strong>Book:</strong> <em>Teach Yourself XSLT in 21 Days</em> by Michiel van Otegem.</li>
<li><strong>Focus:</strong> Work through chapters 3-17 to build a strong foundation. Use the <code>try xpath</code> command to master XPath concepts, and build a personal snippet library as you go.</li>
</ul>
</li>
<li>
<p><strong>2. Practical Labs (<code>sal</code>)</strong></p>
<ul>
<li><strong>Book:</strong> <em>XSLT Cookbook</em> by Sal Mangano.</li>
<li><strong>Focus:</strong> These are practical, recipe-style examples. Use the AI to explain the core concept of each recipe before examining the solution. (Key chapters: 15, 6).</li>
</ul>
</li>
<li>
<p><strong>3. Intermediate Concepts (<code>jenni</code>)</strong></p>
<ul>
<li><strong>Book:</strong> <em>Beginning XSLT 2.0</em> by Jeni Tennison.</li>
<li><strong>Focus:</strong> Use the AI to explain the high-level concepts from the chapter headings, then dive into the code examples provided in this repo to see them implemented. (Key chapters: 11, appendix A)</li>
</ul>
</li>
<li>
<p><strong>4. Schemas (<code>schema</code>)</strong></p>
<ul>
<li><strong>Book:</strong> <a href="#xml-schemas">XML Schemas in these docs</a>, use the existing examples and an AI to generate new examples</li>
<li><strong>Focus:</strong> Ensure your xml can be properly guarded and specified with an
XDS1.1 and schematron schemas.</li>
</ul>
</li>
<li>
<p><strong>5. Advanced Design Patterns (<code>michael</code>, <code>patterns</code>)</strong></p>
<ul>
<li><strong>Book:</strong> Michael Kay’s <em>XSLT 2.0 and XPath 2.0 Programmer's Reference</em>.</li>
<li><strong>Focus:</strong> Specifically Chapter 17: "Stylesheet Design Patterns." This
is essential reading for writing professional, maintainable XSLT.
(fill-in-the-blanks stylesheets, navigational stylesheets, rule-based
stylesheets, computational stylesheets)</li>
</ul>
</li>
<li>
<p><strong>6. Bridging to XSLT 3.0</strong></p>
<ul>
<li>Since there is no single XSLT 3.0 book, use a combination of these excellent resources:<ul>
<li><strong>Michael Kay's Book:</strong> The book above covers much of the foundation needed for 3.0.</li>
<li><strong>Online Examples:</strong> <a href="https://xslt-3-by-example.blogspot.com/">Martin Honnen’s XSLT 3.0 by Example blog</a> and his expert answers on <a href="https://stackoverflow.com/users/252228/martin-honnen">Stack Overflow</a>.</li>
<li><strong>JSON Handling:</strong> Michael Kay's paper, <a href="https://www.saxonica.com/papers/xmlprague-2016mhk.pdf"><em>Transforming JSON using XSLT 3.0</em></a>. (Supporting code is in the <code>/patterns</code> folder of this repo.)</li>
<li><strong>XPath 3.1 Training:</strong> <a href="https://www.altova.com/training/xpath3">Altova’s free training resources</a>.</li>
</ul>
</li>
</ul>
</li>
<li><strong>7. Overview of 3.0 (<code>scott</code>)</strong><ul>
<li>Since there is no single XSLT 3.0 book, use the training patterns in the <code>(scott)</code>
directory (provided by Grok4)</li>
</ul>
</li>
</ul>
<h3 id="build-an-amoury">Build an Amoury</h3>
<p>To make XSLT less verbose, use editor-snippets.</p>
<p>In Vim/Neovim, SirVer’s UltiSnips is excellent — create your own library as you
learn. Build snippets while reading books, adding comments for reference. Use
UltiSnips’ shortcut to jump between your XSLT file and <a href="https://github.com/aleph2c/.vim/blob/master/snippets/xslt.snippets">snippet
files</a>. Keep
snippets under Git-control for portability.</p>
<h3 id="understanding-xslts-default-behavior-and-why-its-so-confusing">Understanding XSLT's Default Behavior (And Why It's So Confusing)</h3>
<p>The most confusing part of XSLT for newcomers is its set of invisible, built-in
template rules. The best way to understand them is to compare XSLT to CSS.</p>
<p>When you apply a CSS stylesheet to an HTML document, the browser's default
behavior is to render the entire HTML structure. You write CSS rules to <em>style</em>
the elements, but you don't expect the tags themselves (<code><h1></code>, <code><p></code>, etc.) to
disappear. This is because <strong>HTML is a presentational markup language</strong>; its
tags have an inherent visual meaning to the browser.</p>
<p>XSLT behaves differently. If you apply a completely empty stylesheet to an XML
document, the result is that <strong>all the tags are stripped away, leaving only the
raw text content.</strong> This is baffling at first, but it reveals the core
philosophy of the language. Unlike HTML, <strong>XML is a semantic data language.</strong>
Its tags, like <code><customer-id></code> or <code><price></code>, have no intrinsic visual meaning.
They are labels for data.</p>
<p>The XSLT designers assumed that the most basic, default operation anyone would
want is to extract the data itself—the text. Therefore, they created two
built-in rules that work together:</p>
<ol>
<li><strong>A Rule for Elements:</strong> This default rule matches any element (<code>*</code>) or the
root node (<code>/</code>). Its only job is to recursively keep processing
(<code><xsl:apply-templates/></code>). It produces no output for the element tag
itself; it just keeps digging deeper.</li>
<li><strong>A Rule for Text:</strong> This default rule matches any text node (<code>text()</code>). Its
job is to copy the value of the text to the output (<code><xsl:value-of
select="."/></code>).</li>
</ol>
<p>When you combine these, the first rule navigates silently through the tree of
element tags, and the second rule shouts out the value of any text it finds
along the way. The result is a stream of text with all its structural context
removed.</p>
<h4 id="how-to-take-back-control">How to Take Back Control</h4>
<p>This default behavior is rarely what you want. Experienced XSLT developers
almost always start by creating a "blank slate." They override the built-in
rules by putting this template at the top of their stylesheet:</p>
<div class="codehilite"><pre><span></span><code><span class="cm"><!-- This empty template matches ALL nodes and attributes and does nothing.</span>
<span class="cm"> It effectively disables all the built-in rules. --></span>
<span class="nt"><xsl:template</span><span class="w"> </span><span class="na">match=</span><span class="s">"node() | @*"</span><span class="nt">/></span>
</code></pre></div>
<h1 id="installation-instructions">Installation Instructions</h1>
<p>These installation commands will do the following:</p>
<ul>
<li>Install this repo's CLI</li>
<li>Install the two XSLT python parsers (<code>lxml/sachonche</code>)</li>
<li>Get the example programs organized within the book directories</li>
<li>Get a separate version of the Saxonic XSLT that will provide compile errors</li>
</ul>
<div class="codehilite"><pre><span></span><code>git<span class="w"> </span>clone<span class="w"> </span>git@github.com:aleph2c/leaning_xslt.git
<span class="nb">cd</span><span class="w"> </span>learning_xslt
python3<span class="w"> </span>-m<span class="w"> </span>venv<span class="w"> </span>venv
<span class="nb">source</span><span class="w"> </span>./venv/bin/activate
pip<span class="w"> </span>install<span class="w"> </span>--upgrade<span class="w"> </span>pip
pip<span class="w"> </span>install<span class="w"> </span>-e<span class="w"> </span>.
<span class="c1"># see note:</span>
xslt<span class="w"> </span>install-compile-errors
</code></pre></div>
<p><strong>Note:</strong>
The <code>saxonche</code> pip package used by this repo will not output XSLT compiler errors,
but if you want to see them (which you do) this command will fix the problem:</p>
<div class="codehilite"><pre><span></span><code>xslt<span class="w"> </span>install-compiler-errors
</code></pre></div>
<p>This will download the
<a href="https://github.com/Saxonica/Saxon-HE/blob/be4dd844d935d8d0ef09748490448624abe3c66b/12/source/saxon12-0source.zip">zipped java version of saxon</a>
and decompress its contents in <code>./java/</code>. With this jar installed the <code>try</code>
cli tool will call out to java when the <code>saxoniche</code> library fails to compile
your <code>.xsl</code>. It will rerun the compilation using the jar and output the XSLT
compiler error messages to the terminal. This will give you the feedback
required to debug your programs.</p>
<h1 id="running-examples">Running Examples</h1>
<p>The repo installs a <code>try</code> command. To see how it works:</p>
<div class="codehilite"><pre><span></span><code>try --help
Usage: try [OPTIONS] COMMAND [ARGS]...
Try an XSLT/XPath example and cache the command
Options:
-d, --dir TEXT Set the exercise directory
--help Show this message and exit.
Commands:
cache View your command cache
ex Run an exercise
xpath Test an XPath query on a given xml doc and context
</code></pre></div>
<h2 id="how-to-run-specific-examples">How to Run Specific Examples</h2>
<p>To see how to run an exercise:</p>
<div class="codehilite"><pre><span></span><code>try ex --help
Usage: try ex [OPTIONS]
Run an exercise:
try -d sal/ch07 ex \
-x books.xml \
-l text.hierarchy.xsl \
-params "indent=' ',param2='some_value'" \
-o text.hierarchy.txt
Options:
-n, --node-name TEXT Set the node name
-x, --xml TEXT Set the xml file
-j, --json TEXT Set the json file (saxon)
-l, --xls TEXT Set the xls file
-p, --processor TEXT Set the processor (lxml|saxon)
-o, --output_file TEXT Set the output file name
--params TEXT Set the optional parameter(s)
-v, --verbose Run in verbose mode?
--help Show this message and exit.
</code></pre></div>
<p>To run an example:</p>
<div class="codehilite"><pre><span></span><code><span class="n">try -d jenni/ch2_html_from_xml ex -x TVGuide2.xml -l TVGuide2.xsl -o TVGuide2.html -p lxml -v</span>
<span class="c"># a lot of XML</span>
<span class="n">ran the lxml process</span>
</code></pre></div>
<p>To see your cache:</p>
<div class="codehilite"><pre><span></span><code><span class="n">try cache</span>
<span class="n">{'context': '', 'home_dir': 'jenni/home/scott/xslt/ch3_templates',</span>
<span class="n">'output_file_name': 'TVGuide2.html', 'processor': 'lxml', </span>
<span class="n">'xls_file_name': 'TVGuide2.xsl', 'xml_file_name': 'TVGuide2.xml'}</span>
</code></pre></div>
<p>To run the same exercise again:</p>
<div class="codehilite"><pre><span></span><code>try ex -v
# a lot of XML
ran the lxml processor
</code></pre></div>
<p>To try the same example with the saxon processor, you just have to tell the
<code>try</code> command you want to use the <code>saxon</code> processor, if the other options
are not specified it will use your cached options:</p>
<div class="codehilite"><pre><span></span><code>try ex -p saxon -v
# a lot of XML
ran the saxon processor
</code></pre></div>
<h2 id="running-your-own-examples">Running Your Own Examples</h2>
<p>To run examples from a different book, add descriptives folder names and put
your xml and xsl files in these folders. Use the <code>-d</code> flag to point to the
folder you are working with, then run the sub-commands as you did before.</p>
<h2 id="json-transform-example-1">JSON Transform Example 1</h2>
<p>In this example we will perform a transform to increase the price of a product
tagged with "ice" by 10 percent (see ./patterns/to_json.xs):</p>
<p>Given this input:</p>
<div class="codehilite"><pre><span></span><code><span class="n">python</span><span class="w"> </span><span class="o">-</span><span class="n">m</span><span class="w"> </span><span class="n">json</span><span class="o">.</span><span class="k">tool</span><span class="w"> </span><span class="o">./</span><span class="n">michael</span><span class="o">/</span><span class="n">json_input</span><span class="o">.</span><span class="n">json</span>
<span class="p">[</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s2">"id"</span><span class="p">:</span><span class="w"> </span><span class="mi">2</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"name"</span><span class="p">:</span><span class="w"> </span><span class="s2">"An ice sculpture"</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"price"</span><span class="p">:</span><span class="w"> </span><span class="mf">12.50</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"tags"</span><span class="p">:</span><span class="w"> </span><span class="p">[</span><span class="s2">"cold"</span><span class="p">,</span><span class="w"> </span><span class="s2">"ice"</span><span class="p">],</span>
<span class="w"> </span><span class="s2">"dimensions"</span><span class="p">:</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s2">"length"</span><span class="p">:</span><span class="w"> </span><span class="mf">7.0</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"width"</span><span class="p">:</span><span class="w"> </span><span class="mf">12.0</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"height"</span><span class="p">:</span><span class="w"> </span><span class="mf">9.5</span>
<span class="w"> </span><span class="p">},</span>
<span class="w"> </span><span class="s2">"warehouseLocation"</span><span class="p">:</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s2">"latitude"</span><span class="p">:</span><span class="w"> </span><span class="o">-</span><span class="mf">78.75</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"longitude"</span><span class="p">:</span><span class="w"> </span><span class="mf">20.4</span>
<span class="w"> </span><span class="p">}</span>
<span class="w"> </span><span class="p">},</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s2">"id"</span><span class="p">:</span><span class="w"> </span><span class="mi">3</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"name"</span><span class="p">:</span><span class="w"> </span><span class="s2">"A blue mouse"</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"price"</span><span class="p">:</span><span class="w"> </span><span class="mf">25.50</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"dimensions"</span><span class="p">:</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s2">"length"</span><span class="p">:</span><span class="w"> </span><span class="mf">3.1</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"width"</span><span class="p">:</span><span class="w"> </span><span class="mf">1.0</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"height"</span><span class="p">:</span><span class="w"> </span><span class="mf">1.0</span>
<span class="w"> </span><span class="p">},</span>
<span class="w"> </span><span class="s2">"warehouseLocation"</span><span class="p">:</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s2">"latitude"</span><span class="p">:</span><span class="w"> </span><span class="mf">54.4</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"longitude"</span><span class="p">:</span><span class="w"> </span><span class="o">-</span><span class="mf">32.7</span>
<span class="w"> </span><span class="p">}</span>
<span class="w"> </span><span class="p">}</span>
<span class="p">]</span>
</code></pre></div>
<p>Perform a transform (saxonpy works, saxonche stackoverflow):</p>
<div class="codehilite"><pre><span></span><code><span class="gh">#</span> this will crash with saxonche 12.0 due to stackoverflow errors
<span class="gh">#</span> but will run with saxonche 12.1
try -d michael \
ex -j json_input.json \
-l to_json.xsl \
-o json_output.json \
-p saxon
</code></pre></div>
<p>This will create the following output:</p>
<div class="codehilite"><pre><span></span><code><span class="n">python</span><span class="w"> </span><span class="o">-</span><span class="n">m</span><span class="w"> </span><span class="n">json</span><span class="o">.</span><span class="k">tool</span><span class="w"> </span><span class="o">./</span><span class="n">michael</span><span class="o">/</span><span class="n">json_output</span><span class="o">.</span><span class="n">json</span>
<span class="p">[</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s2">"id"</span><span class="p">:</span><span class="w"> </span><span class="mi">2</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"name"</span><span class="p">:</span><span class="w"> </span><span class="s2">"An ice sculpture"</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"price"</span><span class="p">:</span><span class="w"> </span><span class="mf">13.75</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"tags"</span><span class="p">:</span><span class="w"> </span><span class="p">[</span>
<span class="w"> </span><span class="s2">"cold"</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"ice"</span>
<span class="w"> </span><span class="p">],</span>
<span class="w"> </span><span class="s2">"dimensions"</span><span class="p">:</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s2">"length"</span><span class="p">:</span><span class="w"> </span><span class="mi">7</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"width"</span><span class="p">:</span><span class="w"> </span><span class="mi">12</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"height"</span><span class="p">:</span><span class="w"> </span><span class="mf">9.5</span>
<span class="w"> </span><span class="p">},</span>
<span class="w"> </span><span class="s2">"warehouseLocation"</span><span class="p">:</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s2">"latitude"</span><span class="p">:</span><span class="w"> </span><span class="o">-</span><span class="mf">78.75</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"longitude"</span><span class="p">:</span><span class="w"> </span><span class="mf">20.4</span>
<span class="w"> </span><span class="p">}</span>
<span class="w"> </span><span class="p">},</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s2">"id"</span><span class="p">:</span><span class="w"> </span><span class="mi">3</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"name"</span><span class="p">:</span><span class="w"> </span><span class="s2">"A blue mouse"</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"price"</span><span class="p">:</span><span class="w"> </span><span class="mf">25.5</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"dimensions"</span><span class="p">:</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s2">"length"</span><span class="p">:</span><span class="w"> </span><span class="mf">3.1</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"width"</span><span class="p">:</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"height"</span><span class="p">:</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="p">},</span>
<span class="w"> </span><span class="s2">"warehouseLocation"</span><span class="p">:</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s2">"latitude"</span><span class="p">:</span><span class="w"> </span><span class="mf">54.4</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"longitude"</span><span class="p">:</span><span class="w"> </span><span class="o">-</span><span class="mf">32.7</span>
<span class="w"> </span><span class="p">}</span>
<span class="w"> </span><span class="p">}</span>
<span class="p">]</span>
</code></pre></div>
<h2 id="json-transform-example-2">JSON Transform Example 2</h2>
<p>We would like to invert the hierarchy of a json document. In this example we
will take the data being organized from faculty->courses->students->email and
transform it to email->courses. We will also sort the output based on last name
and then the first name of each student, but we will keep the student's name out
of the final output.</p>
<p>Given this input:</p>
<div class="codehilite"><pre><span></span><code><span class="o">[</span>
<span class="n"> {</span>
<span class="n"> "faculty": "humanities",</span>
<span class="n"> "courses": [</span>
<span class="n"> {</span>
<span class="n"> "course": "English",</span>
<span class="n"> "students": [</span>
<span class="n"> {</span>
<span class="n"> "first": "Mary",</span>
<span class="n"> "last": "Smith",</span>
<span class="n"> "email": "mary_smith@gmail.com"</span>
<span class="n"> },</span>
<span class="n"> {</span>
<span class="n"> "first": "Ann",</span>
<span class="n"> "last": "Jones",</span>
<span class="n"> "email": "ann_jones@gmail.com"</span>
<span class="n"> }</span>
<span class="n"> </span><span class="o">]</span>
<span class="w"> </span><span class="err">}</span><span class="p">,</span>
<span class="w"> </span><span class="err">{</span>
<span class="w"> </span><span class="ss">"course"</span><span class="err">:</span><span class="w"> </span><span class="ss">"History"</span><span class="p">,</span>
<span class="w"> </span><span class="ss">"students"</span><span class="err">:</span><span class="w"> </span><span class="o">[</span>
<span class="n"> {</span>
<span class="n"> "first": "Ann",</span>
<span class="n"> "last": "Jones",</span>
<span class="n"> "email": "ann_jones@gmail.com"</span>
<span class="n"> },</span>
<span class="n"> {</span>
<span class="n"> "first": "John",</span>
<span class="n"> "last": "Taylor",</span>
<span class="n"> "email": "john_taylor@gmail.com"</span>
<span class="n"> }</span>
<span class="n"> </span><span class="o">]</span>
<span class="w"> </span><span class="err">}</span>
<span class="w"> </span><span class="err">]</span>
<span class="w"> </span><span class="err">}</span><span class="p">,</span>
<span class="w"> </span><span class="err">{</span>
<span class="w"> </span><span class="ss">"faculty"</span><span class="err">:</span><span class="w"> </span><span class="ss">"science"</span><span class="p">,</span>
<span class="w"> </span><span class="ss">"courses"</span><span class="err">:</span><span class="w"> </span><span class="o">[</span>
<span class="n"> {</span>
<span class="n"> "course": "Physics",</span>
<span class="n"> "students": [</span>
<span class="n"> {</span>
<span class="n"> "first": "Anil",</span>
<span class="n"> "last": "Singh",</span>
<span class="n"> "email": "anil_singh@gmail.com"</span>
<span class="n"> },</span>
<span class="n"> {</span>
<span class="n"> "first": "Amisha",</span>
<span class="n"> "last": "Patel",</span>
<span class="n"> "email": "amisha_patel@gmail.com"</span>
<span class="n"> }</span>
<span class="n"> </span><span class="o">]</span>
<span class="w"> </span><span class="err">}</span><span class="p">,</span>
<span class="w"> </span><span class="err">{</span>
<span class="w"> </span><span class="ss">"course"</span><span class="err">:</span><span class="w"> </span><span class="ss">"Chemistry"</span><span class="p">,</span>
<span class="w"> </span><span class="ss">"students"</span><span class="err">:</span><span class="w"> </span><span class="o">[</span>
<span class="n"> {</span>
<span class="n"> "first": "John",</span>
<span class="n"> "last": "Taylor",</span>
<span class="n"> "email": "john_taylor@gmail.com"</span>
<span class="n"> },</span>
<span class="n"> {</span>
<span class="n"> "first": "Anil",</span>
<span class="n"> "last": "Singh",</span>
<span class="n"> "email": "anil_singh@gmail.com"</span>
<span class="n"> }</span>
<span class="n"> </span><span class="o">]</span>
<span class="w"> </span><span class="err">}</span>
<span class="w"> </span><span class="err">]</span>
<span class="w"> </span><span class="err">}</span>
<span class="err">]</span>
</code></pre></div>
<p>Perform the transform (saxonpy works, saxonche stackoverflow):</p>
<div class="codehilite"><pre><span></span><code>try -d michael \
ex -x json_input2.json \
-l to_json2.xsl \
-o json_output2.json \
-p saxon
</code></pre></div>
<p>This will produce the following output</p>
<div class="codehilite"><pre><span></span><code><span class="n">python</span><span class="w"> </span><span class="o">-</span><span class="n">m</span><span class="w"> </span><span class="n">json</span><span class="o">.</span><span class="k">tool</span><span class="w"> </span><span class="o">./</span><span class="n">patterns</span><span class="o">/</span><span class="n">json_output2</span><span class="o">.</span><span class="n">json</span>
<span class="p">[</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s2">"email"</span><span class="p">:</span><span class="w"> </span><span class="s2">"ann_jones@gmail.com"</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"courses"</span><span class="p">:</span><span class="w"> </span><span class="p">[</span>
<span class="w"> </span><span class="s2">"English"</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"History"</span>
<span class="w"> </span><span class="p">]</span>
<span class="w"> </span><span class="p">},</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s2">"email"</span><span class="p">:</span><span class="w"> </span><span class="s2">"amisha_patel@gmail.com"</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"courses"</span><span class="p">:</span><span class="w"> </span><span class="p">[</span>
<span class="w"> </span><span class="s2">"Physics"</span>
<span class="w"> </span><span class="p">]</span>
<span class="w"> </span><span class="p">},</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s2">"email"</span><span class="p">:</span><span class="w"> </span><span class="s2">"anil_singh@gmail.com"</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"courses"</span><span class="p">:</span><span class="w"> </span><span class="p">[</span>
<span class="w"> </span><span class="s2">"Physics"</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"Chemistry"</span>
<span class="w"> </span><span class="p">]</span>
<span class="w"> </span><span class="p">},</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s2">"email"</span><span class="p">:</span><span class="w"> </span><span class="s2">"mary_smith@gmail.com"</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"courses"</span><span class="p">:</span><span class="w"> </span><span class="p">[</span>
<span class="w"> </span><span class="s2">"English"</span>
<span class="w"> </span><span class="p">]</span>
<span class="w"> </span><span class="p">},</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s2">"email"</span><span class="p">:</span><span class="w"> </span><span class="s2">"john_taylor@gmail.com"</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"courses"</span><span class="p">:</span><span class="w"> </span><span class="p">[</span>
<span class="w"> </span><span class="s2">"History"</span><span class="p">,</span>
<span class="w"> </span><span class="s2">"Chemistry"</span>
<span class="w"> </span><span class="p">]</span>
<span class="w"> </span><span class="p">}</span>
<span class="p">]</span>
</code></pre></div>
<h1 id="integrating-xslt-30-with-python-in-the-main-thread">Integrating XSLT 3.0 with Python in the main thread</h1>
<p>The <a href="https://pypi.org/project/saxonche/">saxonche documentation</a> is incomplete
and almost useless. To see fixed versions of the low quality python examples
provided by Saxonica look in the <code>oneal</code> folder of this repo.</p>
<p>If you want to get your python code to parse XML/JSON/XSLT and output XML/JSON
using <code>saxonche</code> consider the following:</p>
<div class="codehilite"><pre><span></span><code><span class="kn">from</span><span class="w"> </span><span class="nn">pathlib</span><span class="w"> </span><span class="kn">import</span> <span class="n">Path</span>
<span class="kn">from</span><span class="w"> </span><span class="nn">saxonche</span><span class="w"> </span><span class="kn">import</span> <span class="n">PySaxonProcessor</span>
<span class="k">def</span><span class="w"> </span><span class="nf">transform_with_saxonche</span><span class="p">(</span>
<span class="bp">self</span><span class="p">,</span> <span class="n">home_dir</span><span class="p">,</span> <span class="n">xml_file_name</span><span class="p">,</span> <span class="n">xsl_file_name</span><span class="p">,</span> <span class="n">output_file_name</span>
<span class="p">):</span>
<span class="c1"># Don't use the PySaxonProcess context manager if you are calling saxonche</span>
<span class="c1"># over and over again within your program. Instead build the proc and</span>
<span class="c1"># xsltproc once, and reference them when you need them. If you don't do</span>
<span class="c1"># this, you will get strange memory errors:</span>
<span class="c1"># "JNI_CreateJavaVM() failed with result: -5" (last seen in saxonc-he 11.4)</span>
<span class="c1">#</span>
<span class="c1"># Example of how to build the proc and xsltproc once per program invocation:</span>
<span class="c1">#</span>
<span class="c1"># from functools import cache as cached</span>
<span class="c1"># @cached</span>
<span class="c1"># def get_cached_procs_from(*args):</span>
<span class="c1"># proc = PySaxonProcessor(licence=False)</span>
<span class="c1"># xsltproc = proc.new_xslt30_processor()</span>
<span class="c1"># return proc, xsltproc</span>
<span class="c1">#</span>
<span class="c1"># def transform_with_saxonche(...)</span>
<span class="c1"># proc, xsltproc = get_cached_procs_from(PySaxonProcessor)</span>
<span class="c1"># # ...</span>
<span class="c1"># If you are running your transforms once per program invocation</span>
<span class="c1"># you can use the PySaxonProcessor context manager. Don't be fooled, given</span>
<span class="c1"># that this context manager doesn't clean up memory when it's done, it's not</span>
<span class="c1"># really behaving like a Python context manager. (see the memory bug</span>
<span class="c1"># mentioned above)</span>
<span class="k">with</span> <span class="n">PySaxonProcessor</span><span class="p">(</span><span class="n">license</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span> <span class="k">as</span> <span class="n">proc</span><span class="p">:</span>
<span class="n">xsltproc</span> <span class="o">=</span> <span class="n">proc</span><span class="o">.</span><span class="n">new_xslt30_processor</span><span class="p">()</span>
<span class="n">xsltproc</span><span class="o">.</span><span class="n">set_cwd</span><span class="p">(</span><span class="nb">str</span><span class="p">(</span><span class="n">home_dir</span><span class="p">))</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">Path</span><span class="p">(</span><span class="n">home_dir</span><span class="p">)</span><span class="o">.</span><span class="n">exists</span><span class="p">():</span>
<span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">"</span><span class="si">{</span><span class="n">home_dir</span><span class="si">}</span><span class="s2"> doesn't exist"</span><span class="p">)</span>
<span class="n">exit</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="k">if</span> <span class="ow">not</span> <span class="p">(</span><span class="n">Path</span><span class="p">(</span><span class="n">home_dir</span><span class="p">)</span> <span class="o">/</span> <span class="n">xml_file_name</span><span class="p">)</span><span class="o">.</span><span class="n">exists</span><span class="p">():</span>
<span class="nb">print</span><span class="p">(</span>
<span class="sa">f</span><span class="s2">"xml_file_name: </span><span class="si">{</span><span class="nb">str</span><span class="p">(</span><span class="n">Path</span><span class="p">(</span><span class="n">home_dir</span><span class="p">)</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="n">xml_file_name</span><span class="p">)</span><span class="si">}</span><span class="s2"> doesn't exist"</span>
<span class="p">)</span>
<span class="n">exit</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="k">if</span> <span class="ow">not</span> <span class="p">(</span><span class="n">Path</span><span class="p">(</span><span class="n">home_dir</span><span class="p">)</span> <span class="o">/</span> <span class="n">xsl_file_name</span><span class="p">)</span><span class="o">.</span><span class="n">exists</span><span class="p">():</span>
<span class="nb">print</span><span class="p">(</span>
<span class="sa">f</span><span class="s2">"xsl_file_name: </span><span class="si">{</span><span class="nb">str</span><span class="p">(</span><span class="n">Path</span><span class="p">(</span><span class="n">home_dir</span><span class="p">)</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="n">xsl_file_name</span><span class="p">)</span><span class="si">}</span><span class="s2"> doesn't exist"</span>
<span class="p">)</span>
<span class="n">exit</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="k">if</span> <span class="n">Path</span><span class="p">(</span><span class="n">xml_file_name</span><span class="p">)</span><span class="o">.</span><span class="n">suffix</span> <span class="o">==</span> <span class="s2">".json"</span><span class="p">:</span>
<span class="n">json_input_param</span> <span class="o">=</span> <span class="n">proc</span><span class="o">.</span><span class="n">make_string_value</span><span class="p">(</span><span class="nb">str</span><span class="p">(</span><span class="n">home_dir</span> <span class="o">/</span> <span class="n">xml_file_name</span><span class="p">))</span>
<span class="n">xsltproc</span><span class="o">.</span><span class="n">set_parameter</span><span class="p">(</span><span class="s2">"json_input_filename"</span><span class="p">,</span> <span class="n">json_input_param</span><span class="p">)</span>
<span class="n">stylesheet_file</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">Path</span><span class="p">(</span><span class="n">home_dir</span><span class="p">)</span> <span class="o">/</span> <span class="n">xsl_file_name</span><span class="p">)</span>
<span class="n">_exec</span> <span class="o">=</span> <span class="n">xsltproc</span><span class="o">.</span><span class="n">compile_stylesheet</span><span class="p">(</span>
<span class="n">stylesheet_file</span><span class="o">=</span><span class="n">stylesheet_file</span><span class="p">,</span>
<span class="p">)</span>
<span class="k">if</span> <span class="n">_exec</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"saxonica failed"</span><span class="p">)</span>
<span class="n">exit</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="k">if</span> <span class="n">Path</span><span class="p">(</span><span class="n">xml_file_name</span><span class="p">)</span><span class="o">.</span><span class="n">suffix</span> <span class="o">==</span> <span class="s2">".json"</span><span class="p">:</span>
<span class="c1"># it's a mystery why we have to use call_template_returning_file</span>
<span class="c1"># and not make_string_value (this isn't documented anywhere)</span>
<span class="n">_exec</span><span class="o">.</span><span class="n">call_template_returning_file</span><span class="p">(</span><span class="n">output_file</span><span class="o">=</span><span class="n">output_file_name</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="c1"># add a test_param to validate saxon is working</span>
<span class="n">test_param</span> <span class="o">=</span> <span class="n">proc</span><span class="o">.</span><span class="n">make_string_value</span><span class="p">(</span><span class="nb">str</span><span class="p">(</span><span class="n">home_dir</span> <span class="o">/</span> <span class="n">xml_file_name</span><span class="p">))</span>
<span class="n">_exec</span><span class="o">.</span><span class="n">set_parameter</span><span class="p">(</span><span class="s2">"test_param"</span><span class="p">,</span> <span class="n">test_param</span><span class="p">)</span>
<span class="n">_exec</span><span class="o">.</span><span class="n">set_initial_match_selection</span><span class="p">(</span><span class="n">file_name</span><span class="o">=</span><span class="n">xml_file_name</span><span class="p">)</span>
<span class="n">_exec</span><span class="o">.</span><span class="n">apply_templates_returning_file</span><span class="p">(</span><span class="n">output_file</span><span class="o">=</span><span class="n">output_file_name</span><span class="p">)</span>
<span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="n">home_dir</span> <span class="o">/</span> <span class="n">output_file_name</span><span class="p">,</span> <span class="s2">"r"</span><span class="p">)</span> <span class="k">as</span> <span class="n">fp</span><span class="p">:</span>
<span class="n">contents</span> <span class="o">=</span> <span class="n">fp</span><span class="o">.</span><span class="n">read</span><span class="p">()</span>
<span class="nb">print</span><span class="p">(</span><span class="n">contents</span><span class="p">)</span>
</code></pre></div>
<h1 id="integrating-xslt-30-with-multithreaded-python">Integrating XSLT 3.0 with Multithreaded Python</h1>
<div class="codehilite"><pre><span></span><code><span class="c1"># This doesn't cause StackOverFlow crashes and, its fully documented </span>
<span class="c1"># and its documentation isn't wrong. It only support XSLT 1.0</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">lxml</span>
</code></pre></div>
<p>But if you are willing to accept some risk, here is a working demo of Python thread
performing XSLT transforms using saxonche without causing StackOverFlows:</p>
<div class="codehilite"><pre><span></span><code><span class="c1"># working copy can be found in ./cli/thread_demo.py</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">os</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">shutil</span>
<span class="kn">from</span><span class="w"> </span><span class="nn">uuid</span><span class="w"> </span><span class="kn">import</span> <span class="n">uuid1</span>
<span class="kn">from</span><span class="w"> </span><span class="nn">pathlib</span><span class="w"> </span><span class="kn">import</span> <span class="n">Path</span>
<span class="kn">from</span><span class="w"> </span><span class="nn">queue</span><span class="w"> </span><span class="kn">import</span> <span class="n">Queue</span>
<span class="kn">from</span><span class="w"> </span><span class="nn">threading</span><span class="w"> </span><span class="kn">import</span> <span class="n">Thread</span>
<span class="kn">from</span><span class="w"> </span><span class="nn">threading</span><span class="w"> </span><span class="kn">import</span> <span class="n">Lock</span>
<span class="kn">from</span><span class="w"> </span><span class="nn">collections</span><span class="w"> </span><span class="kn">import</span> <span class="n">namedtuple</span>
<span class="kn">from</span><span class="w"> </span><span class="nn">threading</span><span class="w"> </span><span class="kn">import</span> <span class="n">Event</span> <span class="k">as</span> <span class="n">ThreadEvent</span>
<span class="kn">from</span><span class="w"> </span><span class="nn">saxonche</span><span class="w"> </span><span class="kn">import</span> <span class="n">PySaxonProcessor</span>
<span class="n">proc_globals</span> <span class="o">=</span> <span class="p">{}</span>
<span class="n">proc_globals_lock</span> <span class="o">=</span> <span class="n">Lock</span><span class="p">()</span>
<span class="n">ValidateXmlPath</span> <span class="o">=</span> <span class="p">(</span><span class="n">Path</span><span class="p">(</span><span class="vm">__file__</span><span class="p">)</span><span class="o">.</span><span class="n">parent</span> <span class="o">/</span> <span class="s2">"validate_xml.xsl"</span><span class="p">)</span><span class="o">.</span><span class="n">resolve</span><span class="p">()</span>
<span class="n">SaxonPayload</span> <span class="o">=</span> <span class="n">namedtuple</span><span class="p">(</span>
<span class="s2">"SaxonPayload"</span><span class="p">,</span>
<span class="p">[</span><span class="s2">"home_dir"</span><span class="p">,</span> <span class="s2">"xml_file_name"</span><span class="p">,</span> <span class="s2">"xsl_file_name"</span><span class="p">,</span> <span class="s2">"output_file_name"</span><span class="p">,</span> <span class="s2">"verbose"</span><span class="p">],</span>
<span class="p">)</span>
<span class="k">def</span><span class="w"> </span><span class="nf">__initialize_saxon</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">):</span>
<span class="w"> </span><span class="sd">"""The PySaxonProcessor proc and the xslt30 proc should only be made once"""</span>
<span class="k">if</span> <span class="s2">"proc"</span> <span class="ow">in</span> <span class="n">proc_globals</span><span class="p">:</span>
<span class="n">proc</span> <span class="o">=</span> <span class="n">proc_globals</span><span class="p">[</span><span class="s2">"proc"</span><span class="p">]</span>
<span class="n">xsltproc</span> <span class="o">=</span> <span class="n">proc_globals</span><span class="p">[</span><span class="s2">"xsltproc"</span><span class="p">]</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">proc</span> <span class="o">=</span> <span class="n">PySaxonProcessor</span><span class="p">(</span><span class="n">license</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
<span class="n">xsltproc</span> <span class="o">=</span> <span class="n">proc</span><span class="o">.</span><span class="n">new_xslt30_processor</span><span class="p">()</span>
<span class="n">proc_globals</span><span class="p">[</span><span class="s2">"proc"</span><span class="p">]</span> <span class="o">=</span> <span class="n">proc</span>
<span class="n">proc_globals</span><span class="p">[</span><span class="s2">"xsltproc"</span><span class="p">]</span> <span class="o">=</span> <span class="n">xsltproc</span>
<span class="k">return</span> <span class="n">proc</span><span class="p">,</span> <span class="n">xsltproc</span>
<span class="c1"># call this from the main thread at least once</span>
<span class="n">proc_globals_lock</span><span class="o">.</span><span class="n">acquire</span><span class="p">()</span>
<span class="n">__initialize_saxon</span><span class="p">()</span>
<span class="n">proc_globals_lock</span><span class="o">.</span><span class="n">release</span><span class="p">()</span>
<span class="k">def</span><span class="w"> </span><span class="nf">__saxon_xslt30_transform</span><span class="p">(</span>
<span class="n">lock</span><span class="p">,</span> <span class="n">home_dir</span><span class="p">,</span> <span class="n">xml_file_name</span><span class="p">,</span> <span class="n">xsl_file_name</span><span class="p">,</span> <span class="n">output_file_name</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span>
<span class="p">):</span>
<span class="n">result</span> <span class="o">=</span> <span class="s2">""</span>
<span class="n">lock</span><span class="o">.</span><span class="n">acquire</span><span class="p">()</span>
<span class="n">proc</span><span class="p">,</span> <span class="n">xsltproc</span> <span class="o">=</span> <span class="n">__initialize_saxon</span><span class="p">()</span>