/usr/bin/diffoscope --exclude-command .*apksigner verify.* --max-report-size 12345678 --max-diff-block-lines 128 --html unsigned/com.econverter.app_8.apk.diffoscope.html --text unsigned/com.econverter.app_8.apk.diffoscope.txt /home/fdroid/fdroiddata/tmp/com.econverter.app_8.apk /home/fdroid/fdroiddata/unsigned/com.econverter.app

⊟

3.53 MB

/home/fdroid/fdroiddata/tmp/com.econverter.app_8.apk vs.

/home/fdroid/fdroiddata/unsigned/com.econverter.app_8.apk ¶

⊟

8.2 KB

APK Signing Block ¶

⊟

3.02 KB

zipinfo {} ¶

⊟

3.51 MB

assets/chaquopy/requirements-common.imy ¶

⊟

25.8 KB

zipinfo {} ¶

⊟

6.14 KB

zipnote «TEMP»/diffoscope_rc5pjyr8_unsigned/tmpkaztwolb_.zip ¶

⊟

2.76 MB

zipdetails --redact --walk --utc {} ¶

⊟

599 B

charset_normalizer/__init__.py ¶

⊟

14.6 KB

charset_normalizer/api.py ¶

⊟

17.3 KB

charset_normalizer/constant.py ¶

⊟

30.8 KB

charset_normalizer/md.py ¶

⊟

3.95 KB

charset_normalizer/models.py ¶

⊟

11.4 KB

charset_normalizer/utils.py ¶

⊟

220 B

charset_normalizer/version.py ¶

⊟

569 B

cssselect2/__init__.py ¶

⊟

711 B

cssselect2/parser.py ¶

⊟

3.36 KB

filelock/__init__.py ¶

⊟

77.9 KB

filelock/_api.py ¶

⊟

12.5 KB

filelock/_async.py ¶

⊟

14.8 KB

filelock/_async_read_write.py ¶

⊟

2.61 KB

filelock/_descriptor.py ¶

⊟

3.21 KB

filelock/_error.py ¶

⊟

8.59 KB

filelock/_identity.py ¶

⊟

21.9 KB

filelock/_lease.py ¶

⊟

8.45 KB

filelock/_marker.py ¶

⊟

43.2 KB

filelock/_read_write.py ¶

⊟

18.0 KB

filelock/_soft.py ¶

⊟

34.8 KB

filelock/_strict.py ¶

⊟

6.98 KB

filelock/_unix.py ¶

⊟

8.92 KB

filelock/_util.py ¶

⊟

5.4 KB

filelock/_windows.py ¶

⊟

23.7 KB

filelock/asyncio.py ¶

⊟

420 B

filelock/version.py ¶

⊟

452 B

filelock/_soft_rw/__init__.py ¶

⊟

14.9 KB

filelock/_soft_rw/_async.py ¶

⊟

59.5 KB

filelock/_soft_rw/_sync.py ¶

⊟

561 B

reportlab/__init__.py ¶

⊟

646 B

reportlab/graphics/renderPDF.py ¶

⊟

3.3 KB

reportlab/lib/rl_safe_eval.py ¶

⊟

6.54 KB

reportlab/lib/utils.py ¶

⊟

777 B

reportlab/pdfgen/canvas.py ¶

⊟

6.37 KB

soupsieve/__init__.py ¶

⊟

355 B

soupsieve/__meta__.py ¶

⊟

48.5 KB

soupsieve/css_match.py ¶

⊟

50.2 KB

soupsieve/css_parser.py ¶

⊟

16.5 KB

soupsieve/css_types.py ¶

⊟

959 B

soupsieve/util.py ¶

⊟

3.31 KB

svglib/__init__.py ¶

⊟

4.22 KB

svglib/fonts.py ¶

⊟

76.5 KB

svglib/svglib.py ¶

⊟

6.57 KB

svglib/utils.py ¶

⊟

11.0 KB

webencodings/__init__.py ¶

⊟

45.0 B

encoding ¶

⊟

3.3 KB

webencodings/labels.py ¶

⊟

44.1 KB

charset_normalizer-3.4.9.dist-info/METADATA vs.

charset_normalizer-3.5.2.dist-info/METADATA ¶

Files 92% similar despite different names

⊟

26.6 KB

html2text {} ¶

⊟

141 B

charset_normalizer-3.4.9.dist-info/licenses/LICENSE vs.

charset_normalizer-3.5.2.dist-info/licenses/LICENSE ¶

Files identical despite different names

⊟

1.2 KB

cssselect2-0.9.0.dist-info/METADATA vs.

cssselect2-0.10.1.dist-info/METADATA ¶

Files 98% similar despite different names

⊟

126 B

cssselect2-0.9.0.dist-info/licenses/LICENSE vs.

cssselect2-0.10.1.dist-info/licenses/LICENSE ¶

Files identical despite different names

⊟

1.83 KB

filelock-3.32.0.dist-info/METADATA vs.

filelock-4.1.1.dist-info/METADATA ¶

Files 97% similar despite different names

⊟

122 B

filelock-3.32.0.dist-info/licenses/LICENSE vs.

filelock-4.1.1.dist-info/licenses/LICENSE ¶

Files identical despite different names

⊟

592 B

reportlab-5.0.0.dist-info/METADATA vs.

reportlab-5.0.1.dist-info/METADATA ¶

Files 92% similar despite different names

⊟

123 B

reportlab-5.0.0.dist-info/licenses/LICENSE vs.

reportlab-5.0.1.dist-info/licenses/LICENSE ¶

Files identical despite different names

⊟

3.69 KB

soupsieve-2.9.1.dist-info/METADATA vs.

soupsieve-3.0.3.dist-info/METADATA ¶

Files 84% similar despite different names

⊟

129 B

soupsieve-2.9.1.dist-info/licenses/LICENSE.md vs.

soupsieve-3.0.3.dist-info/licenses/LICENSE.md ¶

Files identical despite different names

⊟

1.83 KB

svglib-2.0.2.dist-info/METADATA vs.

svglib-2.3.0.dist-info/METADATA ¶

Files 98% similar despite different names

⊟

125 B

svglib-2.0.2.dist-info/licenses/LICENSE.txt vs.

svglib-2.3.0.dist-info/licenses/LICENSE.txt ¶

Files identical despite different names

⊟

1.34 KB

assets/chaquopy/build.json ¶

⊟

1.29 KB

Pretty-printed ¶

Similarity: 0.99822695035461% Differences: {"'assets'": "{'requirements-common.imy': 'de1592022f8771860566bfd444c4a59be48264a5'}"}

+Key·0x42726577:
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000
+Key·0x7109871a:
+f7050000f3050000b50300002c00000028000000030100002000000079e4450ba1925f
+eaf4d8e28d350f4ac895d4f89aad38e69ed608a5af8236d030000690300003082
+03653082024da003020102020863707fe532bb2ae7300d06092a864886f70d01010b05
+003060310b300906035504061302554b310c300a060355040813034f5247310c300a06
+0355040713034f524731133011060355040a130a6664726f69642e6f7267310f300d06
+0355040b13064644726f6964310f300d060355040313064644726f69643020170d3236
+303632373135343331325a180f32303533313131323135343331325a3060310b300906
+035504061302554b310c300a060355040813034f5247310c300a060355040713034f52
+4731133011060355040a130a6664726f69642e6f7267310f300d060355040b13064644
+f6964310f300d060355040313064644726f696430820122300d06092a864886f70d
+01010105000382010f003082010a0282010100ac74a8f4fb5ff9c1a0338278598eb9c6
+ba0fce0774e5f2dfe7d8aff70c0cb2535a834e125f1581127f7a6f5d3f86dc5195fd7a
+b1c92b26bd6422d7d34de63f255b1782446868cb7bfdc3b992ccb233a52ef9c4d5f81
+ca92954b14f8046ec50a095dd5556832565712fd9d41cd934410056864573af7
+d8187d1774c6a004b928eb712a907ec5944e75acd901cfb09a1ce230815caae69da3a0
+b6bf6fb6d63156b21b8922ed1917331c4f1421eaa8dbb232f7832dcc35e7a6e6907f62
+df44fe4a73cd3f238002dfc7a5e2e2fc64ce1596966c7c411f63ad2e19c0339354c530
+b31e8cfb923799d505bbaa8c2d6bf92187fe3ae13fe30eabe346242d110203010001
+a321301f301d0603551d0e04160414ecb0d0226aa2fe884f4897c348146f3ffffc96b7
+d06092a864886f70d01010b0500038201010048373d1fdd119f7858e6e3c2e5c181
+b3ed8072b53c4ab90889efb9b8cd0c23eab3e01752c48305ee01f073d5a108e62196d4
+ce553bb0022a0055cac40979bccc03c1a6c90ee4baaad9f217f746731470b128bfd3b2
+d67879509be45a91d5042396036d3b05594d1f5055dca470801751296b3c5f4d72ece
+c04320cbbb69ee8a6d9d39309916850db9939afdfca7c90755c57a88fe82343d2b02cb
+fa45c1467ddc6e81e59fadd39925d9b2e62e85c55625247f04ce42a115ae52a52dec25
+f249cf08a392f7efb473a319ea4e410e74bb516475b7c881610fb95a013a9209c4243c
+bff03e2a50f4c1e6da3bad7c6a918afeeb7472bc45ad09efe63b47200c000000
+080000000df0efbe03000000000000000c0100000801000003010000000100008a8ba5
+ccfe9eb8a1fc412bc3aab3709dea78d88004af840290a192951e082a723b90abc98
+cbc35a27a58b02eb935831b35be0e4a5acd42e656049b94f2674f843c34a86aeef731
+29185621e250b6c9a7c850af7be0dc32f6e800e9a2018cc1b228ab91d201c130d7c0fa
+c768580ee93fecb41f909378db00720d66cd7cda40221d8631e307153d1d696f2fedbb
+b75c39409387770028b29b286a2c53c4bc985716d72da536b0a1398cd5bfa5bcef
+aaab6df7903008a4911d1966737af7870d931c582364d080d0fbcda3c0b2ee3c9f7f
+f2785a68f8e6406f0f14673fd34293a7a25274bd6ffc82baca468c32d247a9eca84e
+c8203aaf937c82f2601000030820122300d06092a864886f70d01010105000382010f
+003082010a0282010100ac74a8f4fb5ff9c1a0338278598eb9c6ba0fce0774e5f2dfe7
+d8aff70c0cb2535a834e125f1581127f7a6f5d3f86dc5195fd7a4b1c92b26bd6422d7d
+de63f255b1782446868cb7bfdc3b992ccb233a52ef9c4d5f81954926ca92954b14f8
+ec50a095dd5556832565712fd9d41cd934410056864573af7d8187d1774c6a004b9
+eb712a907ec5944e75acd901cfb09a1ce230815caae69da3a0b6bf6fb6d63156b21b
+ed1917331c4f1421eaa8dbb232f7832dcc35e7a6e6907f62df44fe4a73cd3f2380
+dfc7a5e2e2fc64ce1596966c7c411f63ad2e19c0339354c53083b31e8cfb923799d5
+bbaa8c2d6bf92187fe3ae13fe30eabe346242d110203010001
+Key·0xf05368c0:
+f7050000f3050000ad0300002c00000028000000030100002000000079e4450ba1925f
+eaf4d8e28d350f4ac895d4f89aad38e69ed608a5af8236d030000690300003082
+03653082024da003020102020863707fe532bb2ae7300d06092a864886f70d01010b05
+003060310b300906035504061302554b310c300a060355040813034f5247310c300a06
+0355040713034f524731133011060355040a130a6664726f69642e6f7267310f300d06
+0355040b13064644726f6964310f300d060355040313064644726f69643020170d3236
+303632373135343331325a180f32303533313131323135343331325a3060310b300906
+035504061302554b310c300a060355040813034f5247310c300a060355040713034f52
+4731133011060355040a130a6664726f69642e6f7267310f300d060355040b13064644
+f6964310f300d060355040313064644726f696430820122300d06092a864886f70d
+01010105000382010f003082010a0282010100ac74a8f4fb5ff9c1a0338278598eb9c6
+ba0fce0774e5f2dfe7d8aff70c0cb2535a834e125f1581127f7a6f5d3f86dc5195fd7a
+b1c92b26bd6422d7d34de63f255b1782446868cb7bfdc3b992ccb233a52ef9c4d5f81
+ca92954b14f8046ec50a095dd5556832565712fd9d41cd934410056864573af7
+d8187d1774c6a004b928eb712a907ec5944e75acd901cfb09a1ce230815caae69da3a0
+b6bf6fb6d63156b21b8922ed1917331c4f1421eaa8dbb232f7832dcc35e7a6e6907f62
+df44fe4a73cd3f238002dfc7a5e2e2fc64ce1596966c7c411f63ad2e19c0339354c530
+b31e8cfb923799d505bbaa8c2d6bf92187fe3ae13fe30eabe346242d110203010001
+a321301f301d0603551d0e04160414ecb0d0226aa2fe884f4897c348146f3ffffc96b7
+d06092a864886f70d01010b0500038201010048373d1fdd119f7858e6e3c2e5c181
+b3ed8072b53c4ab90889efb9b8cd0c23eab3e01752c48305ee01f073d5a108e62196d4
+ce553bb0022a0055cac40979bccc03c1a6c90ee4baaad9f217f746731470b128bfd3b2
+d67879509be45a91d5042396036d3b05594d1f5055dca470801751296b3c5f4d72ece
+c04320cbbb69ee8a6d9d39309916850db9939afdfca7c90755c57a88fe82343d2b02cb
+fa45c1467ddc6e81e59fadd39925d9b2e62e85c55625247f04ce42a115ae52a52dec25
+f249cf08a392f7efb473a319ea4e410e74bb516475b7c881610fb95a013a9209c4243c
+bff03e2a50f4c1e6da3bad7c6a918afeeb7472bc45ad09efe63b472018000000
+ffffff7f0000000018000000ffffff7f0c01000008010000030100000001000000d108
+ce8610437b20888ed3f752b7cede7790989f002b065d2a6e027150538ef2de15c8c198
+f3fbbb1756799e80bf8cebc14f955a7246df7b276b3a31e8b2373d70c261bd0ea7eb48
+b54cce3cd4d0865aff9ba74dfc24a5ba0aa4cbc8bf83078819f42693a211c59a5
+a6e9a3063bd6be891b7ba065b96fe2762a19fa281e6b7be61925455f0ab03939af8e8c
+e4c8f17b419578e88e232467256c052e5c3db9ae2adfe708297dc93cdea10b76a49bd0
+d4d84759e04208fecee8a2758dc31f07b1e1163b26948b6fc050b291a9bc973d054
+a92f89039d2b6fa93957a9a1a191c02c7fbb79e1c2ba6da0b69273ba678eae73
+fd54897bd3cb23022601000030820122300d06092a864886f70d01010105000382010f
+003082010a0282010100ac74a8f4fb5ff9c1a0338278598eb9c6ba0fce0774e5f2dfe7
+d8aff70c0cb2535a834e125f1581127f7a6f5d3f86dc5195fd7a4b1c92b26bd6422d7d
+de63f255b1782446868cb7bfdc3b992ccb233a52ef9c4d5f81954926ca92954b14f8
+ec50a095dd5556832565712fd9d41cd934410056864573af7d8187d1774c6a004b9
+eb712a907ec5944e75acd901cfb09a1ce230815caae69da3a0b6bf6fb6d63156b21b
+ed1917331c4f1421eaa8dbb232f7832dcc35e7a6e6907f62df44fe4a73cd3f2380
+dfc7a5e2e2fc64ce1596966c7c411f63ad2e19c0339354c53083b31e8cfb923799d5
+bbaa8c2d6bf92187fe3ae13fe30eabe346242d110203010001


Offset 477, 33 lines modified		Offset 477, 33 lines modified

477	Filename:·charset_normalizer/cli/__init__.py	477	Filename:·charset_normalizer/cli/__init__.py
478	Comment:·	478	Comment:·

479	Filename:·charset_normalizer/cli/__main__.py	479	Filename:·charset_normalizer/cli/__main__.py
480	Comment:·	480	Comment:·

481	Filename:·charset_normalizer-3.4.9.dist-info/	481	Filename:·charset_normalizer-3.5.2.dist-info/
482	Comment:·	482	Comment:·

483	Filename:·charset_normalizer-3.4.9.dist-info/INSTALLER	483	Filename:·charset_normalizer-3.5.2.dist-info/INSTALLER
484	Comment:·	484	Comment:·

485	Filename:·charset_normalizer-3.4.9.dist-info/METADATA	485	Filename:·charset_normalizer-3.5.2.dist-info/METADATA
486	Comment:·	486	Comment:·

487	Filename:·charset_normalizer-3.4.9.dist-info/entry_points.txt	487	Filename:·charset_normalizer-3.5.2.dist-info/entry_points.txt
488	Comment:·	488	Comment:·

489	Filename:·charset_normalizer-3.4.9.dist-info/top_level.txt	489	Filename:·charset_normalizer-3.5.2.dist-info/top_level.txt
490	Comment:·	490	Comment:·

491	Filename:·charset_normalizer-3.4.9.dist-info/licenses/	491	Filename:·charset_normalizer-3.5.2.dist-info/licenses/
492	Comment:·	492	Comment:·

493	Filename:·charset_normalizer-3.4.9.dist-info/licenses/LICENSE	493	Filename:·charset_normalizer-3.5.2.dist-info/licenses/LICENSE
494	Comment:·	494	Comment:·

495	Filename:·css_parser/	495	Filename:·css_parser/
496	Comment:·	496	Comment:·

497	Filename:·css_parser/__init__.py	497	Filename:·css_parser/__init__.py
498	Comment:·	498	Comment:·
Offset 699, 27 lines modified		Offset 699, 27 lines modified

699	Filename:·cssselect2/parser.py	699	Filename:·cssselect2/parser.py
700	Comment:·	700	Comment:·

701	Filename:·cssselect2/tree.py	701	Filename:·cssselect2/tree.py
702	Comment:·	702	Comment:·

703	Filename:·cssselect2-0.9.0.dist-info/	703	Filename:·cssselect2-0.10.1.dist-info/
704	Comment:·	704	Comment:·

705	Filename:·cssselect2-0.9.0.dist-info/INSTALLER	705	Filename:·cssselect2-0.10.1.dist-info/INSTALLER
706	Comment:·	706	Comment:·

707	Filename:·cssselect2-0.9.0.dist-info/METADATA	707	Filename:·cssselect2-0.10.1.dist-info/METADATA
708	Comment:·	708	Comment:·

709	Filename:·cssselect2-0.9.0.dist-info/licenses/	709	Filename:·cssselect2-0.10.1.dist-info/licenses/
710	Comment:·	710	Comment:·

711	Filename:·cssselect2-0.9.0.dist-info/licenses/LICENSE	711	Filename:·cssselect2-0.10.1.dist-info/licenses/LICENSE
712	Comment:·	712	Comment:·

713	Filename:·dateutil/	713	Filename:·dateutil/
714	Comment:·	714	Comment:·

715	Filename:·dateutil/__init__.py	715	Filename:·dateutil/__init__.py
716	Comment:·	716	Comment:·
Offset 903, 30 lines modified		Offset 903, 36 lines modified

903	Filename:·filelock/_soft_rw/__init__.py	903	Filename:·filelock/_soft_rw/__init__.py
904	Comment:·	904	Comment:·

905	Filename:·filelock/_soft_rw/_async.py	905	Filename:·filelock/_soft_rw/_async.py
906	Comment:·	906	Comment:·

		907	Filename:·filelock/_soft_rw/_protocol.py
		908	Comment:·

		909	Filename:·filelock/_soft_rw/_storage.py
		910	Comment:·

907	Filename:·filelock/_soft_rw/_sync.py	911	Filename:·filelock/_soft_rw/_sync.py
908	Comment:·	912	Comment:·

909	Filename:·filelock-3.32.0.dist-info/	913	Filename:·filelock-4.1.1.dist-info/
910	Comment:·	914	Comment:·

911	Filename:·filelock-3.32.0.dist-info/INSTALLER	915	Filename:·filelock-4.1.1.dist-info/INSTALLER
912	Comment:·	916	Comment:·

913	Filename:·filelock-3.32.0.dist-info/METADATA	917	Filename:·filelock-4.1.1.dist-info/METADATA
914	Comment:·	918	Comment:·

915	Filename:·filelock-3.32.0.dist-info/licenses/	919	Filename:·filelock-4.1.1.dist-info/licenses/
916	Comment:·	920	Comment:·

917	Filename:·filelock-3.32.0.dist-info/licenses/LICENSE	921	Filename:·filelock-4.1.1.dist-info/licenses/LICENSE
918	Comment:·	922	Comment:·

919	Filename:·html2text/	923	Filename:·html2text/
920	Comment:·	924	Comment:·

921	Filename:·html2text/__init__.py	925	Filename:·html2text/__init__.py
922	Comment:·	926	Comment:·
Offset 2025, 30 lines modified		Offset 2031, 30 lines modified

2025	Filename:·reportlab/platypus/tables.py	2031	Filename:·reportlab/platypus/tables.py
2026	Comment:·	2032	Comment:·

2027	Filename:·reportlab/platypus/xpreformatted.py	2033	Filename:·reportlab/platypus/xpreformatted.py
2028	Comment:·	2034	Comment:·

2029	Filename:·reportlab-5.0.0.dist-info/	2035	Filename:·reportlab-5.0.1.dist-info/
2030	Comment:·	2036	Comment:·

2031	Filename:·reportlab-5.0.0.dist-info/INSTALLER	2037	Filename:·reportlab-5.0.1.dist-info/INSTALLER
2032	Comment:·	2038	Comment:·

2033	Filename:·reportlab-5.0.0.dist-info/METADATA	2039	Filename:·reportlab-5.0.1.dist-info/METADATA
2034	Comment:·	2040	Comment:·

2035	Filename:·reportlab-5.0.0.dist-info/top_level.txt	2041	Filename:·reportlab-5.0.1.dist-info/top_level.txt
2036	Comment:·	2042	Comment:·

2037	Filename:·reportlab-5.0.0.dist-info/licenses/	2043	Filename:·reportlab-5.0.1.dist-info/licenses/
2038	Comment:·	2044	Comment:·

2039	Filename:·reportlab-5.0.0.dist-info/licenses/LICENSE	2045	Filename:·reportlab-5.0.1.dist-info/licenses/LICENSE
2040	Comment:·	2046	Comment:·

2041	Filename:·six-1.17.0.dist-info/	2047	Filename:·six-1.17.0.dist-info/
2042	Comment:·	2048	Comment:·

Max diff block lines reached; 2561/6172 bytes (41.49%) of diff not shown.


Offset 3532, 35923 lines modified		Offset 3532, 35872 lines modified
3532	07746D·Extract·Zip·Spec······14·(20)·'2.0'	3532	07746D·Extract·Zip·Spec······14·(20)·'2.0'
3533	07746E·Extract·OS············00·(0)·'MS-DOS'	3533	07746E·Extract·OS············00·(0)·'MS-DOS'
3534	07746F·General·Purpose·Flag··0800·(2048)	3534	07746F·General·Purpose·Flag··0800·(2048)
3535	·······[Bits·1-2]············0·'Normal·Compression'	3535	·······[Bits·1-2]············0·'Normal·Compression'
3536	·······[Bit·11]··············1·'Language·Encoding'	3536	·······[Bit·11]··············1·'Language·Encoding'
3537	077471·Compression·Method····0008·(8)·'Deflated'	3537	077471·Compression·Method····0008·(8)·'Deflated'
3538	077473·Modification·Time·····00410000·(4259840)·'Fri·Feb··1·00:00:00·1980'	3538	077473·Modification·Time·····00410000·(4259840)·'Fri·Feb··1·00:00:00·1980'
3539	077477·CRC···················~~84EED9B3~~·(2230245811)	3539	077477·CRC···················36D9FA28·(920255016)
3540	07747B·Compressed·Size·······00000324·(~~804~~)	3540	07747B·Compressed·Size·······0000031C·(796)
3541	07747F·Uncompressed·Size·····00000636·(1590)	3541	07747F·Uncompressed·Size·····0000062E·(1582)
3542	077483·Filename·Length·······001E·(30)	3542	077483·Filename·Length·······001E·(30)
3543	077485·Extra·Length··········0014·(20)	3543	077485·Extra·Length··········0014·(20)
3544	077487·Filename··············'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'	3544	077487·Filename··············'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
3545	#	3545	#
3546	#·WARNING:·Offset·0x77487:·Filename·'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'	3546	#·WARNING:·Offset·0x77487:·Filename·'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
3547	#··········Zero·length·filename	3547	#··········Zero·length·filename
3548	#	3548	#
3549	0774A5·Extra·ID·#1···········0001·(1)·'ZIP64'	3549	0774A5·Extra·ID·#1···········0001·(1)·'ZIP64'
3550	0774A7···Length··············0010·(16)	3550	0774A7···Length··············0010·(16)
3551	0774A9···Uncompressed·Size···0000000000000636·(1590)	3551	0774A9···Uncompressed·Size···000000000000062E·(1582)
3552	0774B1···Compressed·Size·····0000000000000324·(~~804~~)	3552	0774B1···Compressed·Size·····000000000000031C·(796)
3553	0774B9·PAYLOAD	3553	0774B9·PAYLOAD
Diff chunk too large, falling back to line-by-line diff (2567 lines added, 2567 lines removed)

3554	0777DD·LOCAL·HEADER·#149·····04034B50·(67324752)	3554	0777D5·LOCAL·HEADER·#149·····04034B50·(67324752)
3555	0777E1·Extract·Zip·Spec······14·(20)·'2.0'	3555	0777D9·Extract·Zip·Spec······14·(20)·'2.0'
3556	0777E2·Extract·OS············00·(0)·'MS-DOS'	3556	0777DA·Extract·OS············00·(0)·'MS-DOS'
3557	0777E3·General·Purpose·Flag··0800·(2048)	3557	0777DB·General·Purpose·Flag··0800·(2048)
3558	·······[Bits·1-2]············0·'Normal·Compression'	3558	·······[Bits·1-2]············0·'Normal·Compression'
3559	·······[Bit·11]··············1·'Language·Encoding'	3559	·······[Bit·11]··············1·'Language·Encoding'
3560	0777E5·Compression·Method····0008·(8)·'Deflated'	3560	0777DD·Compression·Method····0008·(8)·'Deflated'
3561	0777E7·Modification·Time·····00410000·(4259840)·'Fri·Feb··1·00:00:00·1980'	3561	0777DF·Modification·Time·····00410000·(4259840)·'Fri·Feb··1·00:00:00·1980'
3562	0777EB·CRC···················35633DF4·(895696372)	3562	0777E3·CRC···················35633DF4·(895696372)
3563	0777EF·Compressed·Size·······00000055·(85)	3563	0777E7·Compressed·Size·······00000055·(85)
3564	0777F3·Uncompressed·Size·····0000006D·(109)	3564	0777EB·Uncompressed·Size·····0000006D·(109)
3565	0777F7·Filename·Length·······001E·(30)	3565	0777EF·Filename·Length·······001E·(30)
3566	0777F9·Extra·Length··········0014·(20)	3566	0777F1·Extra·Length··········0014·(20)
3567	0777FB·Filename··············'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'	3567	0777F3·Filename··············'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
3568	#	3568	#
3569	#·WARNING:·Offset·0x777FB:·Filename·'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'	3569	#·WARNING:·Offset·0x777F3:·Filename·'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
3570	#··········Zero·length·filename	3570	#··········Zero·length·filename
3571	#	3571	#
3572	077819·Extra·ID·#1···········0001·(1)·'ZIP64'	3572	077811·Extra·ID·#1···········0001·(1)·'ZIP64'
3573	07781B···Length··············0010·(16)	3573	077813···Length··············0010·(16)
3574	07781D···Uncompressed·Size···000000000000006D·(109)	3574	077815···Uncompressed·Size···000000000000006D·(109)
3575	077825···Compressed·Size·····0000000000000055·(85)	3575	07781D···Compressed·Size·····0000000000000055·(85)
3576	07782D·PAYLOAD···············XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX	3576	077825·PAYLOAD···············XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

3577	077882·LOCAL·HEADER·#150·····04034B50·(67324752)	3577	07787A·LOCAL·HEADER·#150·····04034B50·(67324752)
3578	077886·Extract·Zip·Spec······14·(20)·'2.0'	3578	07787E·Extract·Zip·Spec······14·(20)·'2.0'
3579	077887·Extract·OS············00·(0)·'MS-DOS'	3579	07787F·Extract·OS············00·(0)·'MS-DOS'
3580	077888·General·Purpose·Flag··0800·(2048)	3580	077880·General·Purpose·Flag··0800·(2048)
3581	·······[Bits·1-2]············0·'Normal·Compression'	3581	·······[Bits·1-2]············0·'Normal·Compression'
3582	·······[Bit·11]··············1·'Language·Encoding'	3582	·······[Bit·11]··············1·'Language·Encoding'
3583	07788A·Compression·Method····0008·(8)·'Deflated'	3583	077882·Compression·Method····0008·(8)·'Deflated'
3584	07788C·Modification·Time·····00410000·(4259840)·'Fri·Feb··1·00:00:00·1980'	3584	077884·Modification·Time·····00410000·(4259840)·'Fri·Feb··1·00:00:00·1980'
3585	077890·CRC···················~~FABFCC0~~E·(4~~2068736~~14)	3585	077888·CRC···················155BD86E·(358340718)
3586	077894·Compressed·Size·······00002~~504~~·(9476)	3586	07788C·Compressed·Size·······000020BB·(8379)
3587	077898·Uncompressed·Size·····0000~~A555~~·(~~42325~~)	3587	077890·Uncompressed·Size·····00008BBE·(35774)
3588	07789C·Filename·Length·······0019·(25)	3588	077894·Filename·Length·······0019·(25)
3589	07789E·Extra·Length··········0014·(20)	3589	077896·Extra·Length··········0014·(20)
3590	0778A0·Filename··············'XXXXXXXXXXXXXXXXXXXXXXXXX'	3590	077898·Filename··············'XXXXXXXXXXXXXXXXXXXXXXXXX'
3591	#	3591	#
3592	#·WARNING:·Offset·0x778A0:·Filename·'XXXXXXXXXXXXXXXXXXXXXXXXX'	3592	#·WARNING:·Offset·0x77898:·Filename·'XXXXXXXXXXXXXXXXXXXXXXXXX'
3593	#··········Zero·length·filename	3593	#··········Zero·length·filename
3594	#	3594	#
3595	0778B9·Extra·ID·#1···········0001·(1)·'ZIP64'	3595	0778B1·Extra·ID·#1···········0001·(1)·'ZIP64'
3596	0778BB···Length··············0010·(16)	3596	0778B3···Length··············0010·(16)
3597	0778BD···Uncompressed·Size···000000000000~~A555~~·(~~42325~~)	3597	0778B5···Uncompressed·Size···0000000000008BBE·(35774)
3598	0778C5···Compressed·Size·····0000000000002~~504~~·(9476)	3598	0778BD···Compressed·Size·····00000000000020BB·(8379)
3599	0778CD·PAYLOAD	3599	0778C5·PAYLOAD

3600	079~~DD1~~·LOCAL·HEADER·#151·····04034B50·(67324752)	3600	079980·LOCAL·HEADER·#151·····04034B50·(67324752)
3601	079~~DD5~~·Extract·Zip·Spec······14·(20)·'2.0'	3601	079984·Extract·Zip·Spec······14·(20)·'2.0'
3602	079~~DD6~~·Extract·OS············00·(0)·'MS-DOS'	3602	079985·Extract·OS············00·(0)·'MS-DOS'
3603	079~~DD7~~·General·Purpose·Flag··0800·(2048)	3603	079986·General·Purpose·Flag··0800·(2048)
3604	·······[Bits·1-2]············0·'Normal·Compression'	3604	·······[Bits·1-2]············0·'Normal·Compression'
3605	·······[Bit·11]··············1·'Language·Encoding'	3605	·······[Bit·11]··············1·'Language·Encoding'
3606	079~~DD9~~·Compression·Method····0008·(8)·'Deflated'	3606	079988·Compression·Method····0008·(8)·'Deflated'
3607	079~~DDB~~·Modification·Time·····00410000·(4259840)·'Fri·Feb··1·00:00:00·1980'	3607	07998A·Modification·Time·····00410000·(4259840)·'Fri·Feb··1·00:00:00·1980'
3608	079~~DDF~~·CRC···················16049338·(369398584)	3608	07998E·CRC···················16049338·(369398584)
3609	079~~DE3~~·Compressed·Size·······000010D3·(4307)	3609	079992·Compressed·Size·······000010D3·(4307)
3610	079~~DE7~~·Uncompressed·Size·····00003E6C·(15980)	3610	079996·Uncompressed·Size·····00003E6C·(15980)
3611	079~~DEB~~·Filename·Length·······0018·(24)	3611	07999A·Filename·Length·······0018·(24)
3612	079~~DED~~·Extra·Length··········0014·(20)	3612	07999C·Extra·Length··········0014·(20)
3613	079~~DEF~~·Filename··············'XXXXXXXXXXXXXXXXXXXXXXXX'	3613	07999E·Filename··············'XXXXXXXXXXXXXXXXXXXXXXXX'
3614	#	3614	#
3615	#·WARNING:·Offset·0x79~~DEF~~:·Filename·'XXXXXXXXXXXXXXXXXXXXXXXX'	3615	#·WARNING:·Offset·0x7999E:·Filename·'XXXXXXXXXXXXXXXXXXXXXXXX'
3616	#··········Zero·length·filename	3616	#··········Zero·length·filename
3617	#	3617	#
3618	079~~E07~~·Extra·ID·#1···········0001·(1)·'ZIP64'	3618	0799B6·Extra·ID·#1···········0001·(1)·'ZIP64'
3619	079~~E09~~···Length··············0010·(16)	3619	0799B8···Length··············0010·(16)
3620	079~~E0B~~···Uncompressed·Size···0000000000003E6C·(15980)	3620	0799BA···Uncompressed·Size···0000000000003E6C·(15980)
3621	079~~E13~~···Compressed·Size·····00000000000010D3·(4307)	3621	0799C2···Compressed·Size·····00000000000010D3·(4307)
3622	079~~E1B~~·PAYLOAD	3622	0799CA·PAYLOAD

3623	07A~~EEE~~·LOCAL·HEADER·#152·····04034B50·(67324752)	3623	07AA9D·LOCAL·HEADER·#152·····04034B50·(67324752)
3624	07A~~EF2~~·Extract·Zip·Spec······14·(20)·'2.0'	3624	07AAA1·Extract·Zip·Spec······14·(20)·'2.0'
3625	07A~~EF3~~·Extract·OS············00·(0)·'MS-DOS'	3625	07AAA2·Extract·OS············00·(0)·'MS-DOS'
3626	07A~~EF4~~·General·Purpose·Flag··0800·(2048)	3626	07AAA3·General·Purpose·Flag··0800·(2048)
3627	·······[Bits·1-2]············0·'Normal·Compression'	3627	·······[Bits·1-2]············0·'Normal·Compression'
3628	·······[Bit·11]··············1·'Language·Encoding'	3628	·······[Bit·11]··············1·'Language·Encoding'
3629	07A~~EF6~~·Compression·Method····0008·(8)·'Deflated'	3629	07AAA5·Compression·Method····0008·(8)·'Deflated'
3630	07A~~EF8~~·Modification·Time·····00410000·(4259840)·'Fri·Feb··1·00:00:00·1980'	3630	07AAA7·Modification·Time·····00410000·(4259840)·'Fri·Feb··1·00:00:00·1980'
3631	07A~~EFC~~·CRC···················~~57A86875~~·(147065~~4581~~)	3631	07AAAB·CRC···················FA97DBAA·(4204256170)
3632	07A~~F00~~·Compressed·Size·······00003~~253~~·(1~~2883~~)	3632	07AAAF·Compressed·Size·······00003DB4·(15796)
3633	07A~~F04~~·Uncompressed·Size·····0000~~AE50~~·(~~44624~~)	3633	07AAB3·Uncompressed·Size·····0000ED8C·(60812)
3634	07A~~F08~~·Filename·Length·······001E·(30)	3634	07AAB7·Filename·Length·······001E·(30)
3635	07A~~F0A~~·Extra·Length··········0014·(20)	3635	07AAB9·Extra·Length··········0014·(20)
3636	07A~~F0C~~·Filename··············'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'	3636	07AABB·Filename··············'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
3637	#	3637	#
3638	#·WARNING:·Offset·0x7A~~F0C~~:·Filename·'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'	3638	#·WARNING:·Offset·0x7AABB:·Filename·'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
3639	#··········Zero·length·filename	3639	#··········Zero·length·filename
3640	#	3640	#
3641	07A~~F2A~~·Extra·ID·#1···········0001·(1)·'ZIP64'	3641	07AAD9·Extra·ID·#1···········0001·(1)·'ZIP64'
3642	07A~~F2C~~···Length··············0010·(16)	3642	07AADB···Length··············0010·(16)
3643	07A~~F2E~~···Uncompressed·Size···000000000000~~AE50~~·(~~44624~~)	3643	07AADD···Uncompressed·Size···000000000000ED8C·(60812)
3644	07A~~F36~~···Compressed·Size·····0000000000003~~253~~·(1~~2883~~)	3644	07AAE5···Compressed·Size·····0000000000003DB4·(15796)
3645	07A~~F3E~~·PAYLOAD	3645	07AAED·PAYLOAD

3646	07E191·LOCAL·HEADER·#153·····04034B50·(67324752)	3646	07E8A1·LOCAL·HEADER·#153·····04034B50·(67324752)
3647	07E195·Extract·Zip·Spec······14·(20)·'2.0'	3647	07E8A5·Extract·Zip·Spec······14·(20)·'2.0'
3648	07E196·Extract·OS············00·(0)·'MS-DOS'	3648	07E8A6·Extract·OS············00·(0)·'MS-DOS'
3649	07E197·General·Purpose·Flag··0800·(2048)	3649	07E8A7·General·Purpose·Flag··0800·(2048)
3650	·······[Bits·1-2]············0·'Normal·Compression'	3650	·······[Bits·1-2]············0·'Normal·Compression'
3651	·······[Bit·11]··············1·'Language·Encoding'	3651	·······[Bit·11]··············1·'Language·Encoding'
3652	07E199·Compression·Method····0008·(8)·'Deflated'	3652	07E8A9·Compression·Method····0008·(8)·'Deflated'
Max diff block lines reached; 2670662/2891635 bytes (92.36%) of diff not shown.


Offset 1, 8 lines modified		Offset 1, 8 lines modified
1	Zip·file·size:·63374044·bytes,·number·of·entries:·218	1	Zip·file·size:·63398005·bytes,·number·of·entries:·215
2	-rw-r--r--··0.0·unx·······56·b-·defN·81-Jan-01·01:01·META-INF/com/android/build/gradle/app-metadata.properties	2	-rw-r--r--··0.0·unx·······56·b-·defN·81-Jan-01·01:01·META-INF/com/android/build/gradle/app-metadata.properties
3	-rw-r--r--··0.0·unx······120·b-·defN·81-Jan-01·01:01·META-INF/version-control-info.textproto	3	-rw-r--r--··0.0·unx······120·b-·defN·81-Jan-01·01:01·META-INF/version-control-info.textproto
4	-rw-r--r--··0.0·unx·····6978·b-·stor·81-Jan-01·01:01·assets/dexopt/baseline.prof	4	-rw-r--r--··0.0·unx·····6978·b-·stor·81-Jan-01·01:01·assets/dexopt/baseline.prof
5	-rw-r--r--··0.0·unx······391·b-·stor·81-Jan-01·01:01·assets/dexopt/baseline.profm	5	-rw-r--r--··0.0·unx······391·b-·stor·81-Jan-01·01:01·assets/dexopt/baseline.profm
6	-rw-r--r--··0.0·unx·13583992·b-·defN·81-Jan-01·01:01·classes.dex	6	-rw-r--r--··0.0·unx·13583992·b-·defN·81-Jan-01·01:01·classes.dex
7	-rw-r--r--··0.0·unx··4070252·b-·defN·81-Jan-01·01:01·classes2.dex	7	-rw-r--r--··0.0·unx··4070252·b-·defN·81-Jan-01·01:01·classes2.dex
8	-rw-r--r--··0.0·unx····10096·b-·stor·81-Jan-01·01:01·lib/arm64-v8a/libandroidx.graphics.path.so	8	-rw-r--r--··0.0·unx····10096·b-·stor·81-Jan-01·01:01·lib/arm64-v8a/libandroidx.graphics.path.so
Offset 70, 15 lines modified		Offset 70, 15 lines modified
70	-rw-r--r--··0.0·unx····24336·b-·stor·81-Jan-01·01:01·assets/chaquopy/bootstrap-native/x86_64/mmap.so	70	-rw-r--r--··0.0·unx····24336·b-·stor·81-Jan-01·01:01·assets/chaquopy/bootstrap-native/x86_64/mmap.so
71	-rw-r--r--··0.0·unx····37608·b-·stor·81-Jan-01·01:01·assets/chaquopy/bootstrap-native/x86_64/zlib.so	71	-rw-r--r--··0.0·unx····37608·b-·stor·81-Jan-01·01:01·assets/chaquopy/bootstrap-native/x86_64/zlib.so
72	-rw-r--r--··0.0·unx···624933·b-·stor·81-Jan-01·01:01·assets/chaquopy/bootstrap.imy	72	-rw-r--r--··0.0·unx···624933·b-·stor·81-Jan-01·01:01·assets/chaquopy/bootstrap.imy
73	-rw-r--r--··0.0·unx·····4242·b-·defN·81-Jan-01·01:01·assets/chaquopy/build.json	73	-rw-r--r--··0.0·unx·····4242·b-·defN·81-Jan-01·01:01·assets/chaquopy/build.json
74	-rw-r--r--··0.0·unx···299427·b-·defN·81-Jan-01·01:01·assets/chaquopy/cacert.pem	74	-rw-r--r--··0.0·unx···299427·b-·defN·81-Jan-01·01:01·assets/chaquopy/cacert.pem
75	-rw-r--r--··0.0·unx··2594339·b-·stor·81-Jan-01·01:01·assets/chaquopy/requirements-arm64-v8a.imy	75	-rw-r--r--··0.0·unx··2594339·b-·stor·81-Jan-01·01:01·assets/chaquopy/requirements-arm64-v8a.imy
76	-rw-r--r--··0.0·unx··2315511·b-·stor·81-Jan-01·01:01·assets/chaquopy/requirements-armeabi-v7a.imy	76	-rw-r--r--··0.0·unx··2315511·b-·stor·81-Jan-01·01:01·assets/chaquopy/requirements-armeabi-v7a.imy
77	-rw-r--r--··0.0·unx··37~~34889~~·b-·stor·81-Jan-01·01:01·assets/chaquopy/requirements-common.imy	77	-rw-r--r--··0.0·unx··3780927·b-·stor·81-Jan-01·01:01·assets/chaquopy/requirements-common.imy
78	-rw-r--r--··0.0·unx··2725620·b-·stor·81-Jan-01·01:01·assets/chaquopy/requirements-x86_64.imy	78	-rw-r--r--··0.0·unx··2725620·b-·stor·81-Jan-01·01:01·assets/chaquopy/requirements-x86_64.imy
79	-rw-r--r--··0.0·unx··1478595·b-·stor·81-Jan-01·01:01·assets/chaquopy/stdlib-arm64-v8a.imy	79	-rw-r--r--··0.0·unx··1478595·b-·stor·81-Jan-01·01:01·assets/chaquopy/stdlib-arm64-v8a.imy
80	-rw-r--r--··0.0·unx··1386480·b-·stor·81-Jan-01·01:01·assets/chaquopy/stdlib-armeabi-v7a.imy	80	-rw-r--r--··0.0·unx··1386480·b-·stor·81-Jan-01·01:01·assets/chaquopy/stdlib-armeabi-v7a.imy
81	-rw-r--r--··0.0·unx··4812526·b-·stor·81-Jan-01·01:01·assets/chaquopy/stdlib-common.imy	81	-rw-r--r--··0.0·unx··4812526·b-·stor·81-Jan-01·01:01·assets/chaquopy/stdlib-common.imy
82	-rw-r--r--··0.0·unx··1508233·b-·stor·81-Jan-01·01:01·assets/chaquopy/stdlib-x86_64.imy	82	-rw-r--r--··0.0·unx··1508233·b-·stor·81-Jan-01·01:01·assets/chaquopy/stdlib-x86_64.imy
83	-rw----·····2.4·fat·····1738·b-·defN·81-Jan-01·01:01·DebugProbesKt.bin	83	-rw----·····2.4·fat·····1738·b-·defN·81-Jan-01·01:01·DebugProbesKt.bin
84	-rw----·····2.4·fat········6·b-·stor·81-Jan-01·01:01·META-INF/androidx.activity_activity-compose.version	84	-rw----·····2.4·fat········6·b-·stor·81-Jan-01·01:01·META-INF/androidx.activity_activity-compose.version
Offset 210, 11 lines modified		Offset 210, 8 lines modified
210	-rw----·····0.0·fat······225·b-·stor·81-Jan-01·01:01·res/wN.9.png	210	-rw----·····0.0·fat······225·b-·stor·81-Jan-01·01:01·res/wN.9.png
211	-rw----·····0.0·fat·····2456·b-·defN·81-Jan-01·01:01·res/xN.xml	211	-rw----·····0.0·fat·····2456·b-·defN·81-Jan-01·01:01·res/xN.xml
212	-rw----·····0.0·fat······221·b-·stor·81-Jan-01·01:01·res/xa.9.png	212	-rw----·····0.0·fat······221·b-·stor·81-Jan-01·01:01·res/xa.9.png
213	-rw----·····0.0·fat······221·b-·stor·81-Jan-01·01:01·res/z-.9.png	213	-rw----·····0.0·fat······221·b-·stor·81-Jan-01·01:01·res/z-.9.png
214	-rw----·····0.0·fat······206·b-·stor·81-Jan-01·01:01·res/zL.png	214	-rw----·····0.0·fat······206·b-·stor·81-Jan-01·01:01·res/zL.png
215	-rw----·····0.0·fat······884·b-·stor·81-Jan-01·01:01·res/zz.png	215	-rw----·····0.0·fat······884·b-·stor·81-Jan-01·01:01·res/zz.png
216	-rw----·····0.0·fat···415976·b-·stor·81-Jan-01·01:01·resources.arsc	216	-rw----·····0.0·fat···415976·b-·stor·81-Jan-01·01:01·resources.arsc
217	-rw----·····2.0·fat····22646·b-·defN·81-Jan-01·01:01·META-INF/57818ACA.SF
218	-rw----·····2.0·fat·····1344·b-·defN·81-Jan-01·01:01·META-INF/57818ACA.RSA
219	-rw----·····2.0·fat····22519·b-·defN·81-Jan-01·01:01·META-INF/MANIFEST.MF
220	218·files,·7475~~8203~~·bytes·uncompressed,·628~~4848~~2·bytes·compressed:··15.9%	217	215·files,·74757732·bytes·uncompressed,·62876922·bytes·compressed:··15.9%


Offset 11, 15 lines modified		Offset 11, 15 lines modified
11	···>>>·results·=·from_bytes('Bсеки·човек·има·право·на·образование.·Oбразованието!'.encode('utf_8'))	11	···>>>·results·=·from_bytes('Bсеки·човек·има·право·на·образование.·Oбразованието!'.encode('utf_8'))
12	···>>>·best_guess·=·results.best()	12	···>>>·best_guess·=·results.best()
13	···>>>·str(best_guess)	13	···>>>·str(best_guess)
14	···'Bсеки·човек·има·право·на·образование.·Oбразованието!'	14	···'Bсеки·човек·има·право·на·образование.·Oбразованието!'

15	Others·methods·and·usages·are·available·-·see·the·full·documentation	15	Others·methods·and·usages·are·available·-·see·the·full·documentation
16	at·<https://github.com/Ousret/charset_normalizer>.	16	at·<https://github.com/Ousret/charset_normalizer>.
17	:copyright:·(c)·~~2021·by·~~Ahmed·TAHRI	17	:copyright:·(c)·Ahmed·TAHRI
18	:license:·MIT,·see·LICENSE·for·more·details.	18	:license:·MIT,·see·LICENSE·for·more·details.
19	"""	19	"""

20	from·__future__·import·annotations	20	from·__future__·import·annotations

21	import·logging	21	import·logging


Offset 136, 24 lines modified		Offset 136, 22 lines modified

136	····is_too_small_sequence:·bool·=·len(sequences)·<·TOO_SMALL_SEQUENCE	136	····is_too_small_sequence:·bool·=·len(sequences)·<·TOO_SMALL_SEQUENCE
137	····is_too_large_sequence:·bool·=·len(sequences)·>=·TOO_BIG_SEQUENCE	137	····is_too_large_sequence:·bool·=·len(sequences)·>=·TOO_BIG_SEQUENCE

138	····if·is_too_small_sequence:	138	····if·is_too_small_sequence:
139	········logger.log(	139	········logger.log(
140	············TRACE,	140	············TRACE,
141	············"Trying·to·detect·encoding·from·a·tiny·portion·of·({})·byte(s)."~~.format~~(	141	············"Trying·to·detect·encoding·from·a·tiny·portion·of·(%i)·byte(s).",
142	············~~····~~length	142	············length,
143	············),
144	········)	143	········)
145	····elif·is_too_large_sequence:	144	····elif·is_too_large_sequence:
146	········logger.log(	145	········logger.log(
147	············TRACE,	146	············TRACE,
148	············"Using·lazy·str·decoding·because·the·payload·is·quite·large,·({})·byte(s)."~~.format~~(	147	············"Using·lazy·str·decoding·because·the·payload·is·quite·large,·(%i)·byte(s).",
149	············~~····~~length	148	············length,
150	············),
151	········)	149	········)

152	····prioritized_encodings:·list[str]·=·[]	150	····prioritized_encodings:·list[str]·=·[]

153	····specified_encoding:·str·\|·None·=·(	151	····specified_encoding:·str·\|·None·=·(
154	········any_specified_encoding(sequences)·if·preemptive_behaviour·else·None	152	········any_specified_encoding(sequences)·if·preemptive_behaviour·else·None
155	····)	153	····)
Offset 166, 20 lines modified		Offset 164, 14 lines modified
166	············specified_encoding,	164	············specified_encoding,
167	········)	165	········)

168	····tested:·set[str]·=·set()	166	····tested:·set[str]·=·set()
169	····tested_but_hard_failure:·list[str]·=·[]	167	····tested_but_hard_failure:·list[str]·=·[]
170	····tested_but_soft_failure:·list[str]·=·[]	168	····tested_but_soft_failure:·list[str]·=·[]
171	····soft_failure_skip:·set[str]·=·set()	169	····soft_failure_skip:·set[str]·=·set()
172	····success_fast_tracked:·set[str]·=·set()

173	····#·Cache·for·decoded·payload·deduplication:·hash(decoded_payload)·->·(mean_mess_ratio,·cd_ratios_merged,·passed)
174	····#·When·multiple·encodings·decode·to·the·exact·same·string,·we·can·skip·the·expensive
175	····#·mess_ratio·and·coherence_ratio·analysis·and·reuse·the·results·from·the·first·encoding.
176	····payload_result_cache:·dict[int,·tuple[float,·list[tuple[str,·float]],·bool]]·=·{}

177	····#·Avoid·unoptimized·RSS·usage.	170	····#·Avoid·unoptimized·RSS·usage.
178	····#·this·cache·is·mostly·interesting·for	171	····#·this·cache·is·mostly·interesting·for
179	····#·local·usage.·Garbage·collected·at·the	172	····#·local·usage.·Garbage·collected·at·the
180	····#·end.·Like·it·should.	173	····#·end.·Like·it·should.
181	····cached_mess_ratio·=·lru_cache(maxsize=None)(mess_ratio)	174	····cached_mess_ratio·=·lru_cache(maxsize=None)(mess_ratio)
182	····cached_coherence_ratio·=·lru_cache(maxsize=None)(coherence_ratio)	175	····cached_coherence_ratio·=·lru_cache(maxsize=None)(coherence_ratio)
Offset 218, 15 lines modified		Offset 210, 15 lines modified
218	····results:·CharsetMatches·=·CharsetMatches()	210	····results:·CharsetMatches·=·CharsetMatches()

219	····early_stop_results:·CharsetMatches·=·CharsetMatches()	211	····early_stop_results:·CharsetMatches·=·CharsetMatches()

220	····sig_encoding,·sig_payload·=·identify_sig_or_bom(sequences)	212	····sig_encoding,·sig_payload·=·identify_sig_or_bom(sequences)

221	····if·sig_encoding·is·not·None:	213	····if·sig_encoding·is·not·None:
222	········prioritized_encodings.~~app~~end(sig_encoding)	214	········prioritized_encodings.insert(0,·sig_encoding)
223	········logger.log(	215	········logger.log(
224	············TRACE,	216	············TRACE,
225	············"Detected·a·SIG·or·BOM·mark·on·first·%i·byte(s).·Priority·+1·given·for·%s.",	217	············"Detected·a·SIG·or·BOM·mark·on·first·%i·byte(s).·Priority·+1·given·for·%s.",
226	············len(sig_payload),	218	············len(sig_payload),
227	············sig_encoding,	219	············sig_encoding,
228	········)	220	········)

Offset 274, 23 lines modified		Offset 266, 14 lines modified
274	············logger.log(	266	············logger.log(
275	················TRACE,	267	················TRACE,
276	················"%s·is·deemed·too·similar·to·a·code·page·that·was·already·considered·unsuited.·Continuing!",	268	················"%s·is·deemed·too·similar·to·a·code·page·that·was·already·considered·unsuited.·Continuing!",
277	················encoding_iana,	269	················encoding_iana,
278	············)	270	············)
279	············continue	271	············continue

280	········#·Skip·encodings·that·were·already·fast-tracked·from·a·similar·successful·encoding.
281	········if·encoding_iana·in·success_fast_tracked:
282	············logger.log(
283	················TRACE,
284	················"Skipping·%s:·already·fast-tracked·from·a·similar·successful·encoding.",
285	················encoding_iana,
286	············)
287	············continue

288	········try:	272	········try:
289	············is_multi_byte_decoder:·bool·=·is_multi_byte_encoding(encoding_iana)	273	············is_multi_byte_decoder:·bool·=·is_multi_byte_encoding(encoding_iana)
290	········except·(ModuleNotFoundError,·ImportError):··#·Defensive:	274	········except·(ModuleNotFoundError,·ImportError):··#·Defensive:
291	············logger.log(	275	············logger.log(
292	················TRACE,	276	················TRACE,
293	················"Encoding·%s·does·not·provide·an·IncrementalDecoder",	277	················"Encoding·%s·does·not·provide·an·IncrementalDecoder",
294	················encoding_iana,	278	················encoding_iana,
Offset 480, 44 lines modified		Offset 463, 41 lines modified
480	················"LazyStr·Loading:·After·MD·chunk·decode,·code·page·%s·does·not·fit·given·bytes·sequence·at·ALL.·%s",	463	················"LazyStr·Loading:·After·MD·chunk·decode,·code·page·%s·does·not·fit·given·bytes·sequence·at·ALL.·%s",
481	················encoding_iana,	464	················encoding_iana,
482	················str(e),	465	················str(e),
483	············)	466	············)
484	············early_stop_count·=·max_chunk_gave_up	467	············early_stop_count·=·max_chunk_gave_up
485	············lazy_str_hard_failure·=·True	468	············lazy_str_hard_failure·=·True

		469	········mean_mess_ratio:·float·=·sum(md_ratios)·/·len(md_ratios)·if·md_ratios·else·0.0

486	········#·We·might·want·to·check·the·sequence·again·with·the·whole·content	470	········#·We·might·want·to·check·the·sequence·again·with·the·whole·content,
487	········#·Only·if·initial·MD·tests·passes	471	········#·but·only·if·initial·MD·tests·passed.
488	········if·(	472	········if·(
489	············not·lazy_str_hard_failure	473	············not·lazy_str_hard_failure
490	············and·is_too_large_sequence	474	············and·is_too_large_sequence
491	············and·not·is_multi_byte_decoder	475	············and·not·is_multi_byte_decoder
		476	············and·mean_mess_ratio·<·threshold
		477	············and·early_stop_count·<·max_chunk_gave_up
492	········):	478	········):
493	············try:	479	············try:
494	················sequences[int(50e3)·:].decode(encoding_iana,·errors="strict")	480	················sequences[int(50e3)·:].decode(encoding_iana,·errors="strict")
495	············except·UnicodeDecodeError·as·e:	481	············except·UnicodeDecodeError·as·e:
496	················logger.log(	482	················logger.log(
497	····················TRACE,	483	····················TRACE,
498	····················"LazyStr·Loading:·After·final·lookup,·code·page·%s·does·not·fit·given·bytes·sequence·at·ALL.·%s",	484	····················"LazyStr·Loading:·After·final·lookup,·code·page·%s·does·not·fit·given·bytes·sequence·at·ALL.·%s",
499	····················encoding_iana,	485	····················encoding_iana,
500	····················str(e),	486	····················str(e),
501	················)	487	················)
502	················tested_but_hard_failure.append(encoding_iana)	488	················tested_but_hard_failure.append(encoding_iana)
503	················continue	489	················continue

504	········mean_mess_ratio:·float·=·sum(md_ratios)·/·len(md_ratios)·if·md_ratios·else·0.0
505	········if·mean_mess_ratio·>=·threshold·or·early_stop_count·>=·max_chunk_gave_up:	490	········if·mean_mess_ratio·>=·threshold·or·early_stop_count·>=·max_chunk_gave_up:
506	············tested_but_soft_failure.append(encoding_iana)	491	············tested_but_soft_failure.append(encoding_iana)
507	············if·encoding_iana·in·IANA_SUPPORTED_SIMILAR:	492	············if·encoding_iana·in·IANA_SUPPORTED_SIMILAR:
508	················soft_failure_skip.update(IANA_SUPPORTED_SIMILAR[encoding_iana])	493	················soft_failure_skip.update(IANA_SUPPORTED_SIMILAR[encoding_iana])
509	············#·Cache·this·soft-failure·so·identical·decoding·from·other·encodings
510	············#·can·be·skipped·immediately.
511	············if·decoded_payload·is·not·None·and·not·is_multi_byte_decoder:
512	················payload_result_cache.setdefault(
513	····················hash(decoded_payload),·(mean_mess_ratio,·[],·False)
514	················)
Max diff block lines reached; 9361/14866 bytes (62.97%) of diff not shown.

+····"CJK·Unified·Ideographs·Extension·J":·range(205744,·210048),
+····"Tags":·range(917504,·917632),
+····"Variation·Selectors·Supplement":·range(917760,·918000),
+····"Supplementary·Private·Use·Area-A":·range(983040,·1048576),
+····"Supplementary·Private·Use·Area-B":·range(1048576,·1114112),
+#·Canonical·family·for·every·Unicode·range·above.·Keep·this·exhaustive·and
+#·explicit:·official·block·names·are·labels,·not·a·grammar·we·should·parse.
+_RANGE_FAMILIES:·dict[str,·str]·=·{
+····"Control·character":·"Control·character",
+····"Basic·Latin":·"Latin",
+····"Latin-1·Supplement":·"Latin",
+····"Latin·Extended-A":·"Latin",
+····"Latin·Extended-B":·"Latin",
+····"IPA·Extensions":·"IPA",
+····"Spacing·Modifier·Letters":·"Spacing·Modifier·Letters",
+····"Combining·Diacritical·Marks":·"Combining",
+····"Greek·and·Coptic":·"Greek",
+····"Cyrillic":·"Cyrillic",
+····"Cyrillic·Supplement":·"Cyrillic",
+····"Armenian":·"Armenian",
+····"Hebrew":·"Hebrew",
+····"Arabic":·"Arabic",
+····"Syriac":·"Syriac",
+····"Arabic·Supplement":·"Arabic",
+····"Thaana":·"Thaana",
+····"NKo":·"NKo",
+····"Samaritan":·"Samaritan",
+····"Mandaic":·"Mandaic",
+····"Syriac·Supplement":·"Syriac",
+····"Arabic·Extended-B":·"Arabic",
+····"Arabic·Extended-A":·"Arabic",
+····"Devanagari":·"Devanagari",
+····"Bengali":·"Bengali",
+····"Gurmukhi":·"Gurmukhi",
+····"Gujarati":·"Gujarati",
+····"Oriya":·"Oriya",
+····"Tamil":·"Tamil",
+····"Telugu":·"Telugu",
+····"Kannada":·"Kannada",
+····"Malayalam":·"Malayalam",
+····"Sinhala":·"Sinhala",
+····"Thai":·"Thai",
+····"Lao":·"Lao",
+····"Tibetan":·"Tibetan",
+····"Myanmar":·"Myanmar",
+····"Georgian":·"Georgian",
+····"Hangul·Jamo":·"Hangul",
+····"Ethiopic":·"Ethiopic",
+····"Ethiopic·Supplement":·"Ethiopic",
+····"Cherokee":·"Cherokee",
+····"Unified·Canadian·Aboriginal·Syllabics":·"Unified·Canadian·Aboriginal·Syllabics",
+····"Ogham":·"Ogham",
+····"Runic":·"Runic",
+····"Tagalog":·"Tagalog",
+····"Hanunoo":·"Hanunoo",
+····"Buhid":·"Buhid",
+····"Tagbanwa":·"Tagbanwa",
+····"Khmer":·"Khmer",
+····"Mongolian":·"Mongolian",
+····"Unified·Canadian·Aboriginal·Syllabics·Extended":·"Unified·Canadian·Aboriginal·Syllabics",
+····"Limbu":·"Limbu",
+····"Tai·Le":·"Tai·Le",
+····"New·Tai·Lue":·"New·Tai·Lue",
+····"Khmer·Symbols":·"Khmer",
+····"Buginese":·"Buginese",
+····"Tai·Tham":·"Tai·Tham",
+····"Combining·Diacritical·Marks·Extended":·"Combining",
+····"Balinese":·"Balinese",
+····"Sundanese":·"Sundanese",
+····"Batak":·"Batak",
+····"Lepcha":·"Lepcha",
+····"Ol·Chiki":·"Ol·Chiki",
+····"Cyrillic·Extended-C":·"Cyrillic",
+····"Georgian·Extended":·"Georgian",
+····"Sundanese·Supplement":·"Sundanese",
+····"Vedic·Extensions":·"Vedic",
+····"Phonetic·Extensions":·"Phonetic",
+····"Phonetic·Extensions·Supplement":·"Phonetic",
+····"Combining·Diacritical·Marks·Supplement":·"Combining",
+····"Latin·Extended·Additional":·"Latin",
+····"Greek·Extended":·"Greek",
+····"General·Punctuation":·"Punctuation",
+····"Superscripts·and·Subscripts":·"Superscripts·and·Subscripts",
+····"Currency·Symbols":·"Currency·Symbols",
+····"Combining·Diacritical·Marks·for·Symbols":·"Combining",
+····"Letterlike·Symbols":·"Letterlike·Symbols",
+····"Number·Forms":·"Number·Forms",
+····"Arrows":·"Arrows",
+····"Mathematical·Operators":·"Mathematical",
+····"Miscellaneous·Technical":·"Miscellaneous·Technical",
+····"Control·Pictures":·"Control·Pictures",
+····"Optical·Character·Recognition":·"Optical·Character·Recognition",
+····"Enclosed·Alphanumerics":·"Enclosed·Alphanumerics",
+····"Box·Drawing":·"Box·Drawing",
+····"Block·Elements":·"Block·Elements",
+····"Geometric·Shapes":·"Geometric·Shapes",
+····"Miscellaneous·Symbols":·"Miscellaneous·Symbols",
+····"Dingbats":·"Dingbats",
+····"Miscellaneous·Mathematical·Symbols-A":·"Mathematical",
+····"Supplemental·Arrows-A":·"Arrows",
+····"Braille·Patterns":·"Braille",
+····"Supplemental·Arrows-B":·"Arrows",
+····"Miscellaneous·Mathematical·Symbols-B":·"Mathematical",
+····"Supplemental·Mathematical·Operators":·"Mathematical",
+····"Miscellaneous·Symbols·and·Arrows":·"Miscellaneous·Symbols·and·Arrows",
+····"Glagolitic":·"Glagolitic",
+····"Latin·Extended-C":·"Latin",
+····"Coptic":·"Coptic",
+····"Georgian·Supplement":·"Georgian",
+····"Tifinagh":·"Tifinagh",
+····"Ethiopic·Extended":·"Ethiopic",
+····"Cyrillic·Extended-A":·"Cyrillic",
+····"Supplemental·Punctuation":·"Punctuation",
+····"CJK·Radicals·Supplement":·"CJK",
+····"Kangxi·Radicals":·"CJK",
+····"Ideographic·Description·Characters":·"CJK",
+····"CJK·Symbols·and·Punctuation":·"CJK",
+····"Hiragana":·"Hiragana",
+····"Katakana":·"Katakana",
+····"Bopomofo":·"Bopomofo",
+····"Hangul·Compatibility·Jamo":·"Hangul",
+····"Kanbun":·"Kanbun",
+····"Bopomofo·Extended":·"Bopomofo",
+····"CJK·Strokes":·"CJK",
+····"Katakana·Phonetic·Extensions":·"Katakana",


Offset 1, 37 lines modified		Offset 1, 34 lines modified
1	from·__future__·import·annotations	1	from·__future__·import·annotations

2	import·sys
3	from·functools·import·lru_cache	2	from·functools·import·lru_cache
4	from·logging·import·getLogger	3	from·logging·import·getLogger

5	if·sys.version_info·>=·(3,·8):
6	····from·typing·import·final
7	else:
8	····try:
9	········from·typing_extensions·import·final
10	····except·ImportError:

11	········def·final(cls):··#·type:·ignore[misc,no-untyped-def]
12	············return·cls


13	from·.constant·import·(	4	from·.constant·import·(
14	····COMMON_CJK_CHARACTERS,	5	····COMMON_CJK_CHARACTERS,
15	····COMMON_SAFE_ASCII_CHARACTERS,	6	····COMMON_SAFE_ASCII_CHARACTERS,
16	····TRACE,	7	····TRACE,
17	····~~UNI~~C~~ODE_SECONDARY_RANGE_KEYWORD~~,	8	····CompatibleFamillyRange,
18	····_ACCENTUATED,	9	····_ACCENTUATED,
19	····_ARABIC,	10	····_ARABIC,
20	····_ARABIC_ISOLATED_FORM,	11	····_ARABIC_ISOLATED_FORM,
		12	····_BASIC_LATIN_COMPATIBLE_RANGE_FAMILIES,
21	····_CJK,	13	····_CJK,
		14	····_COMPATIBLE_RANGE_FAMILIES,
		15	····_COMPATIBLE_WITH_ANY_RANGE_FAMILIES,
22	····_HANGUL,	16	····_HANGUL,
		17	····_HALFWIDTH_KATAKANA,
23	····_HIRAGANA,	18	····_HIRAGANA,
24	····_KATAKANA,	19	····_KATAKANA,
25	····_LATIN,	20	····_LATIN,
		21	····_LIGATURE,
		22	····_RANGE_FAMILIES,
		23	····_SENTENCE_OPEN_PUNCTUATION,
		24	····_SUPERSCRIPT,
26	····_THAI,	25	····_THAI,
27	)	26	)
28	from·.utils·import·(	27	from·.utils·import·(
29	····_character_flags,	28	····_character_flags,
30	····is_emoticon,	29	····is_emoticon,
31	····is_punctuation,	30	····is_punctuation,
32	····is_separator,	31	····is_separator,
Offset 40, 15 lines modified		Offset 37, 14 lines modified
40	····unicode_range,	37	····unicode_range,
41	)	38	)

42	#·Combined·bitmask·for·CJK/Hangul/Katakana/Hiragana/Thai·glyph·detection.	39	#·Combined·bitmask·for·CJK/Hangul/Katakana/Hiragana/Thai·glyph·detection.
43	_GLYPH_MASK:·int·=·_CJK·\|·_HANGUL·\|·_KATAKANA·\|·_HIRAGANA·\|·_THAI	40	_GLYPH_MASK:·int·=·_CJK·\|·_HANGUL·\|·_KATAKANA·\|·_HIRAGANA·\|·_THAI


44	@final
45	class·CharInfo:	41	class·CharInfo:
46	····"""Pre-computed·character·properties·shared·across·all·detectors."""	42	····"""Pre-computed·character·properties·shared·across·all·detectors."""

47	····__slots__·=·(	43	····__slots__·=·(
48	········"character",	44	········"character",
49	········"printable",	45	········"printable",
50	········"alpha",	46	········"alpha",
Offset 58, 23 lines modified		Offset 54, 29 lines modified
58	········"digit",	54	········"digit",
59	········"is_ascii",	55	········"is_ascii",
60	········"case_variable",	56	········"case_variable",
61	········"flags",	57	········"flags",
62	········"accentuated",	58	········"accentuated",
63	········"latin",	59	········"latin",
64	········"is_cjk",	60	········"is_cjk",
		61	········"is_katakana",
		62	········"is_halfwidth_katakana",
65	········"is_arabic",	63	········"is_arabic",
		64	········"is_ligature",
		65	········"is_superscript",
		66	········"is_sentence_open_punctuation",
66	········"is_glyph",	67	········"is_glyph",
67	········"punct",	68	········"punct",
68	········"sym",	69	········"sym",
69	········"range",	70	········"range",
70	········"sep",	71	········"sep",
71	········"emoticon",	72	········"emoticon",
72	········"safe",	73	········"safe",
73	········"common_cjk",	74	········"common_cjk",
		75	········"unaccented",
74	····)	76	····)

75	····character:·str	77	····character:·str
76	····printable:·bool	78	····printable:·bool
77	····alpha:·bool	79	····alpha:·bool
78	····upper:·bool	80	····upper:·bool
79	····lower:·bool	81	····lower:·bool
Offset 82, 37 lines modified		Offset 84, 52 lines modified
82	····digit:·bool	84	····digit:·bool
83	····is_ascii:·bool	85	····is_ascii:·bool
84	····case_variable:·bool	86	····case_variable:·bool
85	····flags:·int	87	····flags:·int
86	····accentuated:·bool	88	····accentuated:·bool
87	····latin:·bool	89	····latin:·bool
88	····is_cjk:·bool	90	····is_cjk:·bool
		91	····is_katakana:·bool
		92	····is_halfwidth_katakana:·bool
89	····is_arabic:·bool	93	····is_arabic:·bool
		94	····is_ligature:·bool
		95	····is_superscript:·bool
		96	····is_sentence_open_punctuation:·bool
90	····is_glyph:·bool	97	····is_glyph:·bool
91	····punct:·bool	98	····punct:·bool
92	····sym:·bool	99	····sym:·bool
93	····range:·str·\|·None	100	····range:·str·\|·None
94	····sep:·bool	101	····sep:·bool
95	····emoticon:·bool	102	····emoticon:·bool
96	····safe:·bool	103	····safe:·bool
97	····common_cjk:·bool	104	····common_cjk:·bool
		105	····unaccented:·str

98	····def·__init__(self,·character:·str)·->·None:	106	····def·__init__(self,·character:·str)·->·None:
99	········"""Compute·all·properties·for·character·(built·once·per·codepoint,	107	········"""Compute·all·properties·for·character·(built·once·per·codepoint,
100	········every·branch·assigns·every·slot)."""	108	········every·branch·assigns·every·slot)."""
101	········self.character·=·character	109	········self.character·=·character

102	········#·ASCII·fast-path:·for·characters·with·ord·<·128,·we·can·skip	110	········#·ASCII·fast-path:·for·characters·with·ord·<·128,·we·can·skip
103	········#·_character_flags()·entirely·and·derive·most·properties·from·ord.	111	········#·_character_flags()·entirely·and·derive·most·properties·from·ord.
104	········o:·int·=·ord(character)	112	········o:·int·=·ord(character)
105	········if·o·<·128:	113	········if·o·<·128:
106	············self.is_ascii·=·True	114	············self.is_ascii·=·True
107	············self.accentuated·=·False	115	············self.accentuated·=·False
		116	············self.unaccented·=·character
Max diff block lines reached; 28287/31487 bytes (89.84%) of diff not shown.


Offset 36, 15 lines modified		Offset 36, 19 lines modified
36	········self._string:·str·\|·None·=·decoded_payload	36	········self._string:·str·\|·None·=·decoded_payload

37	········self._preemptive_declaration:·str·\|·None·=·preemptive_declaration	37	········self._preemptive_declaration:·str·\|·None·=·preemptive_declaration

38	····def·__eq__(self,·other:·object)·->·bool:	38	····def·__eq__(self,·other:·object)·->·bool:
39	········if·not·isinstance(other,·CharsetMatch):	39	········if·not·isinstance(other,·CharsetMatch):
40	············if·isinstance(other,·str):	40	············if·isinstance(other,·str):
		41	················#·Use·non-strict·iana_name·so·an·operand·that·is·not·a·known
		42	················#·encoding·alias·compares·unequal·instead·of·raising,·keeping
		43	················#·__eq__·total·as·the·data·model·requires·(mirrors·the·lookup
		44	················#·in·CharsetMatches.__getitem__).
41	················return·iana_name(other)·==·self.encoding	45	················return·iana_name(other,·False)·==·self.encoding
42	············return·False	46	············return·False
43	········return·self.encoding·==·other.encoding·and·self.fingerprint·==·other.fingerprint	47	········return·self.encoding·==·other.encoding·and·self.fingerprint·==·other.fingerprint

44	····def·__lt__(self,·other:·object)·->·bool:	48	····def·__lt__(self,·other:·object)·->·bool:
45	········"""	49	········"""
46	········Implemented·to·make·sorted·available·upon·CharsetMatches·items.	50	········Implemented·to·make·sorted·available·upon·CharsetMatches·items.
47	········"""	51	········"""
Offset 64, 15 lines modified		Offset 68, 19 lines modified
64	················return·self.chaos·<·other.chaos	68	················return·self.chaos·<·other.chaos
65	············return·self.multi_byte_usage·>·other.multi_byte_usage	69	············return·self.multi_byte_usage·>·other.multi_byte_usage

66	········return·self.chaos·<·other.chaos	70	········return·self.chaos·<·other.chaos

67	····@property	71	····@property
68	····def·multi_byte_usage(self)·->·float:	72	····def·multi_byte_usage(self)·->·float:
		73	········#·Empty·payloads·are·valid·(from_bytes(b"")·returns·a·match);·avoid·/0.
		74	········raw_len·=·len(self.raw)
		75	········if·raw_len·==·0:
		76	············return·0.0
69	········return·1.0·-·(len(str(self))·/·le~~n(se~~l~~f.ra~~w))	77	········return·1.0·-·(len(str(self))·/·raw_len)

70	····def·__str__(self)·->·str:	78	····def·__str__(self)·->·str:
71	········#·Lazy·Str·Loading	79	········#·Lazy·Str·Loading
72	········if·self._string·is·None:	80	········if·self._string·is·None:
73	············self._string·=·str(self._payload,·self._encoding,·"strict")	81	············self._string·=·str(self._payload,·self._encoding,·"strict")
74	············#·UTF-7·BOM·is·encoded·in·modified·Base64·whose·byte·boundary	82	············#·UTF-7·BOM·is·encoded·in·modified·Base64·whose·byte·boundary
75	············#·can·overlap·with·the·next·character,·so·raw-byte·stripping	83	············#·can·overlap·with·the·next·character,·so·raw-byte·stripping
Offset 254, 24 lines modified		Offset 262, 32 lines modified
254	····"""	262	····"""
255	····Container·with·every·CharsetMatch·items·ordered·by·default·from·most·probable·to·the·less·one.	263	····Container·with·every·CharsetMatch·items·ordered·by·default·from·most·probable·to·the·less·one.
256	····Act·like·a·list(iterable)·but·does·not·implements·all·related·methods.	264	····Act·like·a·list(iterable)·but·does·not·implements·all·related·methods.
257	····"""	265	····"""

258	····def·__init__(self,·results:·list[CharsetMatch]·\|·None·=·None):	266	····def·__init__(self,·results:·list[CharsetMatch]·\|·None·=·None):
259	········self._results:·list[CharsetMatch]·=·sorted(results)·if·results·else·[]	267	········self._results:·list[CharsetMatch]·=·sorted(results)·if·results·else·[]
		268	········self._is_sorted:·bool·=·True

		269	····def·_ensure_sorted(self)·->·None:
		270	········if·not·self._is_sorted:
		271	············self._results.sort()
		272	············self._is_sorted·=·True

260	····def·__iter__(self)·->·Iterator[CharsetMatch]:	273	····def·__iter__(self)·->·Iterator[CharsetMatch]:
		274	········self._ensure_sorted()
261	········yield·from·self._results	275	········yield·from·self._results

262	····def·__getitem__(self,·item:·int·\|·str)·->·CharsetMatch:	276	····def·__getitem__(self,·item:·int·\|·str)·->·CharsetMatch:
263	········"""	277	········"""
264	········Retrieve·a·single·item·either·by·its·position·or·encoding·name·(alias·may·be·used·here).	278	········Retrieve·a·single·item·either·by·its·position·or·encoding·name·(alias·may·be·used·here).
265	········Raise·KeyError·upon·invalid·index·or·encoding·not·present·in·results.	279	········Raise·KeyError·upon·invalid·index·or·encoding·not·present·in·results.
266	········"""	280	········"""
267	········if·isinstance(item,·int):	281	········if·isinstance(item,·int):
		282	············self._ensure_sorted()
268	············return·self._results[item]	283	············return·self._results[item]
269	········if·isinstance(item,·str):	284	········if·isinstance(item,·str):
270	············item·=·iana_name(item,·False)	285	············item·=·iana_name(item,·False)
271	············for·result·in·self._results:	286	············for·result·in·self._results:
272	················if·item·in·result.could_be_from_charset:	287	················if·item·in·result.could_be_from_charset:
273	····················return·result	288	····················return·result
274	········raise·KeyError	289	········raise·KeyError
Offset 296, 22 lines modified		Offset 312, 23 lines modified
296	········#·We·should·disable·the·submatch·factoring·when·the·input·file·is·too·heavy·(conserve·RAM·usage)	312	········#·We·should·disable·the·submatch·factoring·when·the·input·file·is·too·heavy·(conserve·RAM·usage)
297	········if·len(item.raw)·<·TOO_BIG_SEQUENCE:	313	········if·len(item.raw)·<·TOO_BIG_SEQUENCE:
298	············for·match·in·self._results:	314	············for·match·in·self._results:
299	················if·match.fingerprint·==·item.fingerprint·and·match.chaos·==·item.chaos:	315	················if·match.fingerprint·==·item.fingerprint·and·match.chaos·==·item.chaos:
300	····················match.add_submatch(item)	316	····················match.add_submatch(item)
301	····················return	317	····················return
302	········self._results.append(item)	318	········self._results.append(item)
303	········self._~~resul~~ts·=·sorted~~(self._resu~~lts)	319	········self._is_sorted·=·False

304	····def·best(self)·->·CharsetMatch·\|·None:	320	····def·best(self)·->·CharsetMatch·\|·None:
305	········"""	321	········"""
306	········Simply·return·the·first·match.·Strict·equivalent·to·matches[0].	322	········Simply·return·the·first·match.·Strict·equivalent·to·matches[0].
307	········"""	323	········"""
308	········if·not·self._results:	324	········if·not·self._results:
309	············return·None	325	············return·None
		326	········self._ensure_sorted()
310	········return·self._results[0]	327	········return·self._results[0]

311	····def·first(self)·->·CharsetMatch·\|·None:	328	····def·first(self)·->·CharsetMatch·\|·None:
312	········"""	329	········"""
313	········Redundant·method,·call·the·method·best().·Kept·for·BC·reasons.	330	········Redundant·method,·call·the·method·best().·Kept·for·BC·reasons.
314	········"""	331	········"""
315	········return·self.best()	332	········return·self.best()


Offset 1, 37 lines modified		Offset 1, 42 lines modified
1	from·__future__·import·annotations	1	from·__future__·import·annotations

2	import·importlib	2	import·importlib
3	import·logging	3	import·logging
4	import·unicodedata	4	import·unicodedata
5	from·bisect·import·bisect_right	5	from·bisect·import·bisect_right
6	from·codecs·import·IncrementalDecoder	6	from·codecs·import·IncrementalDecoder
7	from·encodings.aliases·import·aliases
8	from·functools·import·lru_cache	7	from·functools·import·lru_cache
9	from·re·import·findall
10	from·typing·import·Generator	8	from·typing·import·Generator

11	from·.constant·import·(	9	from·.constant·import·(
12	····ENCODING_MARKS,	10	····ENCODING_MARKS,
13	····IANA_SUPPORTED_SIMILAR,	11	····IANA_SUPPORTED_SIMILAR,
14	····RE_POSSIBLE_ENCODING_INDICATION,	12	····RE_POSSIBLE_ENCODING_INDICATION,
15	····UNICODE_RANGES_COMBINED,	13	····UNICODE_RANGES_COMBINED,
16	····_SECONDARY_RANGE_NAMES,	14	····_SECONDARY_RANGE_NAMES,
17	····UTF8_MAXIMAL_ALLOCATION,
18	····COMMON_CJK_CHARACTERS,	15	····COMMON_CJK_CHARACTERS,
19	····_LATIN,	16	····_LATIN,
20	····_CJK,	17	····_CJK,
21	····_HANGUL,	18	····_HANGUL,
22	····_KATAKANA,	19	····_KATAKANA,
23	····_HIRAGANA,	20	····_HIRAGANA,
		21	····_HALFWIDTH_KATAKANA,
24	····_THAI,	22	····_THAI,
25	····_ARABIC,	23	····_ARABIC,
26	····_ARABIC_ISOLATED_FORM,	24	····_ARABIC_ISOLATED_FORM,
		25	····_LIGATURE,
		26	····_SUPERSCRIPT,
		27	····_SENTENCE_OPEN_PUNCTUATION,
27	····_ACCENT_KEYWORDS,	28	····_ACCENT_KEYWORDS,
28	····_ACCENTUATED,	29	····_ACCENTUATED,
		30	····_KNOWN_MB_DECODERS,
		31	····_KNOWN_MB_CLASSES,
		32	····_IANA_NAMES,
		33	····_MULTIBYTE_SEARCH_RADIUS,
29	)	34	)


30	def·_character_flags(character:·str)·->·int:	35	def·_character_flags(character:·str)·->·int:
31	····"""Compute·all·name-based·classification·flags·with·a·single·unicodedata.name()·call."""	36	····"""Compute·all·name-based·classification·flags·with·a·single·unicodedata.name()·call."""
32	····try:	37	····try:
33	········desc:·str·=·unicodedata.name(character)	38	········desc:·str·=·unicodedata.name(character)
Offset 44, 36 lines modified		Offset 49, 43 lines modified
44	········flags·\|=·_LATIN	49	········flags·\|=·_LATIN
45	····if·"CJK"·in·desc:	50	····if·"CJK"·in·desc:
46	········flags·\|=·_CJK	51	········flags·\|=·_CJK
47	····if·"HANGUL"·in·desc:	52	····if·"HANGUL"·in·desc:
48	········flags·\|=·_HANGUL	53	········flags·\|=·_HANGUL
49	····if·"KATAKANA"·in·desc:	54	····if·"KATAKANA"·in·desc:
50	········flags·\|=·_KATAKANA	55	········flags·\|=·_KATAKANA
		56	········if·"HALFWIDTH"·in·desc:
		57	············flags·\|=·_HALFWIDTH_KATAKANA
51	····if·"HIRAGANA"·in·desc:	58	····if·"HIRAGANA"·in·desc:
52	········flags·\|=·_HIRAGANA	59	········flags·\|=·_HIRAGANA
53	····if·"THAI"·in·desc:	60	····if·"THAI"·in·desc:
54	········flags·\|=·_THAI	61	········flags·\|=·_THAI
55	····if·"ARABIC"·in·desc:	62	····if·"ARABIC"·in·desc:
56	········flags·\|=·_ARABIC	63	········flags·\|=·_ARABIC
57	········if·"ISOLATED·FORM"·in·desc:	64	········if·"ISOLATED·FORM"·in·desc:
58	············flags·\|=·_ARABIC_ISOLATED_FORM	65	············flags·\|=·_ARABIC_ISOLATED_FORM
		66	····if·"LIGATURE"·in·desc·or·desc.endswith("LETTER·AE"):
		67	········flags·\|=·_LIGATURE
		68	····if·"SUPERSCRIPT"·in·desc:
		69	········flags·\|=·_SUPERSCRIPT
		70	····if·desc·in·{"INVERTED·QUESTION·MARK",·"INVERTED·EXCLAMATION·MARK"}:
		71	········flags·\|=·_SENTENCE_OPEN_PUNCTUATION

59	····for·kw·in·_ACCENT_KEYWORDS:	72	····for·kw·in·_ACCENT_KEYWORDS:
60	········if·kw·in·desc:	73	········if·kw·in·desc:
61	············flags·\|=·_ACCENTUATED	74	············flags·\|=·_ACCENTUATED
62	············break	75	············break

63	····return·flags	76	····return·flags


64	def·is_accentuated(character:·str)·->·bool:	77	def·is_accentuated(character:·str)·->·bool:
65	····return·bool(_character_flags(character)·&·_ACCENTUATED)	78	····return·bool(_character_flags(character)·&·_ACCENTUATED)


66	@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
67	def·remove_accent(character:·str)·->·str:	79	def·remove_accent(character:·str)·->·str:
68	····decomposed:·str·=·unicodedata.decomposition(character)	80	····decomposed:·str·=·unicodedata.decomposition(character)
69	····if·not·decomposed:	81	····if·not·decomposed:
70	········return·character	82	········return·character

71	····codes:·list[str]·=·decomposed.split("·")	83	····codes:·list[str]·=·decomposed.split("·")

Offset 91, 14 lines modified		Offset 103, 19 lines modified

91	def·unicode_range(character:·str)·->·str·\|·None:	103	def·unicode_range(character:·str)·->·str·\|·None:
92	····"""	104	····"""
93	····Retrieve·the·Unicode·range·official·name·from·a·single·character.	105	····Retrieve·the·Unicode·range·official·name·from·a·single·character.
94	····"""	106	····"""
95	····character_ord:·int·=·ord(character)	107	····character_ord:·int·=·ord(character)

		108	····if·character_ord·<·32:
		109	········return·"Control·character"
		110	····if·character_ord·<·128:
		111	········return·"Basic·Latin"

96	····#·Binary·search:·find·the·rightmost·range·whose·start·<=·character_ord	112	····#·Binary·search:·find·the·rightmost·range·whose·start·<=·character_ord
97	····idx·=·bisect_right(_UNICODE_RANGE_STARTS,·character_ord)·-·1	113	····idx·=·bisect_right(_UNICODE_RANGE_STARTS,·character_ord)·-·1
98	····if·idx·>=·0:	114	····if·idx·>=·0:
99	········start,·stop,·name·=·_UNICODE_RANGES_SORTED[idx]	115	········start,·stop,·name·=·_UNICODE_RANGES_SORTED[idx]
100	········if·character_ord·<·stop:	116	········if·character_ord·<·stop:
101	············return·name	117	············return·name

Offset 151, 64 lines modified		Offset 168, 54 lines modified
151	········return·True	168	········return·True

152	····character_category:·str·=·unicodedata.category(character)	169	····character_category:·str·=·unicodedata.category(character)

153	····return·"Z"·in·character_category·or·character_category·in·{"Po",·"Pd",·"Pc"}	170	····return·"Z"·in·character_category·or·character_category·in·{"Po",·"Pd",·"Pc"}


154	@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
155	def·is_case_variable(character:·str)·->·bool:	171	def·is_case_variable(character:·str)·->·bool:
156	····return·character.islower()·!=·character.isupper()	172	····return·character.islower()·!=·character.isupper()


157	@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
158	def·is_cjk(character:·str)·->·bool:	173	def·is_cjk(character:·str)·->·bool:
159	····return·bool(_character_flags(character)·&·_CJK)	174	····return·bool(_character_flags(character)·&·_CJK)

Max diff block lines reached; 8112/11582 bytes (70.04%) of diff not shown.


Offset 1, 8 lines modified		Offset 1, 8 lines modified
1	"""	1	"""
2	Expose·version	2	Expose·version
3	"""	3	"""

4	from·__future__·import·annotations	4	from·__future__·import·annotations

5	__version__·=·"3.4.9"	5	__version__·=·"3.5.2"
6	VERSION·=·__version__.split(".")	6	VERSION·=·__version__.split(".")


Offset 9, 15 lines modified		Offset 9, 15 lines modified
9	from·webencodings·import·ascii_lower	9	from·webencodings·import·ascii_lower

10	#·Classes·are·imported·here·to·expose·them·at·the·top·level·of·the·module	10	#·Classes·are·imported·here·to·expose·them·at·the·top·level·of·the·module
11	from·.compiler·import·compile_selector_list··#·noqa	11	from·.compiler·import·compile_selector_list··#·noqa
12	from·.parser·import·SelectorError··#·noqa	12	from·.parser·import·SelectorError··#·noqa
13	from·.tree·import·ElementWrapper··#·noqa	13	from·.tree·import·ElementWrapper··#·noqa

14	VERSION·=·__version__·=·'0.9.0'	14	VERSION·=·__version__·=·'0.10.1'


15	class·Matcher:	15	class·Matcher:
16	····"""A·CSS·selectors·storage·that·can·match·against·HTML·elements."""	16	····"""A·CSS·selectors·storage·that·can·match·against·HTML·elements."""
17	····def·__init__(self):	17	····def·__init__(self):
18	········self.id_selectors·=·{}	18	········self.id_selectors·=·{}
19	········self.class_selectors·=·{}	19	········self.class_selectors·=·{}


Offset 5, 14 lines modified		Offset 5, 16 lines modified
5	SUPPORTED_PSEUDO_ELEMENTS·=·{	5	SUPPORTED_PSEUDO_ELEMENTS·=·{
6	····#·As·per·CSS·Pseudo-Elements·Module·Level·4	6	····#·As·per·CSS·Pseudo-Elements·Module·Level·4
7	····'first-line',·'first-letter',·'prefix',·'postfix',·'selection',	7	····'first-line',·'first-letter',·'prefix',·'postfix',·'selection',
8	····'target-text',·'spelling-error',·'grammar-error',·'before',·'after',	8	····'target-text',·'spelling-error',·'grammar-error',·'before',·'after',
9	····'marker',·'placeholder',·'file-selector-button',	9	····'marker',·'placeholder',·'file-selector-button',
10	····#·As·per·CSS·Generated·Content·for·Paged·Media·Module	10	····#·As·per·CSS·Generated·Content·for·Paged·Media·Module
11	····'footnote-call',·'footnote-marker',	11	····'footnote-call',·'footnote-marker',
		12	····#·As·per·CSS·Notes
		13	····'note-call',·'note-marker',·'note-callback',
12	····#·As·per·CSS·Scoping·Module·Level·1	14	····#·As·per·CSS·Scoping·Module·Level·1
13	····'content',·'shadow',	15	····'content',·'shadow',
14	}	16	}


15	def·parse(input,·namespaces=None,·forgiving=False,·relative=False):	17	def·parse(input,·namespaces=None,·forgiving=False,·relative=False):
16	····"""Yield·tinycss2·selectors·found·in·given·``input``.	18	····"""Yield·tinycss2·selectors·found·in·given·``input``.


Offset 1, 8 lines modified		Offset 1, 8 lines modified
1	Zip·file·size:·37~~34889~~·bytes,·number·of·entries:·773	1	Zip·file·size:·3780927·bytes,·number·of·entries:·772
2	-rw----·····2.0·fat····34703·b-·defN·80-Feb-01·00:00·six.py	2	-rw----·····2.0·fat····34703·b-·defN·80-Feb-01·00:00·six.py
3	-rw----·····2.0·fat···165012·b-·defN·80-Feb-01·00:00·typing_extensions.py	3	-rw----·····2.0·fat···165012·b-·defN·80-Feb-01·00:00·typing_extensions.py
4	-rw----·····2.0·fat········0·b-·defN·80-Feb-01·00:00·PIL/	4	-rw----·····2.0·fat········0·b-·defN·80-Feb-01·00:00·PIL/
5	-rw----·····2.0·fat·····3477·b-·defN·80-Feb-01·00:00·PIL/BdfFontFile.py	5	-rw----·····2.0·fat·····3477·b-·defN·80-Feb-01·00:00·PIL/BdfFontFile.py
6	-rw----·····2.0·fat····16584·b-·defN·80-Feb-01·00:00·PIL/BlpImagePlugin.py	6	-rw----·····2.0·fat····16584·b-·defN·80-Feb-01·00:00·PIL/BlpImagePlugin.py
7	-rw----·····2.0·fat····19758·b-·defN·80-Feb-01·00:00·PIL/BmpImagePlugin.py	7	-rw----·····2.0·fat····19758·b-·defN·80-Feb-01·00:00·PIL/BmpImagePlugin.py
8	-rw----·····2.0·fat·····1753·b-·defN·80-Feb-01·00:00·PIL/BufrStubImagePlugin.py	8	-rw----·····2.0·fat·····1753·b-·defN·80-Feb-01·00:00·PIL/BufrStubImagePlugin.py
Offset 142, 35 lines modified		Offset 142, 35 lines modified
142	-rw----·····2.0·fat········4·b-·defN·80-Feb-01·00:00·chaquopy_libxml2-2.9.8.dist-info/INSTALLER	142	-rw----·····2.0·fat········4·b-·defN·80-Feb-01·00:00·chaquopy_libxml2-2.9.8.dist-info/INSTALLER
143	-rw----·····2.0·fat·······86·b-·defN·80-Feb-01·00:00·chaquopy_libxml2-2.9.8.dist-info/METADATA	143	-rw----·····2.0·fat·······86·b-·defN·80-Feb-01·00:00·chaquopy_libxml2-2.9.8.dist-info/METADATA
144	-rw----·····2.0·fat········0·b-·defN·80-Feb-01·00:00·chaquopy_libxslt-1.1.32.dist-info/	144	-rw----·····2.0·fat········0·b-·defN·80-Feb-01·00:00·chaquopy_libxslt-1.1.32.dist-info/
145	-rw----·····2.0·fat·····2968·b-·defN·80-Feb-01·00:00·chaquopy_libxslt-1.1.32.dist-info/COPYING	145	-rw----·····2.0·fat·····2968·b-·defN·80-Feb-01·00:00·chaquopy_libxslt-1.1.32.dist-info/COPYING
146	-rw----·····2.0·fat········4·b-·defN·80-Feb-01·00:00·chaquopy_libxslt-1.1.32.dist-info/INSTALLER	146	-rw----·····2.0·fat········4·b-·defN·80-Feb-01·00:00·chaquopy_libxslt-1.1.32.dist-info/INSTALLER
147	-rw----·····2.0·fat······129·b-·defN·80-Feb-01·00:00·chaquopy_libxslt-1.1.32.dist-info/METADATA	147	-rw----·····2.0·fat······129·b-·defN·80-Feb-01·00:00·chaquopy_libxslt-1.1.32.dist-info/METADATA
148	-rw----·····2.0·fat········0·b-·defN·80-Feb-01·00:00·charset_normalizer/	148	-rw----·····2.0·fat········0·b-·defN·80-Feb-01·00:00·charset_normalizer/
149	-rw----·····2.0·fat·····1590·b-·defN·80-Feb-01·00:00·charset_normalizer/__init__.py	149	-rw----·····2.0·fat·····1582·b-·defN·80-Feb-01·00:00·charset_normalizer/__init__.py
150	-rw----·····2.0·fat······109·b-·defN·80-Feb-01·00:00·charset_normalizer/__main__.py	150	-rw----·····2.0·fat······109·b-·defN·80-Feb-01·00:00·charset_normalizer/__main__.py
151	-rw----·····2.0·fat····~~42325~~·b-·defN·80-Feb-01·00:00·charset_normalizer/api.py	151	-rw----·····2.0·fat····35774·b-·defN·80-Feb-01·00:00·charset_normalizer/api.py
152	-rw----·····2.0·fat····15980·b-·defN·80-Feb-01·00:00·charset_normalizer/cd.py	152	-rw----·····2.0·fat····15980·b-·defN·80-Feb-01·00:00·charset_normalizer/cd.py
153	-rw----·····2.0·fat····~~44624~~·b-·defN·80-Feb-01·00:00·charset_normalizer/constant.py	153	-rw----·····2.0·fat····60812·b-·defN·80-Feb-01·00:00·charset_normalizer/constant.py
154	-rw----·····2.0·fat·····2651·b-·defN·80-Feb-01·00:00·charset_normalizer/legacy.py	154	-rw----·····2.0·fat·····2651·b-·defN·80-Feb-01·00:00·charset_normalizer/legacy.py
155	-rw----·····2.0·fat····32641·b-·defN·80-Feb-01·00:00·charset_normalizer/md.py	155	-rw----·····2.0·fat····35274·b-·defN·80-Feb-01·00:00·charset_normalizer/md.py
156	-rw----·····2.0·fat····12830·b-·defN·80-Feb-01·00:00·charset_normalizer/models.py	156	-rw----·····2.0·fat····13530·b-·defN·80-Feb-01·00:00·charset_normalizer/models.py
157	-rw----·····2.0·fat········0·b-·defN·80-Feb-01·00:00·charset_normalizer/py.typed	157	-rw----·····2.0·fat········0·b-·defN·80-Feb-01·00:00·charset_normalizer/py.typed
158	-rw----·····2.0·fat····1~~3537~~·b-·defN·80-Feb-01·00:00·charset_normalizer/utils.py	158	-rw----·····2.0·fat····14122·b-·defN·80-Feb-01·00:00·charset_normalizer/utils.py
159	-rw----·····2.0·fat······115·b-·defN·80-Feb-01·00:00·charset_normalizer/version.py	159	-rw----·····2.0·fat······115·b-·defN·80-Feb-01·00:00·charset_normalizer/version.py
160	-rw----·····2.0·fat········0·b-·defN·80-Feb-01·00:00·charset_normalizer/cli/	160	-rw----·····2.0·fat········0·b-·defN·80-Feb-01·00:00·charset_normalizer/cli/
161	-rw----·····2.0·fat······136·b-·defN·80-Feb-01·00:00·charset_normalizer/cli/__init__.py	161	-rw----·····2.0·fat······136·b-·defN·80-Feb-01·00:00·charset_normalizer/cli/__init__.py
162	-rw----·····2.0·fat····11949·b-·defN·80-Feb-01·00:00·charset_normalizer/cli/__main__.py	162	-rw----·····2.0·fat····11949·b-·defN·80-Feb-01·00:00·charset_normalizer/cli/__main__.py
163	-rw----·····2.0·fat········0·b-·defN·80-Feb-01·00:00·charset_normalizer-3.4.9.dist-info/	163	-rw----·····2.0·fat········0·b-·defN·80-Feb-01·00:00·charset_normalizer-3.5.2.dist-info/
164	-rw----·····2.0·fat········4·b-·defN·80-Feb-01·00:00·charset_normalizer-3.4.9.dist-info/INSTALLER	164	-rw----·····2.0·fat········4·b-·defN·80-Feb-01·00:00·charset_normalizer-3.5.2.dist-info/INSTALLER
165	-rw----·····2.0·fat····4~~1678~~·b-·defN·80-Feb-01·00:00·charset_normalizer-3.4.9.dist-info/METADATA	165	-rw----·····2.0·fat····46395·b-·defN·80-Feb-01·00:00·charset_normalizer-3.5.2.dist-info/METADATA
166	-rw----·····2.0·fat·······65·b-·defN·80-Feb-01·00:00·charset_normalizer-3.4.9.dist-info/entry_points.txt	166	-rw----·····2.0·fat·······65·b-·defN·80-Feb-01·00:00·charset_normalizer-3.5.2.dist-info/entry_points.txt
167	-rw----·····2.0·fat·······19·b-·defN·80-Feb-01·00:00·charset_normalizer-3.4.9.dist-info/top_level.txt	167	-rw----·····2.0·fat·······19·b-·defN·80-Feb-01·00:00·charset_normalizer-3.5.2.dist-info/top_level.txt
168	-rw----·····2.0·fat········0·b-·defN·80-Feb-01·00:00·charset_normalizer-3.4.9.dist-info/licenses/	168	-rw----·····2.0·fat········0·b-·defN·80-Feb-01·00:00·charset_normalizer-3.5.2.dist-info/licenses/
169	-rw----·····2.0·fat·····1071·b-·defN·80-Feb-01·00:00·charset_normalizer-3.4.9.dist-info/licenses/LICENSE	169	-rw----·····2.0·fat·····1071·b-·defN·80-Feb-01·00:00·charset_normalizer-3.5.2.dist-info/licenses/LICENSE
170	-rw----·····2.0·fat········0·b-·defN·80-Feb-01·00:00·css_parser/	170	-rw----·····2.0·fat········0·b-·defN·80-Feb-01·00:00·css_parser/


Offset 1, 26 lines modified		Offset 1, 30 lines modified
1	"""	1	"""
2	A·platform·independent·file·lock·that·supports·the·with-statement.	2	A·platform·independent·file·lock·that·supports·the·with-statement.

3	..·autodata::·filelock.__version__	3	..·autodata::·filelock.__version__
4	····:no-value:	4	····:no-value:

		5	..·autodata::·filelock.OwnerMode

		6	..·autodata::·filelock.CompromiseReason

5	"""	7	"""

6	from·__future__·import·annotations	8	from·__future__·import·annotations

7	import·sys	9	import·sys
8	import·warnings	10	import·warnings
9	from·typing·import·TYPE_CHECKING,·Final	11	from·typing·import·TYPE_CHECKING,·Final

10	from·._api·import·AcquireReturnProxy,·BaseFileLock,·CloseErrorPolicy,·ContextErrorPolicy,·LockOptions	12	from·._api·import·AcquireReturnProxy,·BaseFileLock,·CloseErrorPolicy,·ContextErrorPolicy,·LockOptions
11	from·._descriptor·import·lock_descriptor,·unlock_descriptor	13	from·._descriptor·import·lock_descriptor,·unlock_descriptor
12	from·._error·import·LeaseSettingsMismatch,·SoftFileLockLifetimeWarning,·SoftFileLockProtocolError,·Timeout	14	from·._error·import·LeaseSettingsMismatch,·SoftFileLockLifetimeWarning,·SoftFileLockProtocolError,·Timeout
13	from·._lease·import·LeaseCompromise,·SoftFileLease	15	from·._lease·import·CompromiseReason,·LeaseCompromise,·SoftFileLease
14	from·._marker·import·MarkerSoftFileLock,·OwnerRecord	16	from·._marker·import·MarkerSoftFileLock,·OwnerMode,·OwnerRecord

15	if·TYPE_CHECKING:	17	if·TYPE_CHECKING:
16	····from·._async_read_write·import·(	18	····from·._async_read_write·import·(
17	········AsyncAcquireReadWriteReturnProxy,	19	········AsyncAcquireReadWriteReturnProxy,
18	········AsyncReadWriteLock,	20	········AsyncReadWriteLock,
19	····)	21	····)
20	····from·._read_write·import·ReadWriteLock	22	····from·._read_write·import·ReadWriteLock
Offset 32, 30 lines modified		Offset 36, 39 lines modified
32	········AsyncAcquireReadWriteReturnProxy·=·None	36	········AsyncAcquireReadWriteReturnProxy·=·None
33	········AsyncReadWriteLock·=·None	37	········AsyncReadWriteLock·=·None
34	········ReadWriteLock·=·None	38	········ReadWriteLock·=·None

35	from·._soft·import·SoftFileLock	39	from·._soft·import·SoftFileLock
36	from·._soft_rw·import·AsyncAcquireSoftReadWriteReturnProxy,·AsyncSoftReadWriteLock,·SoftReadWriteLock	40	from·._soft_rw·import·AsyncAcquireSoftReadWriteReturnProxy,·AsyncSoftReadWriteLock,·SoftReadWriteLock
37	from·._strict·import·StrictSoftFileClaim,·StrictSoftFileClaimState,·StrictSoftFileLock	41	from·._strict·import·StrictSoftFileClaim,·StrictSoftFileClaimState,·StrictSoftFileLock


Offset 2, 49 lines modified		Offset 2, 57 lines modified

2	import·contextlib	2	import·contextlib
3	import·inspect	3	import·inspect
4	import·logging	4	import·logging
5	import·math	5	import·math
6	import·os	6	import·os
7	import·secrets	7	import·secrets
		8	import·stat
8	import·sys	9	import·sys
9	import·time	10	import·time
10	import·warnings	11	import·warnings
11	from·abc·import·ABCMeta,·abstractmethod	12	from·abc·import·ABCMeta,·abstractmethod
12	from·collections.abc·import·Callable,·Hashable	13	from·collections.abc·import·Callable,·Hashable
13	from·contextlib·import·contextmanager	14	from·contextlib·import·contextmanager
14	from·dataclasses·import·dataclass	15	from·dataclasses·import·dataclass,·fields
		16	from·decimal·import·Decimal
15	from·itertools·import·count,·starmap	17	from·itertools·import·count,·starmap
		18	from·numbers·import·Real
16	from·threading·import·Condition,·RLock,·get_ident,·local	19	from·threading·import·TIMEOUT_MAX,·Condition,·RLock,·Thread,·current_thread,·get_ident,·local
17	from·typing·import·TYPE_CHECKING,·Final,·Literal,·NoReturn,·TypedDict,·TypeVar,·cast	20	from·typing·import·TYPE_CHECKING,·Final,·Generic,·Literal,·NoReturn,·TypedDict,·TypeVar,·cast
18	from·weakref·import·WeakKeyDictionary,·WeakValueDictionary	21	from·weakref·import·WeakKeyDictionary,·WeakValueDictionary

19	from·._error·import·SoftFileLockLifetimeWarning,·Timeout	22	from·._error·import·SoftFileLockLifetimeWarning,·Timeout
20	from·._util·import·break_lock_file	23	from·._util·import·break_lock_file

21	#:·No·explicit·file·permission·mode·was·passed.·Lock·files·then·open·with·0o666·so·umask·and·default·ACLs·pick	24	#:·No·explicit·file·permission·mode·was·passed.·Lock·files·then·open·with·0o666·so·umask·and·default·ACLs·pick
22	#:·the·final·permissions,·and·fchmod·is·skipped·to·preserve·POSIX·default·ACL·inheritance.	25	#:·the·final·permissions,·and·fchmod·is·skipped·to·preserve·POSIX·default·ACL·inheritance.
23	_UNSET_FILE_MODE:·Final[int]·=·-1	26	_UNSET_FILE_MODE:·Final[int]·=·-1

		27	_PERMISSION_BITS:·Final[int]·=·stat.S_IRWXU·\|·stat.S_IRWXG·\|·stat.S_IRWXO

24	#:·Ceiling·on·the·retry·counter·used·as·a·power·of·two,·so·a·long·contended·wait·cannot·overflow·the·backoff·multiply.	28	#:·Ceiling·on·the·retry·counter·used·as·a·power·of·two,·so·a·long·contended·wait·cannot·overflow·the·backoff·multiply.
25	_MAX_BACKOFF_EXPONENT:·Final[int]·=·20	29	_MAX_BACKOFF_EXPONENT:·Final[int]·=·20

26	#:·How·a·context·manager·reconciles·a·body·failure·with·a·release·failure·on·exit·(see·the·property·of·this·name).	30	#:·How·a·context·manager·reconciles·a·body·failure·with·a·release·failure·on·exit·(see·the·property·of·this·name).
27	ContextErrorPolicy·=·Literal["chain",·"group"]	31	ContextErrorPolicy·=·Literal["chain",·"group"]
28	_CONTEXT_ERROR_POLICIES:·Final[frozenset[str]]·=·frozenset({"chain",·"group"})	32	_CONTEXT_ERROR_POLICIES:·Final[frozenset[str]]·=·frozenset({"chain",·"group"})


Offset 4, 18 lines modified		Offset 4, 26 lines modified

4	import·asyncio	4	import·asyncio
5	import·contextlib	5	import·contextlib
6	import·time	6	import·time
7	from·concurrent.futures·import·Future·as·ConcurrentFuture	7	from·concurrent.futures·import·Future·as·ConcurrentFuture
8	from·dataclasses·import·dataclass	8	from·dataclasses·import·dataclass
9	from·threading·import·Lock	9	from·threading·import·Lock
10	from·typing·import·TYPE_CHECKING,·Final,·Generic,·TypeVar,·cast	10	from·typing·import·TYPE_CHECKING,·Final,·Generic,·Literal,·NoReturn,·TypeVar,·cast
		11	from·weakref·import·WeakKeyDictionary

		12	from·._api·import·_append_exception_context,·_fork_transition,·_raise_chained_errors,·_resolve_read_write_timeout
		13	from·._error·import·Timeout

11	if·TYPE_CHECKING:	14	if·TYPE_CHECKING:
12	····from·collections.abc·import·AsyncIterator,·Awaitable,·Callable	15	····from·collections.abc·import·AsyncGenerator,·Awaitable,·Callable
		16	····from·concurrent.futures·import·Executor

		17	····from·._read_write·import·ReadWriteLock
		18	····from·._soft_rw·import·SoftReadWriteLock

13	_T·=·TypeVar("_T")	19	_T·=·TypeVar("_T")


14	class·_AsyncTransitionUnavailableError(Exception):	20	class·_AsyncTransitionUnavailableError(Exception):
15	····pass	21	····pass

Offset 28, 23 lines modified		Offset 36, 23 lines modified

28	class·_AsyncTransitionGate:	36	class·_AsyncTransitionGate:
29	····def·__init__(self)·->·None:	37	····def·__init__(self)·->·None:
30	········self._tail_lock:·Final[Lock]·=·Lock()	38	········self._tail_lock:·Final[Lock]·=·Lock()
31	········self._tail:·ConcurrentFuture[None]·\|·None·=·None	39	········self._tail:·ConcurrentFuture[None]·\|·None·=·None

32	····@contextlib.asynccontextmanager	40	····@contextlib.asynccontextmanager
33	····async·def·hold(self)·->·AsyncIterator[None]:	41	····async·def·hold(self)·->·AsyncGenerator[None]:
34	········ticket:·ConcurrentFuture[None]·=·ConcurrentFuture()	42	········ticket:·ConcurrentFuture[None]·=·ConcurrentFuture()
35	········with·self._tail_lock:	43	········with·self._tail_lock:
36	············predecessor·=·self._tail	44	············predecessor·=·self._tail


Offset 2, 50 lines modified		Offset 2, 58 lines modified

2	from·__future__·import·annotations	2	from·__future__·import·annotations

3	import·asyncio	3	import·asyncio
4	import·functools	4	import·functools
5	import·os	5	import·os
6	import·sqlite3	6	import·sqlite3
		7	import·threading
7	from·concurrent.futures·import·ThreadPoolExecutor	8	from·concurrent.futures·import·ThreadPoolExecutor
8	from·contextlib·import·asynccontextmanager	9	from·contextlib·import·asynccontextmanager
9	from·typing·import·TYPE_CHECKING,·ParamSpec,·TypeVar	10	from·typing·import·TYPE_CHECKING,·Literal,·ParamSpec,·TypeVar,·cast

10	from·._api·import·(	11	from·._api·import·(
11	····_append_exception_context,	12	····_append_exception_context,
12	····_ensure_current_process,	13	····_ensure_current_process,
13	····_fork_transition,	14	····_fork_transition,
14	····_raise_chained_errors,
15	····_register_fork_object,	15	····_register_fork_object,
16	)	16	)
17	from·._async·import·~~_BackendOutcome,·_capture_call,·_drain_future,·_future_result,·_wait_until_don~~e	17	from·._async·import·(
		18	····_BackendOutcome,
		19	····_capture_call,
		20	····_drain_future,
		21	····_future_result,
		22	····_raise_cancelled_error,
		23	····_task_owners_for,
		24	····_wait_until_done,
		25	)
18	from·._read_write·import·ReadWriteLock	26	from·._read_write·import·ReadWriteLock

19	if·TYPE_CHECKING:	27	if·TYPE_CHECKING:
20	····from·collections.abc·import·AsyncGenerator,·Callable	28	····from·collections.abc·import·AsyncGenerator,·Callable
21	····from·concurrent·import·futures	29	····from·concurrent·import·futures
22	····from·types·import·TracebackType	30	····from·types·import·TracebackType
23	····from·typing·import·NoReturn

24	····from·._api·import·AcquireReturnProxy

25	_P·=·ParamSpec("_P")	31	_P·=·ParamSpec("_P")
26	_R·=·TypeVar("_R")	32	_R·=·TypeVar("_R")


27	class·AsyncReadWriteLock:	33	class·AsyncReadWriteLock:
28	····"""	34	····"""
29	····Async·wrapper·around·:class:`ReadWriteLock`·for·use·in·``asyncio``·applications.	35	····Async·wrapper·around·:class:`ReadWriteLock`·for·use·in·``asyncio``·applications.

30	····This·wrapper·dispatches·every·blocking·SQLite·operation·to·a·thread·pool·via·``loop.run_in_executor()``·because	36	····This·wrapper·dispatches·every·blocking·SQLite·operation·to·a·thread·pool·via·``loop.run_in_executor()``·because
31	····Python's·:mod:`sqlite3`·module·has·no·async·API.·It·delegates·reentrancy,·upgrade/downgrade·rules,·and·singleton
32	····behavior·to·the·un~~derlying~~·:class~~:`R~~ea~~dWriteL~~ock`.	37	····Python's·:mod:`sqlite3`·module·has·no·async·API.·Each·``asyncio``·task·owns·its·own·hold.·Tasks·share·a·read·lock,
		38	····and·a·task·asking·for·the·write·lock·waits·until·the·other·holders·release,·with·waiting·writers·ahead·of·new
		39	····readers.·As·with·:class:`ReadWriteLock`,·upgrading·or·downgrading·a·held·lock·raises·:class:`RuntimeError`.
		40	····Singleton·wrappers·over·one·path·share·their·task·holds.

33	····:param·lock_file:·path·to·the·SQLite·database·file·used·as·the·lock	41	····:param·lock_file:·path·to·the·SQLite·database·file·used·as·the·lock
34	····:param·timeout:·maximum·wait·time·in·seconds;·``-1``·~~mean~~s·block·~~inde~~f~~ini~~tely	42	····:param·timeout:·maximum·wait·time·in·seconds;·``-1``·waits·up·to·SQLite's·busy-timeout·cap·of·about·23·days
35	····:param·blocking:·if·``False``,·raise·:class:`~filelock.Timeout`·immediately·when·the·lock·is·unavailable	43	····:param·blocking:·if·``False``,·raise·:class:`~filelock.Timeout`·immediately·when·the·lock·is·unavailable
36	····:param·is_singleton:·if·``True``,·reuse·existing·:class:`ReadWriteLock`·instances·for·the·same·resolved·path	44	····:param·is_singleton:·if·``True``,·reuse·existing·:class:`ReadWriteLock`·instances·for·the·same·resolved·path
37	····:param·loop:·event·loop·for·``run_in_executor``;·``None``·uses·the·running·loop	45	····:param·loop:·event·loop·for·``run_in_executor``;·``None``·uses·the·running·loop
38	····:param·executor:·executor·for·``run_in_executor``.·When·``None``·this·lock·creates·and·owns·a·dedicated	46	····:param·executor:·executor·for·``run_in_executor``.·When·``None``·this·lock·creates·and·owns·a·dedicated
39	········single-thread·executor·so·every·operation·runs·on·the·same·thread·(SQLite·affinity·requires·this)·and·shuts·it	47	········single-thread·executor·so·every·operation·runs·on·the·same·thread·(SQLite·affinity·requires·this)·and·shuts·it
40	········down·in·:meth:`close`.·This·lock·uses·a·caller-supplied·executor·as-is·and·never·shuts·it·down,·so·after·passing	48	········down·in·:meth:`close`.·This·lock·uses·a·caller-supplied·executor·as-is·and·never·shuts·it·down,·so·after·passing
41	········no·executor·call·:meth:`close`·to·release·the·owned·one.	49	········no·executor·call·:meth:`close`·to·release·the·owned·one.
Offset 67, 14 lines modified		Offset 75, 15 lines modified
67	········creator_pid·=·os.getpid()	75	········creator_pid·=·os.getpid()
68	········self._creator_pid·=·creator_pid	76	········self._creator_pid·=·creator_pid
69	········self._fork_invalidated·=·False	77	········self._fork_invalidated·=·False
70	········self._closed·=·False	78	········self._closed·=·False
71	········_register_fork_object(self)	79	········_register_fork_object(self)
72	········with·_fork_transition():	80	········with·_fork_transition():
73	············self._lock·=·ReadWriteLock(lock_file,·timeout,·blocking=blocking,·is_singleton=is_singleton)	81	············self._lock·=·ReadWriteLock(lock_file,·timeout,·blocking=blocking,·is_singleton=is_singleton)
		82	············self._owners·=·_task_owners_for(self._lock)
74	············self._loop·=·loop	83	············self._loop·=·loop
75	············self._owns_executor·=·executor·is·None	84	············self._owns_executor·=·executor·is·None
76	············self._executor·=·executor·or·ThreadPoolExecutor(max_workers=1)	85	············self._executor·=·executor·or·ThreadPoolExecutor(max_workers=1)
77	············if·os.getpid()·!=·creator_pid:··#·pragma:·forked·child	86	············if·os.getpid()·!=·creator_pid:··#·pragma:·forked·child
78	················msg·=·"AsyncReadWriteLock·construction·cannot·continue·after·fork"	87	················msg·=·"AsyncReadWriteLock·construction·cannot·continue·after·fork"
79	················raise·RuntimeError(msg)	88	················raise·RuntimeError(msg)

Offset 110, 18 lines modified		Offset 119, 14 lines modified

110	········Falls·back·to·instance·defaults·for·timeout·and·blocking·when·``None``.	119	········Falls·back·to·instance·defaults·for·timeout·and·blocking·when·``None``.

111	········:param·timeout:·maximum·wait·time·in·seconds,·or·``None``·to·use·the·instance·default	120	········:param·timeout:·maximum·wait·time·in·seconds,·or·``None``·to·use·the·instance·default
112	········:param·blocking:·if·``False``,·raise·:class:`~filelock.Timeout`·immediately;·``None``·uses·the·instance·default	121	········:param·blocking:·if·``False``,·raise·:class:`~filelock.Timeout`·immediately;·``None``·uses·the·instance·default

113	········"""	122	········"""
114	········if·timeout·is·None:
115	············timeout·=·self._lock.timeout
116	········if·blocking·is·None:
117	············blocking·=·self._lock.blocking
118	········await·self.acquire_read(timeout,·blocking=blocking)	123	········await·self.acquire_read(timeout,·blocking=blocking)
119	········body_error:·BaseException·\|·None·=·None	124	········body_error:·BaseException·\|·None·=·None
120	········try:	125	········try:
121	············yield	126	············yield
122	········except·BaseException·as·error:	127	········except·BaseException·as·error:
123	············body_error·=·error	128	············body_error·=·error
124	············raise	129	············raise
Offset 135, 18 lines modified		Offset 140, 14 lines modified

135	········Falls·back·to·instance·defaults·for·timeout·and·blocking·when·``None``.	140	········Falls·back·to·instance·defaults·for·timeout·and·blocking·when·``None``.

136	········:param·timeout:·maximum·wait·time·in·seconds,·or·``None``·to·use·the·instance·default	141	········:param·timeout:·maximum·wait·time·in·seconds,·or·``None``·to·use·the·instance·default
137	········:param·blocking:·if·``False``,·raise·:class:`~filelock.Timeout`·immediately;·``None``·uses·the·instance·default	142	········:param·blocking:·if·``False``,·raise·:class:`~filelock.Timeout`·immediately;·``None``·uses·the·instance·default

138	········"""	143	········"""
139	········if·timeout·is·None:
140	············timeout·=·self._lock.timeout
141	········if·blocking·is·None:
142	············blocking·=·self._lock.blocking
143	········await·self.acquire_write(timeout,·blocking=blocking)	144	········await·self.acquire_write(timeout,·blocking=blocking)
144	········body_error:·BaseException·\|·None·=·None	145	········body_error:·BaseException·\|·None·=·None
145	········try:	146	········try:
146	············yield	147	············yield
147	········except·BaseException·as·error:	148	········except·BaseException·as·error:
148	············body_error·=·error	149	············body_error·=·error
149	············raise	150	············raise
Offset 157, 67 lines modified		Offset 158, 95 lines modified
157	········try:	158	········try:
158	············await·self.release()	159	············await·self.release()
159	········except·BaseException·as·release_error:	160	········except·BaseException·as·release_error:
160	············if·body_error·is·not·None:	161	············if·body_error·is·not·None:
161	················_append_exception_context(release_error,·body_error)	162	················_append_exception_context(release_error,·body_error)
162	············raise	163	············raise

163	····async·def·acquire_read(~~self,·timeout:·float·=·-1,·*,·blocking:·bool·=·True)·->·AsyncAcquireReadWriteReturnProxy:~~	164	····async·def·acquire_read(
		165	········self,·timeout:·float·\|·None·=·None,·*,·blocking:·bool·\|·None·=·None
		166	····)·->·AsyncAcquireReadWriteReturnProxy:
Max diff block lines reached; 9442/15115 bytes (62.47%) of diff not shown.


Offset 1, 16 lines modified		Offset 1, 18 lines modified
1	"""A·minimal·native·lock·over·a·caller-owned·file·descriptor,·contending·with·:class:`FileLock`·on·the·same·file."""	1	"""A·minimal·native·lock·over·a·caller-owned·file·descriptor,·contending·with·:class:`FileLock`·on·the·same·file."""

2	from·__future__·import·annotations	2	from·__future__·import·annotations

3	import·sys	3	import·sys
4	import·time	4	import·time
5	from·math·import·~~isfinite~~	5	from·threading·import·TIMEOUT_MAX
6	from·typing·import·Final	6	from·typing·import·Final

		7	from·._api·import·_seconds

7	if·sys.platform·==·"win32":··#·pragma:·win32·cover	8	if·sys.platform·==·"win32":··#·pragma:·win32·cover
8	····from·._windows·import·_lock_fd_nonblocking,·_unlock_fd	9	····from·._windows·import·_lock_fd_nonblocking,·_unlock_fd
9	else:··#·pragma:·win32·no·cover	10	else:··#·pragma:·win32·no·cover
10	····from·._unix·import·_lock_fd_nonblocking,·_unlock_fd	11	····from·._unix·import·_lock_fd_nonblocking,·_unlock_fd


11	def·lock_descriptor(fd:·int,·*,·blocking:·bool·=·True,·poll_interval:·float·=·0.05)·->·bool:	12	def·lock_descriptor(fd:·int,·*,·blocking:·bool·=·True,·poll_interval:·float·=·0.05)·->·bool:
Offset 24, 30 lines modified		Offset 26, 31 lines modified

24	····For·timeout,·reentrancy,·singleton,·lifetime,·or·stale-break·behavior,·use·:class:`FileLock`.·There·is·no·async	26	····For·timeout,·reentrancy,·singleton,·lifetime,·or·stale-break·behavior,·use·:class:`FileLock`.·There·is·no·async
25	····wrapper.·Run·this·in·an·executor,·or·drive·``blocking=False``·from·your·own·polling·loop.	27	····wrapper.·Run·this·in·an·executor,·or·drive·``blocking=False``·from·your·own·polling·loop.

26	····:param·fd:·an·open·file·descriptor·the·caller·owns.	28	····:param·fd:·an·open·file·descriptor·the·caller·owns.
27	····:param·blocking:·when·``True``·(default),·retry·the·nonblocking·attempt·every·poll_interval·seconds·until·it	29	····:param·blocking:·when·``True``·(default),·retry·the·nonblocking·attempt·every·poll_interval·seconds·until·it
28	········succeeds;·when·``False``,·make·one·attempt.	30	········succeeds;·when·``False``,·make·one·attempt.
29	····:param·poll_interval:·finite,·positive·seconds·between·attempts·while·blocking;·ignored·when·blocking·is
30	········~~``F~~alse``.	31	····:param·poll_interval:·positive·seconds·between·attempts·while·blocking,·at·most·:data:`threading.TIMEOUT_MAX`;
		32	········ignored·when·blocking·is·``False``.

31	····:returns:·``True``·once·the·lock·is·held,·or·``False``·on·contention·when·``blocking``·is·``False``.	33	····:returns:·``True``·once·the·lock·is·held,·or·``False``·on·contention·when·``blocking``·is·``False``.

32	····:raises·OSError:·for·a·permanent·native·failure,·such·as·an·invalid·descriptor,·or·with·``errno.ENOSYS``·when·the	34	····:raises·OSError:·for·a·permanent·native·failure,·such·as·an·invalid·descriptor,·or·with·``errno.ENOSYS``·when·the
33	········Python·build·lacks·the·native·locking·primitive.·The·descriptor·is·left·open.	35	········Python·build·lacks·the·native·locking·primitive.·The·descriptor·is·left·open.
34	····:raises·ValueError:·if·a·blocking·call·receives·a·no~~n-f~~inite·o~~r·non-posi~~tive·poll_in~~terv~~al.	36	····:raises·ValueError:·if·a·blocking·call·receives·a·poll_interval·outside·that·range,·including·``nan``.

35	····..·versionadded::·3.30.0	37	····..·versionadded::·3.30.0

36	····"""	38	····"""
37	····if·not·blocking:	39	····if·not·blocking:
38	········return·_lock_fd_nonblocking(fd)	40	········return·_lock_fd_nonblocking(fd)
39	····i~~f·not~~·is~~finit~~e(pol~~l_inte~~rval)·~~or·poll~~_in~~terv~~al·<=·0:	41	····#·time.sleep·raises·OverflowError·past·TIMEOUT_MAX;·nan·fails·both·comparisons.
		42	····if·not·0·<·(poll_interval·:=·_seconds("poll_interval",·poll_interval))·<=·TIMEOUT_MAX:
40	········msg:·Final[str]·=·f"poll_interval·must·be·~~fini~~te·and·~~gre~~ater·~~than·0~~,·got·{poll_interval}"	43	········msg:·Final[str]·=·f"poll_interval·must·be·greater·than·0·and·at·most·{TIMEOUT_MAX},·got·{poll_interval}"
41	········raise·ValueError(msg)	44	········raise·ValueError(msg)
42	····while·not·_lock_fd_nonblocking(fd):	45	····while·not·_lock_fd_nonblocking(fd):
43	········time.sleep(poll_interval)	46	········time.sleep(poll_interval)
44	····return·True	47	····return·True


45	def·unlock_descriptor(fd:·int)·->·None:	48	def·unlock_descriptor(fd:·int)·->·None:


Offset 1, 35 lines modified		Offset 1, 47 lines modified
1	from·__future__·import·annotations	1	from·__future__·import·annotations

		2	from·typing·import·Final


2	class·Timeout(TimeoutError):··#·ruff:ignore[error-suffix-on-exception-name]··#·public·exception·name;·renaming·breaks·the·API	3	class·Timeout(TimeoutError):··#·ruff:ignore[error-suffix-on-exception-name]··#·public·exception·name;·renaming·breaks·the·API
3	····"""Raised·when·the·lock·could·not·be·acquired·in·timeout·seconds."""	4	····"""Raised·when·the·lock·could·not·be·acquired·in·timeout·seconds."""

4	····def·__init__(self,·lock_file:·str)·->·None:	5	····def·__init__(self,·lock_file:·str,·holder:·str·\|·None·=·None)·->·None:
5	········super().__init__()	6	········super().__init__()
6	········self._lock_file·=·lock_file	7	········self._lock_file·=·lock_file
		8	········self._holder·=·holder

7	····def·__reduce__(self)·->·tuple[type[Timeout],·tuple[str]]:	9	····def·__reduce__(self)·->·tuple[type[Timeout],·tuple[str],·dict[str,·object]]:
8	········#·~~__in~~i~~t__~~·needs·lo~~ck_fi~~le,·so·pickle·~~must·restore~~·~~it·as·a~~·construc~~tor~~·~~arg~~	10	········#·holder·rides·in·the·state·so·a·subclass·taking·only·lock_file,·and·a·4.0.12·reader,·can·still·unpickle·it.
9	········return·self.__class__,·(self._lock_file,)	11	········return·self.__class__,·(self._lock_file,),·self.__dict__

10	····def·__str__(self)·->·str:··#·pragma:·needs·hard-link	12	····def·__str__(self)·->·str:··#·pragma:·needs·hard-link
11	········re~~tur~~n·f"The·file·lock·'{self._lock_file}'·could·not·be·acquired."	13	········message:·Final·=·f"The·file·lock·'{self._lock_file}'·could·not·be·acquired."
		14	········if·self._holder·is·None:
		15	············return·message
		16	········return·f"{message}·It·is·held·by·{self._holder},·which·this·host·cannot·probe."

12	····def·__repr__(self)·->·str:	17	····def·__repr__(self)·->·str:
13	········return·f"{self.__class__.__name__}({self.lock_file!r})"	18	········return·f"{self.__class__.__name__}({self.lock_file!r})"

14	····@property	19	····@property
15	····def·lock_file(self)·->·str:	20	····def·lock_file(self)·->·str:
16	········"""The·path·of·the·file·lock."""	21	········"""The·path·of·the·file·lock."""
17	········return·self._lock_file	22	········return·self._lock_file


18	class·SoftFileLockLifetimeWarning(~~Depre~~cat~~ion~~Warning):	23	class·SoftFileLockLifetimeWarning(FutureWarning):
		24	····"""
19	····~~"""~~The·configured·soft-lock·lifetime·permits·overlapping·live·holders·after·expiry.~~"""~~	25	····The·configured·soft-lock·lifetime·permits·overlapping·live·holders·after·expiry.

		26	····A·:class:`FutureWarning`·shows·by·default·wherever·the·lock·is·configured;·a·:class:`DeprecationWarning`·shows·only
		27	····in·``__main__``.

		28	····"""


20	class·LeaseSettingsMismatch(ValueError):··#·ruff:ignore[error-suffix-on-exception-name]··#·public·exception·name;·renaming·breaks·the·API	29	class·LeaseSettingsMismatch(ValueError):··#·ruff:ignore[error-suffix-on-exception-name]··#·public·exception·name;·renaming·breaks·the·API
21	····"""A·lease·contender·disagrees·with·the·published·claim·about·how·long·the·lease·lasts."""	30	····"""A·lease·contender·disagrees·with·the·published·claim·about·how·long·the·lease·lasts."""


22	class·SoftFileLockProtocolError(OSError):	31	class·SoftFileLockProtocolError(OSError):
Offset 39, 16 lines modified		Offset 51, 18 lines modified
39	········self._lock_file·=·lock_file	51	········self._lock_file·=·lock_file
40	········self._claim_name·=·claim_name	52	········self._claim_name·=·claim_name
41	········self._reason·=·reason	53	········self._reason·=·reason
42	········super().__init__(self.__str__())	54	········super().__init__(self.__str__())

43	····def·__reduce__(	55	····def·__reduce__(
44	········self,	56	········self,
45	····)·->·tuple[~~type[SoftFileLockProtocolError],·tuple[str,·str·\|·None,·str]]:··#·pragma:·needs·hard-link~~	57	····)·->·tuple[
		58	········type[SoftFileLockProtocolError],·tuple[str,·str·\|·None,·str],·dict[str,·object]
		59	····]:··#·pragma:·needs·hard-link
46	········return·self.__class__,·(self._lock_file,·self._claim_name,·self._reason)	60	········return·self.__class__,·(self._lock_file,·self._claim_name,·self._reason),·self.__dict__

47	····def·__str__(self)·->·str:	61	····def·__str__(self)·->·str:
48	········location·=·self._lock_file·if·self._claim_name·is·None·else·f"{self._lock_file}:·claim·{self._claim_name!r}"	62	········location·=·self._lock_file·if·self._claim_name·is·None·else·f"{self._lock_file}:·claim·{self._claim_name!r}"
49	········return·f"Invalid·strict·soft-lock·state·at·{location}:·{self._reason}"	63	········return·f"Invalid·strict·soft-lock·state·at·{location}:·{self._reason}"

50	····@property	64	····@property
51	····def·lock_file(self)·->·str:··#·pragma:·needs·hard-link	65	····def·lock_file(self)·->·str:··#·pragma:·needs·hard-link


Offset 1, 40 lines modified		Offset 1, 99 lines modified
1	from·__future__·import·annotations	1	from·__future__·import·annotations

		2	import·hashlib
2	import·os	3	import·os
3	import·socket	4	import·socket
4	import·sys	5	import·sys
5	from·errno·import·EPERM,·ESRCH	6	from·errno·import·EPERM,·ESRCH
6	from·pathlib·import·Path	7	from·pathlib·import·Path
7	from·typing·import·Final	8	from·typing·import·Final

		9	#:·Every·marker·format·in·this·package·caps·the·hostname·at·the·RFC·1123·limit·and·reads·a·longer·one·as·malformed.
		10	_HOST_NAME_LIMIT:·Final[int]·=·253
		11	#:·The·bytes·those·formats·carry·verbatim:·printable·non-space·ASCII,·less·the·``?``·reserved·for·the·escape.
		12	_HOST_NAME_VERBATIM:·Final[frozenset[int]]·=·frozenset(range(0x21,·0x7F))·-·{ord("?")}
		13	#:·The·characters·at·the·end·of·an·over-long·name·that·carry·a·digest·of·the·part·cut·off.
		14	_HOST_NAME_DIGEST_LEN:·Final[int]·=·8
		15	#:·The·kernel·ABI·fixes·the·initial·PID·namespace's·inode·(``PID_NS_INIT_INO``·in·``linux/nsfs.h``);·every·namespace
		16	#:·created·later·draws·one·from·``0xF0000000``·up,·so·this·value·names·the·host's·own·namespace.
		17	_INITIAL_PID_NAMESPACE:·Final[int]·=·0xEFFFFFFC
		18	_NAMESPACE_MARK:·Final[str]·=·"?pidns-"


8	def·host_name()·->·str:	19	def·host_name()·->·str:
		20	····"""
9	····~~"""~~The·hostname·recorded·alongside·an·owner,·so·a·marker·written·on·another·machine·is·never·probed·here.~~"""~~	21	····The·hostname·recorded·alongside·an·owner,·so·a·marker·written·on·another·machine·is·never·probed·here.
10	····return·socket.gethostname()
		22	····Marker·formats·here·hold·the·field·to·printable·non-space·ASCII,·while·``socket.gethostname()``·reports·whatever
		23	····the·kernel·stores:·a·space,·a·newline·that·forges·an·extra·marker·line,·or·a·byte·no·codec·encodes,·which·Python
		24	····hands·back·as·a·surrogate.·A·holder·that·publishes·one·raw·writes·a·marker·it·cannot·read·back,·and·loses·the·lock
		25	····to·the·first·peer·that·ages·it·out·as·malformed.·``?``·is·illegal·in·a·hostname,·so·escaping·it·along·with·every
		26	····out-of-grammar·byte·as·``?<hex>``·leaves·a·real·name·untouched·and·still·keeps·two·hosts·apart,·which
		27	····:func:`owner_is_stale`·relies·on·to·refuse·to·probe·a·foreign·PID.

		28	····Linux·appends·the·PID·namespace,·as·Mercurial's·lock·prefix·does.·Two·containers·in·one·pod·share·the·hostname·and
		29	····the·boot·id·but·not·the·PID·namespace,·so·a·PID·recorded·in·one·names·another·process,·or·none,·in·the·other.·The
		30	····suffix·starts·with·a·``?``·no·escape·can·produce,·so·``a``·in·a·namespace·never·reads·as·a·host·literally·named
		31	····``a?pidns-...``.·The·initial·namespace·adds·nothing,·which·keeps·a·host's·name·what·older·releases·recorded.

		32	····An·over-long·name·ends·in·a·digest·of·the·part·cut·to·fit·the·limit.·A·bare·cut·gives·every·name·that·shares·the
		33	····kept·prefix·one·identity,·and·:func:`owner_is_stale`·would·then·probe·a·local·PID·for·another·host's·holder.
		34	····"""
		35	····name·=·(
		36	········"".join(
		37	············chr(byte)·if·byte·in·_HOST_NAME_VERBATIM·else·f"?{byte:02x}"
		38	············for·byte·in·socket.gethostname().encode("utf-8",·"surrogateescape")
		39	········)
		40	········+·_pid_namespace_suffix()
		41	····)
		42	····if·len(name)·>·_HOST_NAME_LIMIT:
		43	········keep·=·_HOST_NAME_LIMIT·-·_HOST_NAME_DIGEST_LEN·-·1
		44	········name·=·f"{name[:keep]}-{hashlib.sha256(name[keep:].encode()).hexdigest()[:_HOST_NAME_DIGEST_LEN]}"
		45	····#·An·escape·is·three·characters·and·a·kept·byte·is·never·'?',·so·a·bare·'?'·can·only·mean·an·empty·hostname.
		46	····return·name·or·"?"


		47	def·_pid_namespace_suffix()·->·str:
		48	····try:
		49	········namespace:·Final·=·Path("/proc/self/ns/pid").stat().st_ino
		50	····except·OSError:··#·only·Linux·3.8+·has·the·file,·and·a·sandbox·may·hide·it;·nothing·else·tells·namespaces·apart
		51	········return·""
		52	····return·""·if·namespace·==·_INITIAL_PID_NAMESPACE·else·f"{_NAMESPACE_MARK}{namespace:x}"


11	def·owner_is_stale(pid:·int,·hostname:·str,·start_token:·int·\|·None)·->·bool:	53	def·owner_is_stale(pid:·int,·hostname:·str,·start_token:·int·\|·None)·->·bool:
12	····"""	54	····"""
13	····Whether·the·recorded·owner·is·provably·gone,·so·reclaiming·its·marker·cannot·detach·a·live·holder.	55	····Whether·the·recorded·owner·is·provably·gone,·so·reclaiming·its·marker·cannot·detach·a·live·holder.

14	····Fail·closed:·return·``True``·only·when·this·process·can·prove·the·exact·recorded·owner·is·dead.·A·marker·from	56	····Fail·closed:·return·``True``·only·when·this·process·can·prove·the·exact·recorded·owner·is·dead.·A·marker·from
15	····another·host·cannot·be·probed;·a·live·PID·whose·start·token·still·matches,·or·whose·token·cannot·be·read,·is·the	57	····another·host·cannot·be·probed;·a·live·PID·whose·start·token·still·matches,·or·whose·token·cannot·be·read,·is·the
16	····holder·or·is·indistinguishable·from·it;·a·live·PID·whose·start·token·differs·is·a·recycled·PID,·so·the·process·that	58	····holder·or·is·indistinguishable·from·it;·a·live·PID·whose·start·token·differs·is·a·recycled·PID,·so·the·process·that
17	····wrote·the·marker·is·gone.·PostgreSQL,·Qt·``QLockFile``·and·Mercurial·all·break·a·stale·lock·only·on·proof·of·death	59	····wrote·the·marker·is·gone.·PostgreSQL,·Qt·``QLockFile``·and·Mercurial·all·break·a·stale·lock·only·on·proof·of·death
18	····and·treat·an·unreadable·or·foreign·owner·as·still·holding.	60	····and·treat·an·unreadable·or·foreign·owner·as·still·holding.
19	····"""	61	····"""
20	····if·hostname·!=·host_name():	62	····if·hostname·!=·host_name():
21	········return·False	63	········return·False
22	····if·not·process_a~~liv~~e(pid):	64	····if·process_alive(pid)·and·(start_token·is·None·or·process_start_token(pid)·in·{None,·start_token}):
23	········return·~~Tru~~e	65	········return·False
24	····if·start_token·is·None:	66	····#·Only·a·bare·hostname·can·be·an·older·release's,·written·from·a·container·that·shares·this·host's·name.
		67	····return·_NAMESPACE_MARK·in·hostname·or·not·_owner_runs_elsewhere(pid,·start_token)


		68	def·owner_is_current_process(pid:·int,·hostname:·str,·start_token:·int·\|·None)·->·bool:
		69	····"""
		70	····Whether·the·recorded·owner·is·this·process,·so·a·marker·a·recycled·PID·left·behind·never·reads·as·ours.

		71	····Fail·closed:·a·recorded·start·token·must·match·this·process's.·One·that·differs·was·written·by·an·earlier·process
		72	····that·reused·this·PID,·and·when·this·process·cannot·read·its·own·token·nothing·proves·the·marker·is·ours.·A·marker
		73	····without·a·token·falls·back·to·the·PID·and·hostname.
		74	····"""
		75	····if·pid·!=·os.getpid()·or·hostname·!=·host_name():
25	········return·False	76	········return·False
		77	····return·start_token·is·None·or·start_token·==·process_start_token(pid)
26	····current·=·process_start_token(pid)
27	····return·current·is·not·None·and·current·!=·start_token


28	if·sys.platform·==·"win32":··#·pragma:·win32·cover	78	if·sys.platform·==·"win32":··#·pragma:·win32·cover
29	····import·ctypes	79	····import·ctypes
30	····from·ctypes·import·wintypes	80	····from·ctypes·import·wintypes

31	····_KERNEL32:·Final[ctypes.WinDLL]·=·ctypes.WinDLL("kernel32",·use_last_error=True)	81	····_KERNEL32:·Final[ctypes.WinDLL]·=·ctypes.WinDLL("kernel32",·use_last_error=True)
Offset 130, 14 lines modified		Offset 189, 47 lines modified
130	················return·None	189	················return·None
131	············try:	190	············try:
132	················starttime·=·int(fields[_STARTTIME_INDEX])	191	················starttime·=·int(fields[_STARTTIME_INDEX])
133	············except·ValueError:··#·pragma:·no·cover··#·/proc·always·renders·starttime·as·an·integer	192	············except·ValueError:··#·pragma:·no·cover··#·/proc·always·renders·starttime·as·an·integer
134	················return·None	193	················return·None
135	············return·(_BOOT_ID·<<·64)·\|·starttime	194	············return·(_BOOT_ID·<<·64)·\|·starttime

		195	········def·_owner_runs_elsewhere(pid:·int,·start_token:·int·\|·None)·->·bool:
		196	············"""
		197	············Whether·the·owner·runs·in·another·PID·namespace·as·pid.

		198	············An·older·release·in·a·container·sharing·this·hostname·recorded·its·in-container·PID,·which·means·nothing
		199	············here.·starttime·and·the·boot·id·are·kernel-wide,·so·a·task·with·that·start·token·whose·innermost·PID·is
		200	············pid·is·the·owner;·one·that·merely·started·in·the·same·tick·is·not.
		201	············"""
		202	············if·start_token·is·None·or·start_token·>>·64·!=·_BOOT_ID:
		203	················return·False
		204	············try:
		205	················with·os.scandir("/proc")·as·entries:
		206	····················return·any(
		207	························entry.name.isdigit()
		208	························and·(task·:=·int(entry.name))·!=·pid
		209	························and·process_start_token(task)·==·start_token
		210	························and·_innermost_pid(task)·==·pid
		211	························for·entry·in·entries
Max diff block lines reached; 925/8755 bytes (10.57%) of diff not shown.


Offset 1, 37 lines modified		Offset 1, 39 lines modified
1	from·__future__·import·annotations	1	from·__future__·import·annotations

2	import·os	2	import·os
3	import·secrets	3	import·secrets
		4	import·sys
4	import·time	5	import·time
5	from·contextlib·import·suppress	6	from·contextlib·import·suppress
6	from·dataclasses·import·dataclass	7	from·dataclasses·import·dataclass
		8	from·math·import·isfinite
7	from·threading·import·Event,·Thread,·current_thread~~,·local~~	9	from·threading·import·Event,·Thread,·current_thread
8	from·typing·import·TYPE_CHECKING,·Literal	10	from·typing·import·TYPE_CHECKING,·Final,·Literal,·cast
		11	from·weakref·import·WeakMethod

		12	from·._api·import·_check_timeout_max,·_seconds
9	from·._error·import·LeaseSettingsMismatch	13	from·._error·import·LeaseSettingsMismatch
10	from·._identity·import·owner_is_stale	14	from·._identity·import·owner_is_stale
11	from·._marker·import·MarkerSoftFileLock,·OwnerMode,·OwnerRecord,·parse_marker	15	from·._marker·import·MarkerSoftFileLock,·OwnerMode,·OwnerRecord,·parse_marker
12	from·._soft·import·_read_lock_file	16	from·._soft·import·_read_lock_file
13	from·._util·import·break_lock_file,·touch	17	from·._util·import·break_lock_file,·touch

14	if·TYPE_CHECKING:	18	if·TYPE_CHECKING:
15	····import·sys
16	····from·collections.abc·import·Callable	19	····from·collections.abc·import·Callable,·Mapping
		20	····from·typing·import·Unpack

17	····from·._api·import·LockOptions	21	····from·._api·import·LockOptions,·_ExtraValue

		22	#:·``evicted``·is·a·:class:`~filelock.SoftReadWriteLock`·loss:·a·peer·waited·out·the·stale·threshold·and·committed·a
		23	#:·generation·without·this·holder.
		24	CompromiseReason·=·Literal["marker-missing",·"owner-changed",·"refresh-failed",·"evicted"]
18	····if·sys.version_info·>=·(3,·11):··#·pragma:·no·cover·(py311+)
19	········from·typing·import·Unpack
20	····else:··#·pragma:·no·cover·(<py311)
21	········from·typing_extensions·import·Unpack

		25	_RefreshOutcome·=·Literal["ok",·"transient",·"marker-missing",·"owner-changed"]
		26	_DEFAULT_LEASE_DURATION:·Final[float]·=·30.0
22	CompromiseReason·=·Literal["marker-missing",·"owner-changed",·"refresh-failed"]

23	_RefreshOutcome·=·Literal["ok",·"lost",·"transient"]


24	@dataclass(frozen=True)	27	@dataclass(frozen=True)
25	class·LeaseCompromise:	28	class·LeaseCompromise:
26	····"""Why·a·held·lease·stopped·being·this·process's·to·hold."""	29	····"""Why·a·held·lease·stopped·being·this·process's·to·hold."""

27	····lock_file:·str	30	····lock_file:·str
Offset 53, 36 lines modified		Offset 55, 23 lines modified
53	····"""The·state·of·one·claim:·its·token,·its·heartbeat,·and·how·that·claim·was·lost."""	55	····"""The·state·of·one·claim:·its·token,·its·heartbeat,·and·how·that·claim·was·lost."""

54	····token:·str·\|·None·=·None	56	····token:·str·\|·None·=·None
55	····compromise:·LeaseCompromise·\|·None·=·None	57	····compromise:·LeaseCompromise·\|·None·=·None
56	····heartbeat:·_Heartbeat·\|·None·=·None	58	····heartbeat:·_Heartbeat·\|·None·=·None


57	class·_LeaseClaimHolder:
58	····"""Holds·the·claim·its·owning·context·acquired."""

59	····#·Only·the·holder·is·thread-local,·mirroring·FileLockContext:·the·claim·stays·an·ordinary·object,·so·the·heartbeat
60	····#·thread·records·a·compromise·where·the·thread·that·acquired·the·lease·reads·it.

61	····def·__init__(self)·->·None:
62	········self.claim·=·_LeaseClaim()


63	class·_ThreadLocalLeaseClaimHolder(_LeaseClaimHolder,·local):
64	····"""A·thread·local·version·of·the·``_LeaseClaimHolder``·class."""


65	class·SoftFileLease(MarkerSoftFileLock):	59	class·SoftFileLease(MarkerSoftFileLock):
66	····"""	60	····"""
67	····Existence·lock·whose·claim·expires,·so·a·peer·may·take·it·while·the·previous·holder·still·runs.	61	····Existence·lock·whose·claim·expires,·so·a·peer·may·take·it·while·the·previous·holder·still·runs.

68	····A·lease·trades·mutual·exclusion·for·progress.·The·holder·publishes·a·claim·and·refreshes·it·every	62	····A·lease·trades·mutual·exclusion·for·progress.·The·holder·publishes·a·claim·and·refreshes·it·every
69	····``heartbeat_interval``·seconds;·a·contender·takes·the·marker·once·it·is·``le~~ase_du~~ra~~tion``~~·seco~~nds·st~~ale~~.·No~~thing	63	····``heartbeat_interval``·seconds;·a·contender·takes·the·marker·once·it·has·seen·no·refresh·for·``lease_duration``
		64	····seconds·of·its·own·monotonic·clock,·so·clock·skew·between·hosts·cannot·expire·a·live·claim.·Nothing·stops·the
70	····~~stops·the·~~expired·holder:·it·keeps·running,·and·it·keeps·using·whatever·the·lock·protects.·Treat·the·lease·as·a·hint	65	····expired·holder:·it·keeps·running,·and·it·keeps·using·whatever·the·lock·protects.·Treat·the·lease·as·a·hint·about
71	····~~about·~~who·should·be·working,·not·as·a·guarantee·that·only·one·worker·is.	66	····who·should·be·working,·not·as·a·guarantee·that·only·one·worker·is.

72	····To·make·a·protected·resource·reject·a·superseded·holder,·that·resource·must·be·linearizable·and·must·fence·on·a	67	····To·make·a·protected·resource·reject·a·superseded·holder,·that·resource·must·be·linearizable·and·must·fence·on·a
73	····monotonic·generation·it·controls.·:attr:`token`·names·a·claim;·it·does·not·fence·one.·Where·overlap·is·unacceptable,	68	····monotonic·generation·it·controls.·:attr:`token`·names·a·claim;·it·does·not·fence·one.·Where·overlap·is·unacceptable,
74	····use·:class:`StrictSoftFileLock·<filelock.StrictSoftFileLock>`·instead.	69	····use·:class:`StrictSoftFileLock·<filelock.StrictSoftFileLock>`·instead.

75	····Every·contender·for·a·path·must·agree·on·``lease_duration``.·A·contender·that·finds·a·claim·published·under·a	70	····Every·contender·for·a·path·must·agree·on·``lease_duration``.·A·contender·that·finds·a·claim·published·under·a
76	····different·duration·raises·:class:`LeaseSettingsMismatch·<filelock.LeaseSettingsMismatch>`·rather·than·apply·its·own	71	····different·duration·raises·:class:`LeaseSettingsMismatch·<filelock.LeaseSettingsMismatch>`·rather·than·apply·its·own
Offset 108, 54 lines modified		Offset 97, 80 lines modified
108	····_lifetime_supported:·bool·=·False	97	····_lifetime_supported:·bool·=·False
109	····_lifetime_unsupported_reason:·str·=·"lease_duration·sets·when·a·lease·expires"	98	····_lifetime_unsupported_reason:·str·=·"lease_duration·sets·when·a·lease·expires"

110	····def·__init__(	99	····def·__init__(
111	········self,	100	········self,
112	········lock_file:·str·\|·os.PathLike[str],	101	········lock_file:·str·\|·os.PathLike[str],
113	········*,	102	········*,
114	········lease_duration:·float·=·~~30.0~~,	103	········lease_duration:·float·=·_DEFAULT_LEASE_DURATION,
115	········heartbeat_interval:·float·\|·None·=·None,	104	········heartbeat_interval:·float·\|·None·=·None,
116	········on_compromise:·Callable[[LeaseCompromise],·None]·\|·None·=·None,	105	········on_compromise:·Callable[[LeaseCompromise],·None]·\|·None·=·None,
117	········**kwargs:·Unpack[LockOptions],	106	········**kwargs:·Unpack[LockOptions],
118	····)·->·None:	107	····)·->·None:
119	········"""	108	········"""
120	········Create·a·lease.	109	········Create·a·lease.

121	········:param·lease_duration:·seconds·~~of·mark~~er·stale~~ness~~·after·~~which·a·cont~~ender·may·take·the·claim.~~·Every·contender~~	110	········:param·lease_duration:·seconds·a·contender·must·see·the·marker·go·unrefreshed·before·it·may·take·the·claim.
122	············for·the·path·must·pass·the·same·value.	111	············Every·contender·for·the·path·must·pass·the·same·value.
123	········:param·heartbeat_interval:·seconds·between·refreshes.·Defaults·to·a·third·of·``lease_duration``,·leaving·room	112	········:param·heartbeat_interval:·seconds·between·refreshes.·Defaults·to·a·third·of·``lease_duration``,·leaving·room
124	············for·two·missed·refreshes·before·a·peer·may·take·the·claim.·Must·be·shorter·than·``lease_duration``.	113	············for·two·missed·refreshes·before·a·peer·may·take·the·claim.·Must·be·shorter·than·``lease_duration``·and·at
		114	············most·:data:`threading.TIMEOUT_MAX`.
125	········:param·on_compromise:·called·from·the·heartbeat·thread·with·a·:class:`LeaseCompromise`·when·the·claim·is·lost.	115	········:param·on_compromise:·called·from·the·heartbeat·thread·with·a·:class:`LeaseCompromise`·when·the·claim·is·lost.
126	········:param·kwargs:·every·other·:class:`BaseFileLock·<filelock.BaseFileLock>`·option,·``timeout``·and·``mode``·among	116	········:param·kwargs:·every·other·:class:`BaseFileLock·<filelock.BaseFileLock>`·option,·``timeout``·and·``mode``·among
127	············them.·The·metaclass·passes·them·all·by·keyword,·and·taking·them·here·lets	117	············them.·The·metaclass·passes·them·all·by·keyword,·and·taking·them·here·lets
128	············:class:`AsyncSoftFileLease·<filelock.AsyncSoftFileLease>`·add·the·async·plumbing·a·fixed·signature·would	118	············:class:`AsyncSoftFileLease·<filelock.AsyncSoftFileLease>`·add·the·async·plumbing·a·fixed·signature·would
129	············hide.	119	············hide.

130	········"""	120	········"""
131	········if·lease_duration·<=·0:	121	········#·A·plain·float:·the·marker·records·its·repr,·which·NumPy's·float64·spells·in·a·form·no·parser·reads.
		122	········if·not·isfinite(lease_duration·:=·_seconds("lease_duration",·lease_duration))·or·lease_duration·<=·0:
132	············msg·=·f"lease_duration·must·be·positive,·got·{lease_duration!r}"	123	············msg·=·f"lease_duration·must·be·positive·and·finite,·got·{lease_duration!r}"
133	············raise·ValueError(msg)	124	············raise·ValueError(msg)
134	········~~if·~~heartbeat_interval·is·~~None~~:	125	········heartbeat_interval·=·(
135	············heartbeat_interval·=·lease_duration~~·/·3~~	126	············lease_duration·/·3·if·heartbeat_interval·is·None·else·_seconds("heartbeat_interval",·heartbeat_interval)
		127	········)
136	········if·not·0·<·heartbeat_interval·<·lease_duration:	128	········if·not·0·<·heartbeat_interval·<·lease_duration:
137	············msg·=·f"heartbeat_interval·must·be·positive·and·below·lease_duration,·got·{heartbeat_interval!r}"	129	············msg·=·f"heartbeat_interval·must·be·positive·and·below·lease_duration,·got·{heartbeat_interval!r}"
138	············raise·ValueError(msg)	130	············raise·ValueError(msg)
		131	········_check_timeout_max("heartbeat_interval",·heartbeat_interval)
139	········super().__init__(lock_file,·**kwargs)	132	········super().__init__(lock_file,·**kwargs)
140	········self._lease_duration·=·lease_duration	133	········self._lease_duration·=·lease_duration
141	········self._heartbeat_interval·=·heartbeat_interval	134	········self._heartbeat_interval·=·heartbeat_interval
Max diff block lines reached; 15268/22353 bytes (68.30%) of diff not shown.


Offset 1, 46 lines modified		Offset 1, 39 lines modified
1	from·__future__·import·annotations	1	from·__future__·import·annotations

2	import·math	2	import·math
3	import·os	3	import·os
		4	import·re
4	from·contextlib·import·suppress	5	from·contextlib·import·suppress
5	from·typing·import·Final,·Literal,·NamedTuple	6	from·typing·import·Final,·Literal,·NamedTuple

6	from·._identity·import·host_name,·process_start_token	7	from·._identity·import·host_name,·owner_is_current_process,·owner_is_stale,·process_start_token
7	from·._soft·import·SoftFileLock,·_read_lock_file	8	from·._soft·import·SoftFileLock,·_read_lock_file,·parse_decimal
8	from·._util·import·write_all	9	from·._util·import·break_lock_file,·write_all

9	#:·Protocol·1·is·the·legacy·``<pid>\n<hostname>\n[<start_token>\n]``·marker·that·:class:`SoftFileLock`·still·writes.	10	#:·Protocol·1·is·the·legacy·``<pid>\n<hostname>\n[<start_token>\n]``·marker·that·:class:`SoftFileLock`·still·writes.
10	#:·Protocol·2·carries·the·owner·mode·and·the·lease·claim.·A·protocol·1·reader·treats·a·protocol·2·marker·as·malformed	11	#:·Protocol·2·carries·the·owner·mode·and·the·lease·claim.·A·protocol·1·reader·treats·a·protocol·2·marker·as·malformed
11	#:·and·evicts·it·after·its·grace·period,·so·the·two·never·guarantee·mutual·exclusion·against·each·other.	12	#:·and·evicts·it·after·its·grace·period,·so·the·two·never·guarantee·mutual·exclusion·against·each·other.
12	_PROTOCOL:·Final[str]·=·"filelock/2"	13	_PROTOCOL:·Final[str]·=·"filelock/2"

13	_MAX_PID:·Final[int]·=·2**31·-·1	14	_MAX_PID:·Final[int]·=·2**31·-·1

14	#:·``unknown``·is·never·published:·it·names·a·mode·some·other·filelock·wrote·that·this·version·cannot·interpret.·Such·a
15	#:·record·still·identifies·a·live·owner,·so·it·is·parsed·rather·than·read·as·malformed·and·aged·out.
16	~~Own~~erMode·~~=·L~~iteral["lease",·"un~~known"]~~	15	#:·The·forms·``repr``·gives·a·non-negative·finite·float·or·int;·``float()``·would·also·accept·whitespace,·underscores
		16	#:·and·non-ASCII·digits.
		17	_DURATION:·Final[re.Pattern[str]]·=·re.compile(r"[0-9]+(?:\.[0-9]+)?(?:e[+-][0-9]+)?",·re.ASCII)

		18	#:·Preserve·unknown·contracts·so·contenders·cannot·mistake·them·for·malformed,·reclaimable·markers.
		19	OwnerMode·=·Literal["lease",·"exclusive",·"unknown"]

17	class·OwnerRecord(NamedTuple):
18	····"""The·owner·published·in·a·protocol·2·marker."""

19	····pid:·int
20	····hostname:·str
21	····mode:·OwnerMode
22	····token:·str·\|·None·=·None
23	····lease_duration:·float·\|·None·=·None
24	····start:·int·\|·None·=·None


25	class·MarkerSoftFileLock(SoftFileLock):	20	class·MarkerSoftFileLock(SoftFileLock):
26	····"""An·existence·lock·whose·marker·carries·a·protocol·2·owner·record."""	21	····"""An·existence·lock·whose·marker·carries·a·protocol·2·owner·record."""

27	····#:·Fille~~d·in~~·by·each·m~~ode·so~~·the·pu~~bli~~shed·rec~~ord~~·~~sta~~t~~es·~~the·con~~tra~~ct·its·holder·ac~~quired~~·un~~der~~.	22	····#:·Age-based·expiry·requires·a·lease·contract;·an·exclusive·holder·grants·none.
28	····_owner_mode:·OwnerMode	23	····_owner_mode:·OwnerMode·=·"exclusive"

29	····@property	24	····@property
30	····def·owner(self)·->·OwnerRecord·\|·None:	25	····def·owner(self)·->·OwnerRecord·\|·None:
31	········"""	26	········"""
32	········The·owner·named·by·the·marker·on·disk.	27	········The·owner·named·by·the·marker·on·disk.

33	········:returns:·the·published·record,·or·``None``·when·no·marker·exists·or·its·record·is·malformed·or·protocol·1	28	········:returns:·the·published·record,·or·``None``·when·no·marker·exists·or·its·record·is·malformed·or·protocol·1
Offset 59, 29 lines modified		Offset 52, 44 lines modified
59	········return·None·if·(owner·:=·self._read_owner())·is·None·else·owner.pid	52	········return·None·if·(owner·:=·self._read_owner())·is·None·else·owner.pid

60	····@property	53	····@property
61	····def·is_lock_held_by_us(self)·->·bool:	54	····def·is_lock_held_by_us(self)·->·bool:
62	········"""	55	········"""
63	········Whether·the·marker·on·disk·names·this·process.	56	········Whether·the·marker·on·disk·names·this·process.

64	········:returns:·``True``·when·the·marker's·~~PID~~·~~and~~·hostname·ma~~tch~~·this·process	57	········:returns:·``True``·when·the·marker·names·this·process's·PID,·hostname·and,·when·recorded,·start·token

65	········"""	58	········"""
66	········owner·=·self._read_owner()	59	········owner·=·self._read_owner()
67	········return·owner·is·not·None·and·owner~~.pid·==·~~o~~s.getpid()·an~~d·owner.hostname·~~==·ho~~st_name()	60	········return·owner·is·not·None·and·owner_is_current_process(owner.pid,·owner.hostname,·owner.start)

68	····def·force_break(self)·->·None:	61	····def·force_break(self)·->·None:
69	········"""	62	········"""
70	········Remove·the·marker·whoever·holds·it,·so·a·later·contender·can·acquire.	63	········Remove·the·marker·whoever·holds·it,·so·a·later·contender·can·acquire.

71	········Forced·breaking·voids·mutual·exclusion:·the·previous·holder·keeps·running·and·keeps·using·whatever·the·lock	64	········Forced·breaking·voids·mutual·exclusion:·the·previous·holder·keeps·running·and·keeps·using·whatever·the·lock
72	········protects.·Reserve·it·for·an·operator·clearing·a·marker·whose·holder·is·known·to·be·gone.	65	········protects.·Reserve·it·for·an·operator·clearing·a·marker·whose·holder·is·known·to·be·gone.
73	········"""	66	········"""
74	········self.break_lock()	67	········self.break_lock()

		68	····def·_try_break_stale_lock(self)·->·None:
		69	········with·suppress(OSError,·ValueError):
		70	············snapshot:·Final[tuple[str·\|·None,·float,·int]]·=·_read_lock_file(self.lock_file)
		71	············owner:·Final[OwnerRecord·\|·None]
		72	············if·(owner·:=·parse_marker(snapshot[0]))·is·None:
		73	················super()._try_break_stale_lock()
		74	············elif·owner.mode·!=·"unknown"·and·owner_is_stale(owner.pid,·owner.hostname,·owner.start):
		75	················break_lock_file(self.lock_file,·*snapshot[1:])

		76	····@classmethod
		77	····def·_recorded_holder(cls,·content:·str·\|·None)·->·tuple[int,·str]·\|·None:
		78	········if·(owner·:=·parse_marker(content))·is·not·None:
		79	············return·owner.pid,·owner.hostname
		80	········return·super()._recorded_holder(content)

75	····def·_read_owner(self)·->·OwnerRecord·\|·None:	81	····def·_read_owner(self)·->·OwnerRecord·\|·None:
76	········with·suppress(OSError,·ValueError):	82	········with·suppress(OSError,·ValueError):
77	············return·parse_marker(_read_lock_file(self.lock_file)[0])	83	············return·parse_marker(_read_lock_file(self.lock_file)[0])
78	········return·None	84	········return·None

79	····def·_write_lock_info(self,·fd:·int)·->·None:	85	····def·_write_lock_info(self,·fd:·int)·->·None:
80	········write_all(fd,·encode_marker(self._published_record()))	86	········write_all(fd,·encode_marker(self._published_record()))
Offset 91, 29 lines modified		Offset 99, 41 lines modified
91	············pid=os.getpid(),	99	············pid=os.getpid(),
92	············hostname=host_name(),	100	············hostname=host_name(),
93	············mode=self._owner_mode,	101	············mode=self._owner_mode,
94	············start=process_start_token(os.getpid()),	102	············start=process_start_token(os.getpid()),
95	········)	103	········)


		104	class·OwnerRecord(NamedTuple):
		105	····"""Keep·optional·metadata·when·reading·unknown·lock·modes."""

		106	····pid:·int
		107	····hostname:·str
		108	····mode:·OwnerMode
		109	····token:·str·\|·None·=·None
		110	····lease_duration:·float·\|·None·=·None
		111	····start:·int·\|·None·=·None


96	def·encode_marker(record:·OwnerRecord)·->·bytes:	112	def·encode_marker(record:·OwnerRecord)·->·bytes:
97	····"""Render·an·owner·record·as·the·bytes·a·protocol·2·marker·holds."""	113	····"""Render·an·owner·record·as·the·bytes·a·protocol·2·marker·holds."""
98	····lines·=·[_PROTOCOL,·f"pid={record.pid}",·f"host={record.hostname}",·f"mode={record.mode}"]	114	····lines·=·[_PROTOCOL,·f"pid={record.pid}",·f"host={record.hostname}",·f"mode={record.mode}"]
99	····if·record.token·is·not·None:	115	····if·record.token·is·not·None:
100	········lines.append(f"token={record.token}")	116	········lines.append(f"token={record.token}")
101	····if·record.lease_duration·is·not·None:	117	····if·record.lease_duration·is·not·None:
102	········lines.append(f"duration={record.lease_duration!r}")	118	········lines.append(f"duration={record.lease_duration!r}")
103	····if·record.start·is·not·None:	119	····if·record.start·is·not·None:
104	········lines.append(f"start={record.start}")	120	········lines.append(f"start={record.start}")
105	····return·"".join(f"{line}\n"·for·line·in·lines).encode()	121	····return·"".join(f"{line}\n"·for·line·in·lines).encode()


Max diff block lines reached; 2959/8614 bytes (34.35%) of diff not shown.


Offset 1, 37 lines modified		Offset 1, 52 lines modified
1	from·__future__·import·annotations	1	from·__future__·import·annotations

		2	import·hashlib
2	import·logging	3	import·logging
3	import·os	4	import·os
4	import·pathlib	5	import·pathlib
		6	import·shutil
5	import·sqlite3	7	import·sqlite3
		8	import·stat
6	import·sys	9	import·sys
		10	import·tempfile
7	import·threading	11	import·threading
8	import·time	12	import·time
		13	from·collections·import·deque
9	from·contextlib·import·contextmanager,·suppress	14	from·contextlib·import·contextmanager,·suppress
		15	from·dataclasses·import·dataclass,·field
		16	from·itertools·import·count
10	from·typing·import·TYPE_CHECKING,·ClassVar,·Final,·Literal,·TypeAlias,·cast	17	from·typing·import·TYPE_CHECKING,·ClassVar,·Final,·Literal,·NamedTuple,·TypeAlias,·cast
11	from·weakref·import·WeakValueDictionary	18	from·weakref·import·WeakValueDictionary

12	from·._api·import·(	19	from·._api·import·(
13	····AcquireReturnProxy,	20	····AcquireReturnProxy,
		21	····_canonical,
14	····_ensure_current_process,	22	····_ensure_current_process,
15	····_fork_transition,	23	····_fork_transition,
16	····_raise_chained_errors,	24	····_raise_chained_errors,
17	····_register_fork_class,	25	····_register_fork_class,
18	····_register_fork_object,	26	····_register_fork_object,
		27	····_register_owned_descriptor,
		28	····_resolve_read_write_timeout,
		29	····_seconds,
		30	····_timeout_behavior,
		31	····_unregister_owned_descriptor,
19	)	32	)
20	from·._error·import·Timeout	33	from·._error·import·Timeout
		34	from·._identity·import·host_name,·owner_is_stale,·process_start_token

		35	if·sys.platform·==·"win32":··#·pragma:·win32·cover
		36	····from·._windows·import·_open_non_reparse_fd

21	if·TYPE_CHECKING:	37	if·TYPE_CHECKING:
22	····from·collections.abc·import·Callable,·Generator	38	····from·collections.abc·import·Callable,·Generator
		39	····from·typing·import·Self

		40	····from·_typeshed·import·Unused
23	····if·sys.version_info·>=·(3,·11):
24	········from·typing·import·Self
25	····else:
26	········from·typing_extensions·import·Self

27	_LOGGER:·Final[logging.Logger]·=·logging.getLogger("filelock")	41	_LOGGER:·Final[logging.Logger]·=·logging.getLogger("filelock")
28	_GETPID:·Final[Callable[[],·int]]·=·os.getpid	42	_GETPID:·Final[Callable[[],·int]]·=·os.getpid
29	_IS_PYPY:·Final[bool]·=·sys.implementation.name·==·"pypy"	43	_IS_PYPY:·Final[bool]·=·sys.implementation.name·==·"pypy"
30	_NEEDS_CONNECTION_ESCROW:·Final[bool]·=·(	44	_NEEDS_CONNECTION_ESCROW:·Final[bool]·=·(
31	····hasattr(os,·"register_at_fork")·and·sys.implementation.name·==·"cpython"·and·sys.version_info·<·(3,·12)	45	····hasattr(os,·"register_at_fork")·and·sys.implementation.name·==·"cpython"·and·sys.version_info·<·(3,·12)
32	)	46	)
Offset 39, 14 lines modified		Offset 54, 23 lines modified
39	····str·\|·bytes·\|·os.PathLike[str]·\|·os.PathLike[bytes]·\|·float·\|·int·\|·type[sqlite3.Connection]·\|·None	54	····str·\|·bytes·\|·os.PathLike[str]·\|·os.PathLike[bytes]·\|·float·\|·int·\|·type[sqlite3.Connection]·\|·None
40	)	55	)
41	_DatabaseIdentity:·TypeAlias·=·tuple[int,·int]	56	_DatabaseIdentity:·TypeAlias·=·tuple[int,·int]

42	#·sqlite3_busy_timeout()·accepts·a·C·int,·max·2_147_483_647·on·32-bit.·Use·a·lower·value·to·be·safe·(~23·days).	57	#·sqlite3_busy_timeout()·accepts·a·C·int,·max·2_147_483_647·on·32-bit.·Use·a·lower·value·to·be·safe·(~23·days).
43	_MAX_SQLITE_TIMEOUT_MS:·Final[int]·=·2_000_000_000·-·1	58	_MAX_SQLITE_TIMEOUT_MS:·Final[int]·=·2_000_000_000·-·1
44	_UNSAFE_FORK_EXIT_STATUS:·Final[int]·=·70	59	_UNSAFE_FORK_EXIT_STATUS:·Final[int]·=·70
		60	#·O_NONBLOCK·keeps·an·open·from·blocking·on·a·FIFO·planted·at·the·path;·the·regular-file·check·then·rejects·it.
		61	_DB_OPEN_FLAGS:·Final[int]·=·os.O_RDWR·\|·os.O_CREAT·\|·getattr(os,·"O_NOFOLLOW",·0)·\|·getattr(os,·"O_NONBLOCK",·0)
		62	#·Descriptor·paths·reopen·the·validated·inode;·journal_mode=MEMORY·avoids·an·on-disk·journal·at·the·synthetic·path.
		63	_FD_DIR:·Final[str]·=·"/proc/self/fd"·if·sys.platform·==·"linux"·else·"/dev/fd"
		64	#·Header·bytes·18·and·19·hold·the·file·format·versions,·2·in·WAL·mode:·https://www.sqlite.org/fileformat.html
		65	_SQLITE_MAGIC:·Final[bytes]·=·b"SQLite·format·3\x00"
		66	_FORMAT_VERSIONS:·Final[slice]·=·slice(18,·20)
		67	_HEADER_SIZE:·Final[int]·=·20
		68	_WAL_FORMAT_VERSION:·Final[int]·=·2


45	class·_SQLiteTransitionContext(threading.local):	69	class·_SQLiteTransitionContext(threading.local):
46	····depth:·int·=·0	70	····depth:·int·=·0


47	_SQLITE_TRANSITION_CONTEXT:·Final·=·_SQLiteTransitionContext()	71	_SQLITE_TRANSITION_CONTEXT:·Final·=·_SQLiteTransitionContext()
Offset 130, 51 lines modified		Offset 154, 176 lines modified
130	········except·OSError:	154	········except·OSError:
131	············return·None	155	············return·None
132	········return·stat_result.st_dev,·stat_result.st_ino	156	········return·stat_result.st_dev,·stat_result.st_ino


133	_FORKED_DATABASES:·Final·=·_ForkedDatabaseRegistry()	157	_FORKED_DATABASES:·Final·=·_ForkedDatabaseRegistry()

		158	_LINK_PREFIX:·Final[str]·=·".filelock-"
		159	_SWEPT_DIRECTORIES:·Final[set[str]]·=·set()


		160	#·POSIX·locks·belong·to·the·process·and·the·inode,·so·closing·any·descriptor·on·the·inode·drops·the·locks·every·other
		161	#·connection·of·this·process·holds·there.·SQLite·defers·its·own·closes·for·this·reason·(section·2.2·of
		162	#·https://www.sqlite.org/howtocorrupt.html);·the·probes·stay·open·until·the·last·connection·on·their·inode·closes.
		163	class·_ProbeDescriptors:
		164	····def·__init__(self)·->·None:
		165	········self._lock·=·threading.Lock()
		166	········self._inodes:·dict[_DatabaseIdentity,·_InodeProbes]·=·{}
		167	········self._releases:·deque[_Probe]·=·deque()
		168	········self._leases·=·count()

		169	····def·adopt(self,·database:·str,·claimed:·list[_Probe])·->·_Probe·\|·None:··#·pragma:·win32·no·cover
		170	········#·Reuse·a·probe·no·live·connection·holds:·each·connect·would·otherwise·keep·another·descriptor·open·until·the
		171	········#·inode's·last·close,·and·two·live·connections·through·one·/dev/fd·name·make·macOS·SQLite·fail·to·open.
		172	········try:
		173	············stat_result:·Final·=·os.lstat(database)
		174	········except·OSError:
		175	············return·None
		176	········identity:·Final·=·stat_result.st_dev,·stat_result.st_ino
		177	········with·self._lock:
		178	············if·not·stat.S_ISREG(stat_result.st_mode)·or·not·(probes·:=·self._inodes.get(identity))·or·not·probes.idle:
		179	················return·None
		180	············claimed.append(adopted·:=·_Probe(identity,·probes.idle.pop(),·next(self._leases)))
		181	············probes.leases.add(adopted.lease)
		182	········return·adopted

		183	····def·retain(self,·fd:·int,·claimed:·list[_Probe])·->·_Probe:··#·pragma:·win32·no·cover
		184	········stat_result:·Final·=·os.fstat(fd)
		185	········identity:·Final·=·stat_result.st_dev,·stat_result.st_ino
		186	········token:·Final·=·_register_owned_descriptor(fd,·identity)
		187	········with·self._lock:
		188	············(probes·:=·self._inodes.setdefault(identity,·_InodeProbes())).descriptors.append((fd,·token))
		189	············claimed.append(retained·:=·_Probe(identity,·fd,·next(self._leases)))
		190	············probes.leases.add(retained.lease)
		191	········return·retained

Max diff block lines reached; 36019/44199 bytes (81.49%) of diff not shown.


Offset 2, 23 lines modified		Offset 2, 24 lines modified

2	import·os	2	import·os
3	import·stat	3	import·stat
4	import·sys	4	import·sys
5	import·time	5	import·time
6	from·contextlib·import·suppress	6	from·contextlib·import·suppress
7	from·errno·import·EACCES,·EEXIST,·EPERM	7	from·errno·import·EACCES,·EEXIST,·EPERM
		8	from·itertools·import·islice
8	from·pathlib·import·Path	9	from·pathlib·import·Path
9	from·typing·import·Final	10	from·typing·import·Final

10	from·._api·import·BaseFileLock,·_raise_grouped_errors	11	from·._api·import·BaseFileLock,·_raise_grouped_errors
11	from·._identity·import·host_name,·owner_is_stale,·process_start_token	12	from·._identity·import·host_name,·owner_is_current_process,·owner_is_stale,·process_start_token
12	from·._soft_protocol·import·STRICT_SOFT_SENTINEL_RECORD	13	from·._soft_protocol·import·STRICT_SOFT_SENTINEL_RECORD
13	from·._util·import·break_lock_file,·ensure_directory_exists,·raise_on_not_writable_file,·write_all	14	from·._util·import·break_lock_file,·ensure_directory_exists,·raise_on_not_writable_file,·write_all

14	_MALFORMED_LOCK_AGE_THRESHOLD:·Final[float]·=·2.0	15	MALFORMED_LOCK_AGE_THRESHOLD:·Final[float]·=·2.0
15	_MAX_LOCK_FILE_SIZE:·Final[int]·=·1024	16	_MAX_LOCK_FILE_SIZE:·Final[int]·=·1024
16	_UNLINK_MAX_RETRIES:·Final[int]·=·10	17	_UNLINK_MAX_RETRIES:·Final[int]·=·10
17	_MARKER_WITH_START_TOKEN_LINE_COUNT:·Final[int]·=·3	18	_MARKER_WITH_START_TOKEN_LINE_COUNT:·Final[int]·=·3


18	class·SoftFileLock(BaseFileLock):	19	class·SoftFileLock(BaseFileLock):
19	····"""	20	····"""
Offset 44, 15 lines modified		Offset 45, 25 lines modified

44	····#:·An·existence·lock·unlinks·its·marker·to·release,·so·it·cannot·promise·to·keep·the·pathname.	45	····#:·An·existence·lock·unlinks·its·marker·to·release,·so·it·cannot·promise·to·keep·the·pathname.
45	····_preserve_lock_file_supported:·bool·=·False	46	····_preserve_lock_file_supported:·bool·=·False

46	····#:·An·existence·lock·keeps·protocol·state·in·its·marker,·so·it·cannot·lend·the·descriptor·to·an·on_acquired·hook.	47	····#:·An·existence·lock·keeps·protocol·state·in·its·marker,·so·it·cannot·lend·the·descriptor·to·an·on_acquired·hook.
47	····_on_acquired_supported:·bool·=·False	48	····_on_acquired_supported:·bool·=·False

		49	····#:·The·marker's·(mtime,·inode)·when·this·instance·last·saw·it·change,·and·when·that·was·on·its·monotonic·clock.
		50	····_marker_seen:·tuple[tuple[float,·int],·float]·\|·None·=·None

		51	····#:·The·identity·of·a·marker·a·Windows·release·relinquished·but·has·not·unlinked·yet.
		52	····_marker_cleanup:·tuple[int,·int]·\|·None·=·None

		53	····#:·The·descriptor·of·that·marker·while·its·close·has·not·run·yet,·as·a·list·so·one·C·call·can·take·it.
		54	····_marker_fds:·list[int]

48	····def·_acquire(self)·->·None:	55	····def·_acquire(self)·->·None:
		56	········self._finish_marker_cleanup()
49	········raise_on_not_writable_file(self.lock_file)	57	········raise_on_not_writable_file(self.lock_file)
50	········ensure_directory_exists(self.lock_file)	58	········ensure_directory_exists(self.lock_file)
51	········#·O_CREAT·\|·O_EXCL·makes·the·create·fail·with·EEXIST·when·the·file·already·exists,·so·a·successful·open	59	········#·O_CREAT·\|·O_EXCL·makes·the·create·fail·with·EEXIST·when·the·file·already·exists,·so·a·successful·open
52	········#·means·this·process·now·holds·the·lock.	60	········#·means·this·process·now·holds·the·lock.
53	········flags·=·os.O_WRONLY·\|·os.O_CREAT·\|·os.O_EXCL·\|·os.O_TRUNC	61	········flags·=·os.O_WRONLY·\|·os.O_CREAT·\|·os.O_EXCL·\|·os.O_TRUNC
54	········if·(o_nofollow·:=·getattr(os,·"O_NOFOLLOW",·None))·is·not·None:··#·pragma:·needs·o-nofollow	62	········if·(o_nofollow·:=·getattr(os,·"O_NOFOLLOW",·None))·is·not·None:··#·pragma:·needs·o-nofollow
55	············flags·\|=·o_nofollow	63	············flags·\|=·o_nofollow
Offset 71, 42 lines modified		Offset 82, 70 lines modified
71	····def·_publish_held_marker(self,·fd:·int)·->·None:	82	····def·_publish_held_marker(self,·fd:·int)·->·None:
72	········#·Publish·held·state·only·once·the·record·is·fully·on·disk.·On·any·failure,·including·cancellation,·close·the	83	········#·Publish·held·state·only·once·the·record·is·fully·on·disk.·On·any·failure,·including·cancellation,·close·the
73	········#·descriptor·and·unlink·the·path·only·while·it·still·names·the·file·we·opened,·so·a·rollback·never·deletes·a	84	········#·descriptor·and·unlink·the·path·only·while·it·still·names·the·file·we·opened,·so·a·rollback·never·deletes·a
74	········#·successor's·marker·that·replaced·ours·at·the·same·path·after·our·lease·expired.	85	········#·successor's·marker·that·replaced·ours·at·the·same·path·after·our·lease·expired.
75	········identity:·tuple[int,·int]·\|·None·=·None	86	········identity:·tuple[int,·int]·\|·None·=·None
76	········try:	87	········try:
77	············identity·=·_file_identity(os.fstat(fd))	88	············identity·=·_file_identity(os.fstat(fd))
		89	············self._apply_explicit_mode(fd)
78	············self._write_lock_info(fd)	90	············self._write_lock_info(fd)
79	········except·BaseException:	91	········except·BaseException:
80	············self._mark_descriptor_released()	92	············self._mark_descriptor_released()
		93	············try:
81	············os.close(fd)	94	················os.close(fd)
		95	············finally:
		96	················self._unlink_held_marker(identity)
82	············with·suppress(OSError):
83	················if·identity·is·not·None·and·_file_identity(os.lstat(self.lock_file))·==·identity:
84	····················Path(self.lock_file).unlink()
85	············raise	97	············raise
86	········self._mark_descriptor_owned(fd,·identity)	98	········self._mark_descriptor_owned(fd,·identity)

		99	····def·_apply_explicit_mode(self,·fd:·int)·->·None:
		100	········#·os.open·filters·the·mode·through·the·umask,·so·an·explicit·mode·lands·as·given·only·through·fchmod,·the·way
		101	········#·UnixFileLock·applies·it.·Windows·maps·the·mode·to·a·read-only·bit·that·os.open·already·set.
		102	········if·self.has_explicit_mode·and·sys.platform·!=·"win32":··#·pragma:·win32·no·cover
		103	············with·suppress(PermissionError):
		104	················os.fchmod(fd,·self._context.mode)

87	····def·_try_break_stale_lock(self)·->·None:	105	····def·_try_break_stale_lock(self)·->·None:
88	········with·suppress(OSError,·ValueError):	106	········with·suppress(OSError,·ValueError):
89	············content,·mtime,·ino·=·_read_lock_file(self.lock_file)	107	············content,·mtime,·ino·=·_read_lock_file(self.lock_file)
90	············if·content·==·STRICT_SOFT_SENTINEL_RECORD:··#·pragma:·needs·hard-link	108	············if·content·==·STRICT_SOFT_SENTINEL_RECORD:··#·pragma:·needs·hard-link
91	················return	109	················return
92	············holder·=·_parse_lock_holder(content)	110	············holder·=·_parse_lock_holder(content)

93	············if·holder·is·None:	111	············if·holder·is·None:
94	················#·Unparsable:·wrong·line·count,·a·non-integer·PID·or·start·token,·empty,·oversized·or·not·UTF-8.	112	················#·Unparsable:·wrong·line·count,·a·non-integer·PID·or·start·token,·empty,·oversized·or·not·UTF-8.
95	················#·Self-heal·only·once·the·file·is·clearly·not·a·half-written·fresh·lock·(a·peer·between·O_EXCL·and	113	················#·Self-heal·only·once·the·file·is·clearly·not·a·half-written·fresh·lock·(a·peer·between·O_EXCL·and
96	················#·_write_lock_info),·so·the·brief·create-then-write·window·is·never·mistaken·for·a·stale·lock.	114	················#·_write_lock_info),·so·the·brief·create-then-write·window·is·never·mistaken·for·a·stale·lock.
97	················if·time~~.tim~~e~~()·-·~~mtime·>=·_MALFORMED_LOCK_AGE_THRESHOLD:	115	················if·self._marker_unchanged_for(mtime,·ino)·>=·MALFORMED_LOCK_AGE_THRESHOLD:
98	····················break_lock_file(self.lock_file,·mtime,·ino)	116	····················break_lock_file(self.lock_file,·mtime,·ino)
99	················return	117	················return

100	············if·owner_is_stale(*holder):	118	············if·owner_is_stale(*holder):
101	················break_lock_file(self.lock_file,·mtime,·ino)	119	················break_lock_file(self.lock_file,·mtime,·ino)

		120	····def·_marker_unchanged_for(self,·mtime:·float,·ino:·int)·->·float:
		121	········#·The·mtime·is·the·writer's·or·file·server's·clock,·so·against·time.time()·a·contender·whose·clock·runs·ahead
		122	········#·would·expire·a·fresh·marker.·Only·watch·it·for·change,·timed·on·this·process's·monotonic·clock.
		123	········now:·Final·=·time.monotonic()
		124	········if·(seen·:=·self._marker_seen)·is·None·or·seen[0]·!=·(mtime,·ino):
		125	············self._marker_seen·=·(mtime,·ino),·now
		126	············return·0.0
		127	········return·now·-·seen[1]

		128	····def·_unprobeable_holder(self)·->·str·\|·None:
		129	········#·This·host·cannot·prove·such·a·holder·dead,·so·whoever·decides·whether·it·is·gone·needs·its·name.
		130	········with·suppress(OSError,·ValueError):
		131	············if·(holder·:=·self._recorded_holder(_read_lock_file(self.lock_file)[0]))·and·holder[1]·!=·host_name():
		132	················return·f"pid·{holder[0]}·on·{holder[1]}"
		133	········return·None

		134	····@classmethod
		135	····def·_recorded_holder(cls,·content:·str·\|·None)·->·tuple[int,·str]·\|·None:
		136	········return·None·if·(holder·:=·_parse_lock_holder(content))·is·None·else·holder[:2]

102	····@staticmethod	137	····@staticmethod
103	····def·_write_lock_info(fd:·int)·->·None:	138	····def·_write_lock_info(fd:·int)·->·None:
104	········#·No·suppression:·a·write·failure·must·reach·the·acquisition·rollback·so·it·never·publishes·a·half-written	139	········#·No·suppression:·a·write·failure·must·reach·the·acquisition·rollback·so·it·never·publishes·a·half-written
105	········#·marker·as·held·state.·The·optional·third·line·is·this·process's·start·token,·absent·when·the·platform	140	········#·marker·as·held·state.·The·optional·third·line·is·this·process's·start·token,·absent·when·the·platform
106	········#·exposes·no·proven·start·time,·in·which·case·a·reader·falls·back·to·PID-only·liveness.	141	········#·exposes·no·proven·start·time,·in·which·case·a·reader·falls·back·to·PID-only·liveness.
107	········info·=·f"{os.getpid()}\n{host_name()}\n"	142	········info·=·f"{os.getpid()}\n{host_name()}\n"
108	········if·(token·:=·process_start_token(os.getpid()))·is·not·None:	143	········if·(token·:=·process_start_token(os.getpid()))·is·not·None:
Offset 128, 83 lines modified		Offset 167, 144 lines modified
128	········return·None	167	········return·None

Max diff block lines reached; 11916/18419 bytes (64.69%) of diff not shown.


Offset 1, 32 lines modified		Offset 1, 36 lines modified
1	from·__future__·import·annotations	1	from·__future__·import·annotations

2	import·contextlib	2	import·contextlib
3	import·errno	3	import·errno
		4	import·functools
4	import·os	5	import·os
5	import·secrets	6	import·secrets
6	import·stat	7	import·stat
7	import·sys	8	import·sys
8	import·tempfile	9	import·tempfile
9	import·time	10	import·time
10	from·dataclasses·import·dataclass	11	from·dataclasses·import·dataclass
11	from·errno·import·EACCES,·EEXIST,·ENOENT,·ENOSYS,·EPERM,·ESTALE,·EXDEV	12	from·errno·import·EACCES,·EEXIST,·ENOENT,·ENOSYS,·EPERM,·ESTALE,·EXDEV
12	from·pathlib·import·Path	13	from·pathlib·import·Path
13	from·typing·import·TYPE_CHECKING,·Final,·Literal,·cast	14	from·typing·import·TYPE_CHECKING,·Final,·Literal,·cast

14	from·._api·import·BaseFileLock,·_canonical,·_raise_cleanup_errors	15	from·._api·import·BaseFileLock,·ThreadLocalFileContext,·_canonical,·_raise_cleanup_errors
15	from·._error·import·SoftFileLockProtocolError	16	from·._error·import·SoftFileLockProtocolError
16	from·._identity·import·host_name,·process_start_token	17	from·._identity·import·host_name,·owner_is_stale,·process_start_token
		18	from·._marker·import·parse_marker
		19	from·._soft·import·MALFORMED_LOCK_AGE_THRESHOLD,·_parse_lock_holder
17	from·._soft_protocol·import·STRICT_SOFT_SENTINEL_RECORD	20	from·._soft_protocol·import·STRICT_SOFT_SENTINEL_RECORD
18	from·._util·import·ensure_directory_exists,·write_all	21	from·._util·import·ensure_directory_exists,·write_all

19	if·TYPE_CHECKING:	22	if·TYPE_CHECKING:
20	····from·collections.abc·import·Iterator	23	····from·collections.abc·import·Callable,·Iterator

21	StrictSoftFileClaimState·=·Literal["intent",·"held"]	24	StrictSoftFileClaimState·=·Literal["intent",·"held"]
		25	_OccupantState·=·Literal["sentinel",·"held",·"exited",·"damaged",·"unparsable"]

22	_CLAIM_STATES:·Final[frozenset[str]]·=·frozenset({"intent",·"held"})	26	_CLAIM_STATES:·Final[frozenset[str]]·=·frozenset({"intent",·"held"})
23	_COORDINATION_SUFFIX:·Final[str]·=·".filelock"	27	_COORDINATION_SUFFIX:·Final[str]·=·".filelock"
24	_CLAIM_DIRECTORY_NAME:·Final[str]·=·"claims"	28	_CLAIM_DIRECTORY_NAME:·Final[str]·=·"claims"
25	_CLAIM_MAGIC:·Final[str]·=·"filelock-strict-v1"	29	_CLAIM_MAGIC:·Final[str]·=·"filelock-strict-v1"
26	_CLAIM_RECORD_LIMIT:·Final[int]·=·1024	30	_CLAIM_RECORD_LIMIT:·Final[int]·=·1024
27	_CLAIM_NAME_PART_COUNT:·Final[int]·=·3	31	_CLAIM_NAME_PART_COUNT:·Final[int]·=·3
Offset 35, 14 lines modified		Offset 39, 17 lines modified
35	_PRIVATE_RECORD_SUFFIX:·Final[str]·=·".tmp"	39	_PRIVATE_RECORD_SUFFIX:·Final[str]·=·".tmp"
36	_PRIVATE_RECORD_RANDOM_HEX_LENGTH:·Final[int]·=·32	40	_PRIVATE_RECORD_RANDOM_HEX_LENGTH:·Final[int]·=·32
37	_PRIVATE_RECORD_GRACE:·Final[float]·=·2.0	41	_PRIVATE_RECORD_GRACE:·Final[float]·=·2.0
38	_UNLINK_MAX_RETRIES:·Final[int]·=·10	42	_UNLINK_MAX_RETRIES:·Final[int]·=·10
39	#:·How·long·a·scan·waits·out·a·claim·held·in·Windows'·delete-pending·state·before·treating·it·as·unreadable.	43	#:·How·long·a·scan·waits·out·a·claim·held·in·Windows'·delete-pending·state·before·treating·it·as·unreadable.
40	_CLAIM_READ_GRACE:·Final[float]·=·0.5	44	_CLAIM_READ_GRACE:·Final[float]·=·0.5
41	_CLAIM_READ_RETRY:·Final[float]·=·0.002	45	_CLAIM_READ_RETRY:·Final[float]·=·0.002
		46	#:·Rides·out·a·peer·replacing·the·lock·path·mid-inspection;·a·foreign·node·or·unreadable·record·outlasting·it·is·damage.
		47	_SENTINEL_READ_GRACE:·Final[float]·=·0.5
		48	_NODE_DESCRIPTIONS:·Final[dict[int,·str]]·=·{stat.S_IFDIR:·"a·directory",·stat.S_IFLNK:·"a·symlink"}
42	#:·Windows·opens·descriptors·in·text·mode·by·default,·which·rewrites·newlines·and·truncates·a·record·at·a·control·byte.	49	#:·Windows·opens·descriptors·in·text·mode·by·default,·which·rewrites·newlines·and·truncates·a·record·at·a·control·byte.
43	#:·The·claim·and·sentinel·records·are·exact·binary,·so·every·record·descriptor·must·be·binary;·POSIX·ignores·the·flag.	50	#:·The·claim·and·sentinel·records·are·exact·binary,·so·every·record·descriptor·must·be·binary;·POSIX·ignores·the·flag.
44	_O_BINARY:·Final[int]·=·getattr(os,·"O_BINARY",·0)	51	_O_BINARY:·Final[int]·=·getattr(os,·"O_BINARY",·0)
45	_LEGACY_SENTINEL:·Final[bytes]·=·STRICT_SOFT_SENTINEL_RECORD.encode()	52	_LEGACY_SENTINEL:·Final[bytes]·=·STRICT_SOFT_SENTINEL_RECORD.encode()
46	_WINDOWS_HARD_LINK_UNSUPPORTED:·Final[frozenset[int]]·=·frozenset({1,·17,·50})	53	_WINDOWS_HARD_LINK_UNSUPPORTED:·Final[frozenset[int]]·=·frozenset({1,·17,·50})

47	#·Termux/Android·CPython·ships·without·os.link·(bionic·long·had·only·linkat),·so·the·strict·backend's·whole·hard-link	54	#·Termux/Android·CPython·ships·without·os.link·(bionic·long·had·only·linkat),·so·the·strict·backend's·whole·hard-link
Offset 97, 135 lines modified		Offset 104, 184 lines modified

97	····_preserve_lock_file_supported:·bool·=·True	104	····_preserve_lock_file_supported:·bool·=·True
98	····_on_acquired_supported:·bool·=·False	105	····_on_acquired_supported:·bool·=·False
99	····#:·Age·cannot·clear·a·strict·claim:·expiring·one·on·a·clock·is·the·overlap·the·fail-closed·contract·exists·to·rule	106	····#:·Age·cannot·clear·a·strict·claim:·expiring·one·on·a·clock·is·the·overlap·the·fail-closed·contract·exists·to·rule
100	····#:·out,·so·only·force_break()·removes·it.	107	····#:·out,·so·only·force_break()·removes·it.
101	····_lifetime_supported:·bool·=·False	108	····_lifetime_supported:·bool·=·False
102	····_lifetime_unsupported_reason:·str·=·"a·strict·claim·is·never·broken·by·age,·only·by·force_break()"	109	····_lifetime_unsupported_reason:·str·=·"a·strict·claim·is·never·broken·by·age,·only·by·force_break()"
103	····#:·The·claim·doorway·publishes·an·intent·and·a·held·record·per·owner,·so·a·shared·instance·must·serialize·them.
104	····_serialize_transitions:·bool·=·True
105	····#:·Contending·processes·each·publish·and·rescan·several·files,·so·~~back~~·their·retries~~·of~~f·~~acr~~o~~ss·a~~·~~jittered~~·~~windo~~w	110	····#:·Contending·processes·each·publish·and·rescan·several·files,·so·jitter·their·retries.·Seconds.·Only·a
106	····#:·~~rather·~~than·let·them·c~~oll~~ide·on·e~~very~~·~~pol~~l.·~~Seco~~nds;·keeps·a·waiter·~~responsiv~~e·once~~·it·wins~~.	111	····#:·poll_interval·below·this·cap·jitters;·the·default·equals·it·and·keeps·a·fixed·cadence.
107	····_poll_backoff_cap:·float·=·0.05	112	····_poll_backoff_cap:·float·=·0.05
		113	····_occupant_seen:·tuple[tuple[float,·int,·int],·float]·\|·None·=·None

108	····def·_acquire(self)·->·None:	114	····def·_acquire(self)·->·None:
		115	········#·Finish·a·doorway·whose·claim·cleanup·failed·before·publishing,·so·this·owner·never·contends·with·leftovers.
		116	········self._discard_pending_doorways(exited_only=True)
109	········#·Resolve·once·per·acquisition,·not·per·poll:·a·waiter·on·a·relative·path·must·keep·publishing·into·the	117	········#·Resolve·once·per·acquisition,·not·per·poll:·a·waiter·on·a·relative·path·must·keep·publishing·into·the
110	········#·directory·it·started·waiting·in·even·when·another·thread·changes·the·working·directory·mid-wait.	118	········#·directory·it·started·waiting·in·even·when·another·thread·changes·the·working·directory·mid-wait.
111	········if·(claim_root·:=·self._context.claim_root)·is·None:	119	········if·(claim_root·:=·self._context.claim_root)·is·None:
112	············claim_root·=·self._context.claim_root·=·_canonical(self.lock_file)	120	············claim_root·=·self._context.claim_root·=·_canonical(self.lock_file)
113	········lock_path·=·Path(claim_root)	121	········lock_path·=·Path(claim_root)
114	········coordination_directory·=·Path(f"{lock_path}{_COORDINATION_SUFFIX}")	122	········coordination_directory·=·Path(f"{lock_path}{_COORDINATION_SUFFIX}")
115	········claim_directory·=·coordination_directory·/·_CLAIM_DIRECTORY_NAME	123	········claim_directory·=·coordination_directory·/·_CLAIM_DIRECTORY_NAME
116	········ensure_directory_exists(os.fspath(lock_path))	124	········ensure_directory_exists(os.fspath(lock_path))
117	········_ensure_protocol_directory(self.lock_file,·coordination_directory)	125	········_ensure_protocol_directory(self.lock_file,·coordination_directory)
118	········_ensure_protocol_directory(self.lock_file,·claim_directory)	126	········_ensure_protocol_directory(self.lock_file,·claim_directory)
119	········if·(~~sentinel_fd·:=·_open_or_create_sentinel(self.lock_file,·lock_path,·self._open_mode()))·is·None:~~	127	········if·(
		128	············sentinel_fd·:=·_open_or_create_sentinel(
		129	················self.lock_file,·lock_path,·self._open_mode(),·self._occupant_unchanged_for
		130	············)
		131	········)·is·None:
120	············return	132	············return
121	········try:	133	········try:
122	············sentinel_identity·=·_file_identity(os.fstat(sentinel_fd))	134	············sentinel_identity·=·_file_identity(os.fstat(sentinel_fd))
123	········except·BaseException·as·inspection_error:··#·preserve·inspection·and·descriptor·cleanup·errors	135	········except·BaseException·as·inspection_error:··#·preserve·inspection·and·descriptor·cleanup·errors
124	············try:	136	············try:
125	················os.close(sentinel_fd)	137	················os.close(sentinel_fd)
126	············except·BaseException·as·close_error:··#·ruff:ignore[blind-except]··#·preserve·inspection·and·descriptor·cleanup·errors	138	············except·BaseException·as·close_error:··#·ruff:ignore[blind-except]··#·preserve·inspection·and·descriptor·cleanup·errors
127	················_raise_cleanup_errors("strict·sentinel·inspection·cleanup·failed",·inspection_error,·close_error)	139	················_raise_cleanup_errors("strict·sentinel·inspection·cleanup·failed",·inspection_error,·close_error)
128	············raise	140	············raise
129	········self._mark_descriptor_pending(sentinel_fd,·sentinel_identity)	141	········self._mark_descriptor_pending(sentinel_fd,·sentinel_identity)
130	········try:	142	········try:
131	············self._attempt_doorway(claim_director~~y,·sentinel_fd,·sentinel_identit~~y)	143	············won·=·self._attempt_doorway(claim_directory)
132	········except·BaseException:	144	········except·BaseException:
		145	············self._discard_doorway()
133	············if·self._context.pending_lock_file_fd·==·sentinel_fd:
134	················self._discard_doorway(sentinel_fd,·sentinel_identity)
135	············raise	146	············raise
		147	········if·won:
		148	············self._mark_descriptor_owned(sentinel_fd,·sentinel_identity)
		149	········else:
		150	············self._discard_doorway()

136	····def·_attempt_doorway(self,·claim_directory:·Path,·sentinel_fd:·int,·sentinel_identity:·tuple[int,·int])·->·None:
137	········if·_read_existing_claims(self.lock_file,·claim_directory):
138	·····~~···~~·~~···~~s~~elf.~~_~~discard~~_doorway(se~~ntin~~e~~l_f~~d~~,·sentine~~l~~_identity)~~	151	····def·_discard_pending_doorways(self,·*,·exited_only:·bool)·->·None:
		152	········if·self._context.owner_claim_paths·and·not·self.is_locked:
		153	············self._discard_doorway()
		154	········if·not·isinstance(context·:=·self._context,·ThreadLocalFileContext):
139	············return	155	············return
		156	········#·Only·this·registry·reaches·an·exited·thread's·thread-local·doorway;·a·live·thread·finishes·its·own.
		157	········own:·Final·=·context.current
		158	········with·self._transition_lock:
		159	············for·pending,·thread·in·self._thread_pending.copy().values():
		160	················if·exited_only·and·thread.is_alive():
		161	····················continue
		162	················context.current·=·pending
		163	················try:
		164	····················self._discard_doorway()
		165	················finally:
		166	····················context.current·=·own
Max diff block lines reached; 27700/35573 bytes (77.87%) of diff not shown.


Offset 63, 78 lines modified		Offset 63, 85 lines modified

63	········We·leave·the·lock·file·in·place·after·release.·Unlinking·a·locked·file·on·Unix·splits	63	········We·leave·the·lock·file·in·place·after·release.·Unlinking·a·locked·file·on·Unix·splits
64	········waiters·across·inodes·and·breaks·mutual·exclusion·for·processes·that·coordinate·via·the	64	········waiters·across·inodes·and·breaks·mutual·exclusion·for·processes·that·coordinate·via·the
65	········same·path.	65	········same·path.
66	········"""	66	········"""

67	········def·_acquire(self)·->·None:	67	········def·_acquire(self)·->·None:
68	············missing_flock·=·self._acquire_native()	68	············if·(missing_flock·:=·self._acquire_native())·is·not·None:
69	············if·missing_flock·is·not·None:
70	················~~sel~~f.~~_swit~~ch_to_soft_lock(*missing_flock)	69	················fd,·exception,·created·=·missing_flock
		70	················self._switch_to_soft_lock(fd,·exception,·created=created)

71	········def·_acquire_native(self)·->·tuple[int,·OSError]·\|·None:	71	········def·_acquire_native(self)·->·tuple[int,·OSError,·bool]·\|·None:
72	············ensure_directory_exists(self.lock_file)	72	············ensure_directory_exists(self.lock_file)
		73	············if·(opened·:=·self._open_lock_file())·is·None:
73	············#·Open·without·O_TRUNC·and·defer·truncation·and·fchmod·until·after·flock·succeeds:·a·contender·that·loses
74	············#·the·lock·must·not·truncate·the·holder's·file·(erasing·caller·diagnostics)·or·change·its·mode.·The·winner
75	············#·truncates·and·normalizes·mode·once·it·owns·the·lock·(#591).
76	············open_flags·=·os.O_RDWR
77	············if·(o_nofollow·:=·getattr(os,·"O_NOFOLLOW",·None))·is·not·None:
78	················open_flags·\|=·o_nofollow
79	············open_flags·\|=·os.O_CREAT
80	············open_mode·=·self._open_mode()
81	············try:
82	················fd·=·os.open(self.lock_file,·open_flags,·open_mode)
83	············except·FileNotFoundError:
84	················#·On·FUSE/NFS,·os.open(O_CREAT)·is·not·atomic;·a·split·LOOKUP·+·CREATE·lets·a·concurrent·unlink()
85	················#·delete·the·file·between·them.·For·a·valid·path,·treat·ENOENT·as·transient·contention.·For·an
86	················#·invalid·path·(e.g.·empty·string),·re-raise·to·avoid·an·infinite·retry·loop.
87	················if·self.lock_file·and·Path(self.lock_file).parent.exists():
88	················~~····~~return·None	74	················return·None
		75	············fd,·created·=·opened
89	················raise
90	············except·PermissionError:
91	················#·Sticky-bit·dirs·(e.g.·/tmp):·O_CREAT·fails·if·the·file·is·owned·by·another·user·(#317).
92	················#·Fall·back·to·opening·the·existing·file·without·O_CREAT.
93	················if·not·Path(self.lock_file).exists():
94	····················raise
95	················try:
96	····················fd·=·os.open(self.lock_file,·open_flags·&·~os.O_CREAT,·open_mode)
97	················except·FileNotFoundError:
98	····················return·None
99	············self._mark_descriptor_pending(fd)	76	············self._mark_descriptor_pending(fd)
100	············try:	77	············try:
101	················locked·=·_lock_fd_nonblocking(fd)	78	················locked·=·_lock_fd_nonblocking(fd)
102	············except·OSError·as·exception:	79	············except·OSError·as·exception:
103	················if·exception.errno·!=·ENOSYS:	80	················if·exception.errno·!=·ENOSYS:
104	····················self._mark_descriptor_released()	81	····················self._mark_descriptor_released()
105	····················os.close(fd)	82	····················os.close(fd)
106	····················raise··#·contention·returns·False·from·_lock_fd_nonblocking,·so·any·raise·here·is·a·real·failure	83	····················raise··#·contention·returns·False·from·_lock_fd_nonblocking,·so·any·raise·here·is·a·real·failure
107	················return·fd,·exception	84	················return·fd,·exception,·created
108	············if·locked:	85	············if·locked:
109	················self._finalize_locked_fd(fd)	86	················self._finalize_locked_fd(fd)
110	············else:	87	············else:
111	················self._mark_descriptor_released()	88	················self._mark_descriptor_released()
112	················os.close(fd)··#·contention;·let·the·retry·loop·try·again	89	················os.close(fd)··#·contention;·let·the·retry·loop·try·again
113	············return·None	90	············return·None

		91	········def·_open_lock_file(self)·->·tuple[int,·bool]·\|·None:
		92	············#·No·O_TRUNC:·a·contender·that·loses·the·flock·must·not·truncate·the·holder's·file·or·change·its·mode;·the
		93	············#·winner·does·both·once·it·owns·the·lock·(#591).·O_EXCL·tells·the·ENOSYS·fallback·whether·this·attempt·made
		94	············#·the·inode,·so·it·removes·only·its·own·placeholder,·never·a·peer's·marker.
		95	············open_flags·=·os.O_RDWR
		96	············if·(o_nofollow·:=·getattr(os,·"O_NOFOLLOW",·None))·is·not·None:
		97	················open_flags·\|=·o_nofollow
		98	············open_mode·=·self._open_mode()
		99	············try:
		100	················return·os.open(self.lock_file,·open_flags·\|·os.O_CREAT·\|·os.O_EXCL,·open_mode),·True
		101	············except·FileExistsError:
		102	················pass
		103	············except·FileNotFoundError:
		104	················#·On·FUSE/NFS·a·split·LOOKUP·+·CREATE·lets·a·concurrent·unlink()·race·the·create,·so·ENOENT·is·transient
		105	················#·contention.·An·empty·or·separator-terminated·path·(Path()·strips·the·separator)·fails·this·way·on
		106	················#·every·attempt·on·macOS,·so·re-raise·rather·than·retry·forever.
		107	················if·self.lock_file·and·not·self.lock_file.endswith(os.sep)·and·Path(self.lock_file).parent.exists():
		108	····················return·None
		109	················raise
		110	············except·PermissionError:
		111	················#·Sticky-bit·dirs·(e.g.·/tmp):·O_CREAT·fails·if·another·user·owns·the·file·(#317).
		112	················if·not·Path(self.lock_file).exists():
		113	····················raise
		114	············try:
		115	················return·os.open(self.lock_file,·open_flags,·open_mode),·False
		116	············except·FileNotFoundError:
		117	················return·None··#·unlinked·since·the·create·attempt;·let·the·retry·loop·start·over

114	········def·_switch_to_soft_lock(self,·fd:·int,·missing_flock:·OSError)·->·None:	118	········def·_switch_to_soft_lock(self,·fd:·int,·missing_flock:·OSError,·*,·created:·bool)·->·None:
115	············#·The·filesystem·does·not·implement·flock.·Capture·the·opened·file's·identity·before·closing·so·the·cleanup	119	············#·The·filesystem·does·not·implement·flock.·Capture·the·opened·file's·identity·before·closing·so·the·cleanup
116	············#·below·removes·only·this·attempt's·placeholder,·not·a·peer's·replacement.	120	············#·below·removes·only·this·attempt's·placeholder,·not·a·peer's·replacement.
117	············identity:·tuple[int,·int]·\|·None·=·None	121	············identity:·tuple[int,·int]·\|·None·=·None
118	············with·suppress(OSError):	122	············with·suppress(OSError):
119	················identity·=·(fstat·:=·os.fstat(fd)).st_dev,·fstat.st_ino	123	················identity·=·(fstat·:=·os.fstat(fd)).st_dev,·fstat.st_ino
120	············self._mark_descriptor_released()	124	············self._mark_descriptor_released()
121	············os.close(fd)	125	············os.close(fd)
122	············if·not·self._fallback_to_soft·or·self._preserve_lock_file·or·self._on_acquired·is·not·None:	126	············if·not·self._fallback_to_soft·or·self._preserve_lock_file·or·self._on_acquired·is·not·None:
123	················#·Fail·closed:·the·caller·opted·out·of·existence-lock·semantics·(#603),·asked·to·preserve·the·pathname	127	················#·Fail·closed:·the·caller·opted·out·of·existence-lock·semantics·(#603),·asked·to·preserve·the·pathname
124	················#·(#605),·or·set·an·on_acquired·hook·(#607),·none·of·which·a·soft·lock·can·honor.	128	················#·(#605),·or·set·an·on_acquired·hook·(#607),·none·of·which·a·soft·lock·can·honor.
125	················raise·missing_flock	129	················raise·missing_flock
		130	············#·A·file·this·attempt·did·not·create·may·be·a·peer's·live·marker;·the·soft·lock·ages·out·a·stale·empty·one.
		131	············if·created:
126	············with·suppress(OSError):	132	················with·suppress(OSError):
127	················current·=·os.lstat(self.lock_file)	133	····················current·=·os.lstat(self.lock_file)
128	················if·identity·==·(current.st_dev,·current.st_ino):	134	····················if·identity·==·(current.st_dev,·current.st_ino):
129	····················Path(self.lock_file).unlink()	135	························Path(self.lock_file).unlink()
130	············self._fallback_to_soft_lock()	136	············self._fallback_to_soft_lock()
131	············self._acquire()	137	············self._acquire()

132	········def·_finalize_locked_fd(self,·fd:·int)·->·None:	138	········def·_finalize_locked_fd(self,·fd:·int)·->·None:
133	············#·Runs·with·the·flock·held.·Truncate·and·normalize·mode·under·a·guard·so·any·failure·closes·fd·rather·than	139	············#·Runs·with·the·flock·held.·Truncate·and·normalize·mode·under·a·guard·so·any·failure·closes·fd·rather·than
134	············#·leaking·it·and·its·lock.·A·concurrent·_release()·may·have·unlinked·the·inode·between·our·open()·and	140	············#·leaking·it·and·its·lock.·A·concurrent·_release()·may·have·unlinked·the·inode·between·our·open()·and
135	············#·flock()·(st_nlink·0),·leaving·a·useless·dead-inode·lock;·drop·it·and·let·the·retry·loop·start·fresh.	141	············#·flock()·(st_nlink·0),·leaving·a·useless·dead-inode·lock;·drop·it·and·let·the·retry·loop·start·fresh.


Offset 1, 25 lines modified		Offset 1, 26 lines modified
1	from·__future__·import·annotations	1	from·__future__·import·annotations

2	import·os	2	import·os
3	import·secrets	3	import·secrets
4	import·stat	4	import·stat
5	import·sys	5	import·sys
		6	from·contextlib·import·suppress
6	from·errno·import·EACCES,·EIO,·EISDIR	7	from·errno·import·EACCES,·EIO,·EISDIR
7	from·pathlib·import·Path	8	from·pathlib·import·Path
8	from·typing·import·Final	9	from·typing·import·Final


9	def·write_all(fd:·int,·data:·bytes)·->·None:	10	def·write_all(fd:·int,·data:·bytes)·->·None:
10	····"""	11	····"""
11	····Write·the·whole·buffer·to·fd,·looping·over·the·short·writes·~~``os.wri~~te``·is·~~allow~~ed·to·make.	12	····Write·the·whole·buffer·to·fd,·looping·over·the·short·writes·POSIX·lets·``os.write``·make.

12	····A·marker·written·with·a·bare·``os.write``·can·land·partially:·a·peer·reading·it·mid-write·parses·a·truncated·record
13	····as·malformed·or·as·a·foreign·holder.·Looping·until·the·buffer·drains·keeps·the·record·atomic·in·the·process·and
14	····~~kern~~el·~~view.·N~~o·~~``fsy~~n~~c``:~~·filelock·ne~~eds~~·a·~~comple~~te·re~~cor~~d,·~~not·c~~rash~~-du~~rable~~·storage.~~	13	····A·caller·that·stopped·after·one·short·write·would·leave·a·truncated·marker·behind.·A·peer·that·reads·between·two
		14	····writes·sees·a·prefix·of·the·record;·each·caller·has·to·tolerate·that.·Lock·records·need·not·survive·a·power·loss,·so
		15	····we·skip·``fsync``.

15	····:param·fd:·file·descriptor·open·for·writing.	16	····:param·fd:·file·descriptor·open·for·writing.
16	····:param·data:·bytes·to·write·in·full.	17	····:param·data:·bytes·to·write·in·full.

17	····:raises·OSError:·if·a·write·reports·zero·progress·before·the·record·is·complete.	18	····:raises·OSError:·if·a·write·reports·zero·progress·before·the·record·is·complete.

18	····"""	19	····"""
Offset 49, 15 lines modified		Offset 50, 23 lines modified
49	········file_stat·=·os.lstat(filename)	50	········file_stat·=·os.lstat(filename)
50	····except·OSError:	51	····except·OSError:
51	········return··#·does·not·exist,·or·an·error·the·caller·cannot·act·on	52	········return··#·does·not·exist,·or·an·error·the·caller·cannot·act·on

52	····#·No·mtime·guard:·the·old·`if·st_mtime·!=·0`·skip·covered·NFS/Linux·quirks·where·os.lstat·returned·an·all-zero	53	····#·No·mtime·guard:·the·old·`if·st_mtime·!=·0`·skip·covered·NFS/Linux·quirks·where·os.lstat·returned·an·all-zero
53	····#·struct,·which·it·no·longer·does.·Skipping·on·mtime·0·let·a·read-only·file·or·a·directory·at·the·lock·path·pass	54	····#·struct,·which·it·no·longer·does.·Skipping·on·mtime·0·let·a·read-only·file·or·a·directory·at·the·lock·path·pass
54	····#·as·missing,·so·acquire()·blocked·forever·on·an·open·that·cannot·succeed.	55	····#·as·missing,·so·acquire()·blocked·forever·on·an·open·that·cannot·succeed.
		56	····#·Match·open()·credentials·where·supported;·group·permissions·and·ACLs·can·grant·access·without·S_IWUSR.
55	····if·not·(file_stat.st_mode·&·stat.S_IWUSR):	57	····if·not·(file_stat.st_mode·&·stat.S_IWUSR)·and·not·os.access(
		58	········filename,·os.W_OK,·effective_ids=os.access·in·os.supports_effective_ids
		59	····):
		60	········try:
		61	············os.lstat(filename)
		62	········except·FileNotFoundError:
		63	············#·A·holder·may·unlink·its·marker·between·lstat()·and·access();·let·the·caller·attempt·creation.
		64	············return
56	········raise·PermissionError(EACCES,·"Permission·denied",·filename)	65	········raise·PermissionError(EACCES,·"Permission·denied",·filename)

57	····if·stat.S_ISDIR(file_stat.st_mode):	66	····if·stat.S_ISDIR(file_stat.st_mode):
58	········if·sys.platform·==·"win32":··#·pragma:·win32·cover	67	········if·sys.platform·==·"win32":··#·pragma:·win32·cover
59	············raise·PermissionError(EACCES,·"Permission·denied",·filename)	68	············raise·PermissionError(EACCES,·"Permission·denied",·filename)
60	········raise·IsADirectoryError(EISDIR,·"Is·a·directory",·filename)··#·pragma:·win32·no·cover	69	········raise·IsADirectoryError(EISDIR,·"Is·a·directory",·filename)··#·pragma:·win32·no·cover

Offset 70, 61 lines modified		Offset 79, 66 lines modified

70	····"""	79	····"""
71	····Path(filename).parent.mkdir(parents=True,·exist_ok=True)	80	····Path(filename).parent.mkdir(parents=True,·exist_ok=True)


72	def·break_lock_file(lock_file:·str,·mtime_before:·float,·ino_before:·int)·->·None:	81	def·break_lock_file(lock_file:·str,·mtime_before:·float,·ino_before:·int)·->·None:
73	····"""	82	····"""
74	····Atom~~ically~~·bre~~ak·a·sta~~le·lock·file~~·judge~~d·stale·at·modification·time·mtime_before.	83	····Remove·the·lock·file·a·caller·found·stale·with·modification·time·mtime_before·and·inode·ino_before.

75	····Rename·the·file·to·a·process-private·name·before·unlinking·it,·so·two·processes·breaking·the·same·lock·cannot
76	····delete·each·other's·work:·only·one·rename·of·a·given·inode·wins,·the·loser·gets·``OSError``.·After·the·rename,
77	····re-check·the·file.·A·newer·modification·time,·or·a·different·inode·than·ino_before,·means·a·peer·recreated·the
78	····lock·between·the·stale·decision·and·the·rename,·so·we·grabbed·a·live·file·and·abort,·leaving·the·renamed·file·in
79	····place.·A·rollback·rename·is·itself·racy,·the·same·trade-off·as·the·soft·read/write·marker·break.·The·inode·check
80	····matters·because·filesystems·with·coarse·modification-time·granularity·(NFS,·FAT)·can·give·a·same-second·recreation
81	····the·old·mtime,·so·mtime·alone·would·miss·it·and·unlink·a·live·lock;·the·inode·is·the·reliable·identity,·mirroring
82	····the·token·re-check·in·the·soft·read/write·marker·break.·``lstat``·avoids·following·a·hostile·symlink·swapped·in
83	····after·the·decisi~~on.~~	84	····Right·before·renaming·we·``lstat``·the·lock·again·and·leave·it·alone·if·a·peer·recreated·it·since·the·caller·judged
		85	····it·stale,·as·Mercurial·re-reads·a·lock·under·its·break·lock.·We·rename·before·unlinking·so·that,·of·several
		86	····processes·racing·to·break·the·same·lock,·one·takes·the·file·and·the·rest·get·``OSError``.·A·newer·modification·time
		87	····or·another·inode·on·the·renamed·file·means·a·peer·recreated·the·lock·between·that·``lstat``·and·the·rename,·so·we
		88	····hard-link·it·back·and·drop·the·break·name.·``link``·never·replaces·a·name,·so·a·marker·a·third·process·created·after
		89	····our·rename·wins·and·the·live·one·stays·under·the·break·name.·In·the·two·syscalls·between·rename·and·link·a·third
		90	····process·can·acquire·beside·the·live·holder,·a·soft·lock·by·creating·its·marker·or·a·StrictSoftFileLock·by
		91	····publishing·its·sentinel·at·the·empty·path.·Without·``os.link``,·or·on·a·filesystem·that·refuses·hard·links,·the·live
		92	····marker·stays·under·the·break·name.·We·compare·inodes·as·well·as·modification·times·because·NFS·and·FAT·store
		93	····coarse·modification·times,·and·a·peer·that·recreates·the·lock·within·that·granularity·leaves·the·old·mtime·on·it.
		94	····We·call·``lstat``·to·avoid·following·a·symlink·a·peer·swaps·in·after·our·stale·check,·and·put·back·only·a·regular
		95	····file·because·``link``·would·follow·a·symlink·to·its·target.

84	····~~The·break·na~~me·ca~~rri~~es·a·random·token·so·it·is·~~unguess~~able·and·u~~nique~~·p~~er·att~~e~~mpt.·Wi~~thout·it·two·breakers·in·the	96	····We·add·a·random·token·to·the·break·name·so·other·processes·cannot·guess·it·and·two·breakers·in·one·process·do·not
85	····s~~ame·process·s~~hare·``<lock>.break.<pid>``,·and·a·second·break·can·rename·a·recreated·live·lock·onto·th~~at·p~~at~~h·in~~	97	····share·``<lock>.break.<pid>``.·With·a·shared·name,·the·second·breaker·could·rename·a·recreated·live·lock·onto·that
		98	····path·between·our·``lstat``·and·``unlink``,·and·our·``unlink``·would·delete·it.
86	····the·window·between·the·re-verify·``lstat``·above·and·the·``unlink``·below,·deleting·a·live·lock·the·inode·check
87	····just·approved.·A·private·name·keeps·anyone·else·from·targeting·our·break·path,·matching·the·soft·read/write·marker
88	····break.

89	····:param·lock_file:·path·to·the·lock·file·to·break.	99	····:param·lock_file:·path·to·the·lock·file·to·break.
90	····:param·mtime_before:·modification·time·~~obs~~er~~ved~~·when·t~~he·lock~~·~~was~~·ju~~dged~~·stale.	100	····:param·mtime_before:·modification·time·the·caller·saw·when·it·judged·the·lock·stale.
91	····:param·ino_before:·inode·number·~~obs~~er~~ved~~·when·t~~he·lock~~·~~was~~·ju~~dged~~·stale.	101	····:param·ino_before:·inode·number·the·caller·saw·when·it·judged·the·lock·stale.

92	····:raises·OSError:·if·the·rename·~~fails·(~~e~~.g.~~·the·~~fil~~e·vani~~shed·~~or·~~is·not~~·~~own~~ed·i~~n·a·st~~i~~cky·di~~r~~ect~~o~~ry).~~	102	····:raises·OSError:·if·the·rename,·the·re-check·or·the·restore·fails,·for·example·because·the·file·vanished·or·another
		103	········user·owns·it·in·a·sticky·directory.

93	····"""	104	····"""
		105	····if·(current·:=·os.lstat(lock_file)).st_mtime·>·mtime_before·or·current.st_ino·!=·ino_before:
94	····break_path·=·f"{lock_file}.break.{os.getpid()}.{secrets.token_hex(16)}"
95	····Path(lock_file).rename(break_path)
96	····try:
97	········st_after·=·os.lstat(break_path)
98	····except·OSError:
99	········return	106	········return
		107	····break_path:·Final[str]·=·f"{lock_file}.break.{os.getpid()}.{secrets.token_hex(16)}"
		108	····Path(lock_file).rename(break_path)
100	····if·st_after.st_mtime·>·mtime_before·or·st_after.st_ino·!=·ino_before:	109	····if·(st_after·:=·os.lstat(break_path)).st_mtime·<=·mtime_before·and·st_after.st_ino·==·ino_before:
101	········return
102	····Path(break_path).unlink()	110	········Path(break_path).unlink()
		111	····elif·stat.S_ISREG(st_after.st_mode)·and·_HAS_LINK:··#·pragma:·needs·hard-link
		112	········with·suppress(FileExistsError):
		113	············os.link(break_path,·lock_file)
		114	············Path(break_path).unlink()


103	def·touch(name:·str,·*,·fd:·int~~·\|·None·=·None~~)·->·None:	115	def·touch(name:·str,·*,·fd:·int)·->·None:
104	····#·Prefer·the·already-open,·already-verified·fd·so·a·peer·that·swaps·a·symlink·or·a·different·file·in·at·the	116	····#·Prefer·the·already-open,·already-verified·fd·so·a·peer·that·swaps·a·symlink·or·a·different·file·in·at·the
105	····#·path·after·our·O_NOFOLLOW·read·cannot·redirect·the·touch:·utime·then·targets·the·inode·behind·the·fd.	117	····#·path·after·our·O_NOFOLLOW·read·cannot·redirect·the·touch:·utime·then·targets·the·inode·behind·the·fd.
106	····#·Where·the·platform·cannot·utime·an·fd,·fall·back·to·a·path-based·touch·that·still·refuses·to·follow·a	118	····#·Where·the·platform·cannot·utime·an·fd,·fall·back·to·a·path-based·touch·that·still·refuses·to·follow·a
107	····#·symlink·where·supported,·matching·the·O_NOFOLLOW·reads·used·elsewhere·here.	119	····#·symlink·where·supported,·matching·the·O_NOFOLLOW·reads·used·elsewhere·here.
108	····if·~~fd·is·not·None·and·~~_SUPPORTS_UTIME_FD:··#·pragma:·needs·utime-fd	120	····if·_SUPPORTS_UTIME_FD:··#·pragma:·needs·utime-fd
109	········os.utime(fd,·None)	121	········os.utime(fd,·None)
110	········return	122	········return
111	····os.utime(name,·None,·follow_symlinks=not·_SUPPORTS_UTIME_NOFOLLOW)	123	····os.utime(name,·None,·follow_symlinks=not·_SUPPORTS_UTIME_NOFOLLOW)··#·pragma:·lacks·utime-fd


Max diff block lines reached; 307/9104 bytes (3.37%) of diff not shown.


Offset 1, 11 lines modified		Offset 1, 12 lines modified
1	from·__future__·import·annotations	1	from·__future__·import·annotations

2	import·os	2	import·os
3	import·sys	3	import·sys
		4	import·time
4	from·contextlib·import·suppress	5	from·contextlib·import·suppress
5	from·pathlib·import·Path	6	from·pathlib·import·Path
6	from·typing·import·Final,·cast	7	from·typing·import·Final,·cast

7	from·._api·import·BaseFileLock	8	from·._api·import·BaseFileLock
8	from·._util·import·ensure_directory_exists,·raise_on_not_writable_file	9	from·._util·import·ensure_directory_exists,·raise_on_not_writable_file

Offset 37, 22 lines modified		Offset 38, 27 lines modified
37	····#·LockFileEx·locks·a·byte·range·at·an·offset·carried·in·OVERLAPPED,·independent·of·the·descriptor's·file·position.	38	····#·LockFileEx·locks·a·byte·range·at·an·offset·carried·in·OVERLAPPED,·independent·of·the·descriptor's·file·position.
38	····#·msvcrt.locking·starts·at·the·current·position·instead,·so·a·metadata·write·between·lock·and·unlock·could·shift	39	····#·msvcrt.locking·starts·at·the·current·position·instead,·so·a·metadata·write·between·lock·and·unlock·could·shift
39	····#·the·byte·a·later·unlock·targets;·the·explicit·offset·removes·that·hazard·for·both·the·path·lock·and·#608's	40	····#·the·byte·a·later·unlock·targets;·the·explicit·offset·removes·that·hazard·for·both·the·path·lock·and·#608's
40	····#·descriptor·lock.	41	····#·descriptor·lock.
41	····_LOCKFILE_FAIL_IMMEDIATELY:·Final[int]·=·0x00000001	42	····_LOCKFILE_FAIL_IMMEDIATELY:·Final[int]·=·0x00000001
42	····_LOCKFILE_EXCLUSIVE_LOCK:·Final[int]·=·0x00000002	43	····_LOCKFILE_EXCLUSIVE_LOCK:·Final[int]·=·0x00000002
43	····_ERROR_LOCK_VIOLATION:·Final[int]·=·33··#·another·handle·holds·the·byte·range	44	····_ERROR_LOCK_VIOLATION:·Final[int]·=·33··#·another·handle·holds·the·byte·range
		45	····_ERROR_NOT_LOCKED:·Final[int]·=·158··#·the·byte·range·is·not·locked

44	····#·NtCreateFile·returns·the·raw·NTSTATUS·as·its·value,·where·CreateFileW·collapses·several·of·these·into·one	46	····#·NtCreateFile·returns·the·raw·NTSTATUS·as·its·value,·where·CreateFileW·collapses·several·of·these·into·one
45	····#·ERROR_ACCESS_DENIED.·Telling·them·apart·is·the·point·(#604):·a·name·pending·deletion·or·a·share·conflict·is	47	····#·ERROR_ACCESS_DENIED.·Telling·them·apart·is·the·point·(#604):·a·name·pending·deletion·or·a·share·conflict·is
46	····#·transient·and·worth·a·retry,·a·real·access·denial·is·not.	48	····#·transient·and·worth·a·retry,·a·real·access·denial·is·not.
47	····_STATUS_SUCCESS:·Final[int]·=·0x00000000	49	····_STATUS_SUCCESS:·Final[int]·=·0x00000000
48	····_STATUS_ACCESS_DENIED:·Final[int]·=·0xC0000022	50	····_STATUS_ACCESS_DENIED:·Final[int]·=·0xC0000022
49	····_STATUS_SHARING_VIOLATION:·Final[int]·=·0xC0000043	51	····_STATUS_SHARING_VIOLATION:·Final[int]·=·0xC0000043
50	····_STATUS_DELETE_PENDING:·Final[int]·=·0xC0000056	52	····_STATUS_DELETE_PENDING:·Final[int]·=·0xC0000056
		53	····#:·How·long·an·open·waits·out·a·STATUS_ACCESS_DENIED·before·treating·it·as·a·real·denial:·NTFS·answers·it·for·a
		54	····#:·moment·while·a·peer's·unlink·tears·the·name·down,·so·a·bounded·wait·keeps·a·real·denial·failing·fast·(#604).
		55	····_ACCESS_DENIED_GRACE:·Final[float]·=·0.5
		56	····_ACCESS_DENIED_RETRY:·Final[float]·=·0.002

51	····_ntdll:·Final[ctypes.WinDLL]·=·ctypes.WinDLL("ntdll")	57	····_ntdll:·Final[ctypes.WinDLL]·=·ctypes.WinDLL("ntdll")
52	····_kernel32:·Final[ctypes.WinDLL]·=·ctypes.WinDLL("kernel32",·use_last_error=True)	58	····_kernel32:·Final[ctypes.WinDLL]·=·ctypes.WinDLL("kernel32",·use_last_error=True)

53	····class·_UNICODE_STRING(ctypes.Structure):··#·ruff:ignore[invalid-class-name]··#·mirrors·the·Win32·struct·name	59	····class·_UNICODE_STRING(ctypes.Structure):··#·ruff:ignore[invalid-class-name]··#·mirrors·the·Win32·struct·name
54	········_fields_·=·(	60	········_fields_·=·(
55	············("Length",·wintypes.USHORT),··#·byte·length,·not·character·count	61	············("Length",·wintypes.USHORT),··#·byte·length,·not·character·count
Offset 159, 17 lines modified		Offset 165, 19 lines modified
159	········if·err·==·_ERROR_LOCK_VIOLATION:	165	········if·err·==·_ERROR_LOCK_VIOLATION:
160	············return·False	166	············return·False
161	········#·A·non-contention·LockFileEx·failure·is·not·reproducible·in-process.	167	········#·A·non-contention·LockFileEx·failure·is·not·reproducible·in-process.
162	········raise·ctypes.WinError(err)··#·pragma:·no·cover	168	········raise·ctypes.WinError(err)··#·pragma:·no·cover

163	····def·_unlock_fd(fd:·int)·->·None:	169	····def·_unlock_fd(fd:·int)·->·None:
164	········overlapped·=·_OVERLAPPED()··#·the·same·offset·0·and·one-byte·length·the·lock·used	170	········overlapped·=·_OVERLAPPED()··#·the·same·offset·0·and·one-byte·length·the·lock·used
165	········#·~~Unlocki~~ng·the·exact·r~~ang~~e·we·hold·does·not·fail.	171	········if·(··#·pragma:·no·cover··#·only·an·interrupted·earlier·release·leaves·our·own·range·unlocked
166	········if·not·_kernel32.UnlockFileEx(msvcrt.get_osfhandle(fd),·0,·1,·0,·ctypes.byref(overlapped))~~:··#·pragma:·no·cover~~	172	············not·_kernel32.UnlockFileEx(msvcrt.get_osfhandle(fd),·0,·1,·0,·ctypes.byref(overlapped))
		173	············and·(err·:=·ctypes.get_last_error())·!=·_ERROR_NOT_LOCKED
		174	········):
167	············raise·ctypes.WinError(~~ctypes.get_last_~~error())	175	············raise·ctypes.WinError(err)

168	····class·WindowsFileLock(BaseFileLock):	176	····class·WindowsFileLock(BaseFileLock):
169	········"""	177	········"""
170	········Uses·``LockFileEx``·to·hard·lock·a·byte·range·of·the·lock·file·on·Windows·systems.	178	········Uses·``LockFileEx``·to·hard·lock·a·byte·range·of·the·lock·file·on·Windows·systems.

171	········Lock·file·cleanup:·Windows·attempts·to·delete·the·lock·file·after·release,·but·deletion·is	179	········Lock·file·cleanup:·Windows·attempts·to·delete·the·lock·file·after·release,·but·deletion·is
172	········not·guaranteed·in·multi-threaded·scenarios·where·another·thread·holds·an·open·handle.·The·lock	180	········not·guaranteed·in·multi-threaded·scenarios·where·another·thread·holds·an·open·handle.·The·lock
Offset 231, 20 lines modified		Offset 239, 27 lines modified
231	········:param·mode:·the·permission·mode;·as·``os.open``·does·on·Windows,·a·cleared·owner-write·bit·creates·the·file	239	········:param·mode:·the·permission·mode;·as·``os.open``·does·on·Windows,·a·cleared·owner-write·bit·creates·the·file
232	············read-only.·The·attribute·only·takes·effect·when·the·file·is·created,·not·when·an·existing·one·is·opened.	240	············read-only.·The·attribute·only·takes·effect·when·the·file·is·created,·not·when·an·existing·one·is·opened.

233	········:returns:·a·file·descriptor·owning·the·opened·handle,·or·``None``·on·a·sharing·violation·or·a·delete-pending	241	········:returns:·a·file·descriptor·owning·the·opened·handle,·or·``None``·on·a·sharing·violation·or·a·delete-pending
234	············name·the·caller·should·treat·as·contention·and·retry.	242	············name·the·caller·should·treat·as·contention·and·retry.

235	········:raises·OSError:·if·the·path·resolves·to·a·reparse·point,·or·the·open·fails·for·any·other·reason,·raised·with	243	········:raises·OSError:·if·the·path·resolves·to·a·reparse·point,·or·the·open·fails·for·any·other·reason,·raised·with
236	············the·Win32·error·the·status·maps·to.	244	············the·Win32·error·the·status·maps·to.·An·access·denial·is·raised·only·once·it·outlasts·a·short·grace,·since
		245	············a·peer·unlinking·the·file·as·it·releases·can·make·the·open·answer·``STATUS_ACCESS_DENIED``·for·a·moment.

237	········"""	246	········"""
238	········#·Emit·the·audit·event·os.open·would,·so·consumers·watching·"open"·still·see·the·path-level·open·and·can·veto.	247	········#·Emit·the·audit·event·os.open·would,·so·consumers·watching·"open"·still·see·the·path-level·open·and·can·veto.
239	········sys.audit("open",·path,·None,·os.O_RDWR·\|·os.O_CREAT)	248	········sys.audit("open",·path,·None,·os.O_RDWR·\|·os.O_CREAT)
		249	········read_only·=·not·mode·&·_OWNER_WRITE
240	········handle,·status·=·_nt_open(path,·read_only=~~not·mo~~de~~·&·_OWN~~ER_W~~RITE~~)	250	········handle,·status·=·_nt_open(path,·read_only=read_only)
		251	········if·status·==·_STATUS_ACCESS_DENIED:
		252	············deadline·=·time.monotonic()·+·_ACCESS_DENIED_GRACE
		253	············while·status·==·_STATUS_ACCESS_DENIED·and·time.monotonic()·<·deadline:
		254	················time.sleep(_ACCESS_DENIED_RETRY)
		255	················handle,·status·=·_nt_open(path,·read_only=read_only)
241	········if·status·!=·_STATUS_SUCCESS:	256	········if·status·!=·_STATUS_SUCCESS:
242	············if·status·in·{_STATUS_SHARING_VIOLATION,·_STATUS_DELETE_PENDING}:	257	············if·status·in·{_STATUS_SHARING_VIOLATION,·_STATUS_DELETE_PENDING}:
243	················return·None	258	················return·None
244	············winerror·=·_ntdll.RtlNtStatusToDosError(status)	259	············winerror·=·_ntdll.RtlNtStatusToDosError(status)
245	············raise·OSError(None,·ctypes.FormatError(winerror).strip(),·path,·winerror)	260	············raise·OSError(None,·ctypes.FormatError(winerror).strip(),·path,·winerror)

246	········info·=·_BY_HANDLE_FILE_INFORMATION()	261	········info·=·_BY_HANDLE_FILE_INFORMATION()
Offset 316, 8 lines modified		Offset 331, 9 lines modified

316	········def·_release(self)·->·None:	331	········def·_release(self)·->·None:
317	············raise·NotImplementedError	332	············raise·NotImplementedError


318	__all__·=·[	333	__all__·=·[
319	····"WindowsFileLock",	334	····"WindowsFileLock",
		335	····"_open_non_reparse_fd",
320	]	336	]


Offset 1, 75 lines modified		Offset 1, 79 lines modified
1	"""An·asyncio-based·implementation·of·the·file·lock."""	1	"""An·asyncio-based·implementation·of·the·file·lock."""

2	from·__future__·import·annotations	2	from·__future__·import·annotations

3	import·asyncio	3	import·asyncio
4	import·contextlib	4	import·contextlib
		5	import·functools
5	import·logging	6	import·logging
6	import·os	7	import·os
		8	import·sys
7	import·time	9	import·time
		10	from·concurrent·import·futures
8	from·dataclasses·import·dataclass	11	from·dataclasses·import·dataclass,·fields
9	from·inspect·import·iscoroutinefunction	12	from·inspect·import·iscoroutinefunction
10	from·threading·import·local	13	from·threading·import·RLock
11	from·typing·import·TYPE_CHECKING,·Final,·NoReturn,·TypeVar,·cast	14	from·typing·import·TYPE_CHECKING,·Final,·NoReturn,·TypeVar,·cast

12	from·._api·import·(	15	from·._api·import·(
13	····_UNSET_FILE_MODE,	16	····_UNSET_FILE_MODE,
14	····BaseFileLock,	17	····BaseFileLock,
15	····CloseErrorPolicy,	18	····CloseErrorPolicy,
16	····ContextErrorPolicy,	19	····ContextErrorPolicy,
17	····FileLockContext,	20	····FileLockContext,
18	····FileLockMeta,	21	····FileLockMeta,
		22	····ThreadLocalFileContext,
19	····_append_exception_context,	23	····_append_exception_context,
20	····_canonical,	24	····_canonical,
		25	····_delegate_to_current,
21	····_ExtraValue,	26	····_ExtraValue,
22	····_fork_transition,	27	····_fork_transition,
23	····_grouped_errors,	28	····_grouped_errors,
24	····_raise_body_and_release,	29	····_raise_body_and_release,
25	····_raise_chained_errors,	30	····_raise_chained_errors,
26	····_raise_cleanup_errors,	31	····_raise_cleanup_errors,
27	····_raise_grouped_errors,	32	····_raise_grouped_errors,
28	····_register_fork_object,	33	····_register_fork_object,
		34	····_resolve_poll_interval,
		35	····_resolve_timeout,
29	)	36	)
30	from·._async·import·(	37	from·._async·import·(
31	····_AsyncTransitionGate,	38	····_AsyncTransitionGate,
32	····_AsyncTransitionUnavailableError,	39	····_AsyncTransitionUnavailableError,
33	····_BackendOutcome,	40	····_BackendOutcome,
34	····_capture_awaitable,	41	····_capture_awaitable,
35	····_capture_call,	42	····_capture_call,
36	····_drain_future,	43	····_drain_future,
37	····_future_result,	44	····_future_result,
		45	····_run_in_executor,
38	····_wait_until_done,	46	····_wait_until_done,
39	)	47	)
40	from·._error·import·Timeout	48	from·._error·import·Timeout
41	from·._lease·import·SoftFileLease	49	from·._lease·import·SoftFileLease
42	from·._soft·import·SoftFileLock	50	from·._soft·import·SoftFileLock
43	from·._strict·import·StrictSoftFileLock	51	from·._strict·import·StrictSoftFileLock
44	from·._unix·import·UnixFileLock	52	from·._unix·import·UnixFileLock
45	from·._windows·import·WindowsFileLock	53	from·._windows·import·WindowsFileLock

46	if·TYPE_CHECKING:	54	if·TYPE_CHECKING:
47	····import·sys
48	····from·collections.abc·import·Awaitable,·Callable,·Coroutine,·Hashable	55	····from·collections.abc·import·Awaitable,·Callable,·Coroutine,·Hashable,·Mapping
49	····from·concurrent·import·futures
50	····from·types·import·TracebackType	56	····from·types·import·TracebackType

51	····if·sys.version_info·>=·(3,·11):··#·pragma:·no·cover·(py311+)
52	····~~····~~from·typing·import·Self	57	····from·typing·import·Self
53	····else:··#·pragma:·no·cover·(<py311)
54	········from·typing_extensions·import·Self


55	_LOGGER:·Final[logging.Logger]·=·logging.getLogger("filelock")	58	_LOGGER:·Final[logging.Logger]·=·logging.getLogger("filelock")
56	_ASYNC_RELEASE_CANCELLATION_ERRORS:·Final[str]·=·"lock·release·cancellation·and·backend·release·both·failed"	59	_ASYNC_RELEASE_CANCELLATION_ERRORS:·Final[str]·=·"lock·release·cancellation·and·backend·release·both·failed"
57	_ASYNC_CONTEXT_RELEASE_ERRORS:·Final[str]·=·"context·body,·release·cancellation,·and·backend·release·failed"	60	_ASYNC_CONTEXT_RELEASE_ERRORS:·Final[str]·=·"context·body,·release·cancellation,·and·backend·release·failed"
58	_ASYNC_RELEASE_CANCELLATION_MARKER_ATTR:·Final[str]·=·"_filelock_async_release_cancellation"	61	_ASYNC_RELEASE_CANCELLATION_MARKER_ATTR:·Final[str]·=·"_filelock_async_release_cancellation"
59	_ASYNC_RELEASE_CANCELLATION_MARKER:·Final[list[None]]·=·[]	62	_ASYNC_RELEASE_CANCELLATION_MARKER:·Final[list[None]]·=·[]
		63	_FINALIZER_RELEASES:·Final[set[asyncio.Task[None]·\|·futures.Future[None]]]·=·set()

60	_AT·=·TypeVar("_AT",·bound="BaseAsyncFileLock")	64	_AT·=·TypeVar("_AT",·bound="BaseAsyncFileLock")
		65	_T·=·TypeVar("_T")


61	class·AsyncFileLockMeta(FileLockMeta):	66	class·AsyncFileLockMeta(FileLockMeta):
62	····def·__call__(··#·ruff:ignore[too-many-arguments]··#·forwards·the·public·constructor's·documented·parameters	67	····def·__call__(··#·ruff:ignore[too-many-arguments]··#·forwards·the·public·constructor's·documented·parameters
63	········cls:·type[_AT],··#·ruff:ignore[invalid-first-argument-name-for-method]··#·metaclass·__call__·receives·the·class·being·constructed	68	········cls:·type[_AT],··#·ruff:ignore[invalid-first-argument-name-for-method]··#·metaclass·__call__·receives·the·class·being·constructed
64	········lock_file:·str·\|·os.PathLike[str],	69	········lock_file:·str·\|·os.PathLike[str],
65	········timeout:·float·=·-1,	70	········timeout:·float·=·-1,
Offset 159, 20 lines modified		Offset 163, 20 lines modified
159	········:param·lock_file:·path·to·the·file	163	········:param·lock_file:·path·to·the·file
160	········:param·timeout:·default·timeout·when·acquiring·the·lock,·in·seconds.·It·will·be·used·as·fallback·value·in·the	164	········:param·timeout:·default·timeout·when·acquiring·the·lock,·in·seconds.·It·will·be·used·as·fallback·value·in·the
161	············acquire·method,·if·no·timeout·value·(``None``)·is·given.·If·you·want·to·disable·the·timeout,·set·it·to·a	165	············acquire·method,·if·no·timeout·value·(``None``)·is·given.·If·you·want·to·disable·the·timeout,·set·it·to·a
162	············negative·value.·A·timeout·of·0·means·that·there·is·exactly·one·attempt·to·acquire·the·file·lock.	166	············negative·value.·A·timeout·of·0·means·that·there·is·exactly·one·attempt·to·acquire·the·file·lock.
163	········:param·mode:·file·permissions·for·the·lockfile.·When·not·specified,·the·OS·controls·permissions·via·umask·and	167	········:param·mode:·file·permissions·for·the·lockfile.·When·not·specified,·the·OS·controls·permissions·via·umask·and
164	············default·ACLs,·preserving·POSIX·default·ACL·inheritance·in·shared·directories.	168	············default·ACLs,·preserving·POSIX·default·ACL·inheritance·in·shared·directories.
165	········:param·thread_local:·Whether·this·object's·internal·context·should·be·thread·local·or·not.·If·this·is·set·to	169	········:param·thread_local:·Whether·this·object's·internal·context·should·be·thread·local·or·not.·If·this·is·set·to
166	············``False``·then·the·lock·will·be·reentrant·across·threads.·When·``True``~~·(the·default)~~,·**all·fields·of·the	170	············``False``·(the·default)·then·the·lock·will·be·reentrant·across·threads.·When·``True``,·**all·fields·of·the
167	············lock's·internal·context·are·per-thread**,·including·the·configuration·values·``poll_interval``,·``timeout``,	171	············lock's·internal·context·are·per-thread**,·including·the·configuration·values·``poll_interval``,·``timeout``,
168	············``blocking``,·``mode``,·and·``lifetime``.·Setting·one·of·these·properties·from·one·thread·does·not·change	172	············``blocking``,·``mode``,·and·``lifetime``.·Setting·one·of·these·properties·from·one·thread·does·not·change
169	············the·value·seen·by·another·thread;·threads·that·did·not·perform·the·write·continue·to·see·the·value·supplied	173	············the·value·seen·by·another·thread;·threads·that·did·not·perform·the·write·continue·to·see·the·value·supplied
170	············at·construction·time.·If·you·need·configuration·values·to·be·visible·across·threads,·construct·the·lock
171	············with·``thr~~ead_l~~ocal=False``.	174	············at·construction·time.·``mode``·has·no·setter,·so·construction·is·the·only·place·it·is·ever·set.·If·you·need
		175	············configuration·values·to·be·visible·across·threads,·construct·the·lock·with·``thread_local=False``.
172	········:param·blocking:·whether·the·lock·should·be·blocking·or·not	176	········:param·blocking:·whether·the·lock·should·be·blocking·or·not
173	········:param·is_singleton:·If·this·is·set·to·``True``·then·only·one·instance·of·this·class·will·be·created·per·lock	177	········:param·is_singleton:·If·this·is·set·to·``True``·then·only·one·instance·of·this·class·will·be·created·per·lock
174	············file.·This·is·useful·if·you·want·to·use·the·lock·object·for·reentrant·locking·without·needing·to·pass·the	178	············file.·This·is·useful·if·you·want·to·use·the·lock·object·for·reentrant·locking·without·needing·to·pass·the
175	············same·object·around.	179	············same·object·around.
176	········:param·poll_interval:·default·interval·for·polling·the·lock·file,·in·seconds.·It·will·be·used·as·fallback·value	180	········:param·poll_interval:·default·interval·for·polling·the·lock·file,·in·seconds.·It·will·be·used·as·fallback·value
177	············in·the·acquire·method,·if·no·poll_interval·value·(``None``)·is·given.	181	············in·the·acquire·method,·if·no·poll_interval·value·(``None``)·is·given.
178	········:param·lifetime:·for·:class:`AsyncSoftFileLock`,·the·age·in·seconds·after·which·a·waiting·process·may·delete	182	········:param·lifetime:·for·:class:`AsyncSoftFileLock`,·the·age·in·seconds·after·which·a·waiting·process·may·delete
Offset 193, 42 lines modified		Offset 197, 60 lines modified
193	············identity·(Windows·skips·its·unlink,·Unix·refuses·the·``ENOSYS``·soft·fallback).·:class:`AsyncSoftFileLock`	197	············identity·(Windows·skips·its·unlink,·Unix·refuses·the·``ENOSYS``·soft·fallback).·:class:`AsyncSoftFileLock`
194	············rejects·``True``.	198	············rejects·``True``.
195	········:param·on_acquired:·for·native·locks·(:class:`AsyncFileLock`),·a·callable·invoked·with·the·borrowed·lock	199	········:param·on_acquired:·for·native·locks·(:class:`AsyncFileLock`),·a·callable·invoked·with·the·borrowed·lock
196	············descriptor·once·per·physical·acquisition,·after·the·lock·is·held·but·before	200	············descriptor·once·per·physical·acquisition,·after·the·lock·is·held·but·before
197	············:meth:`~BaseAsyncFileLock.acquire`·returns.·With·``run_in_executor=True``·(the·default)·it·runs·in·the	201	············:meth:`~BaseAsyncFileLock.acquire`·returns.·With·``run_in_executor=True``·(the·default)·it·runs·in·the
198	············backend·executor.·It·must·not·close·or·unlock·the·descriptor;·a·raise·rolls·the·acquisition·back.	202	············backend·executor.·It·must·not·close·or·unlock·the·descriptor;·a·raise·rolls·the·acquisition·back.
199	············:class:`AsyncSoftFileLock`·rejects·it.	203	············:class:`AsyncSoftFileLock`·rejects·it.
200	········:param·loop:·The·event·loop·~~to·us~~e~~.·If~~·not·s~~pecifi~~e~~d,·~~the~~·runni~~ng·event·loop·~~will~~·be·used.	204	········:param·loop:·the·event·loop·a·garbage-collected·lock·schedules·its·release·on·when·no·loop·runs·in·the
		205	············collecting·thread.·:meth:`~BaseAsyncFileLock.acquire`·and·:meth:`~BaseAsyncFileLock.release`·always·run
		206	············on·the·loop·that·awaits·them.
201	········:param·run_in_executor:·If·this·is·set·to·``True``·then·the·lock·will·be·acquired·in·an·executor.	207	········:param·run_in_executor:·If·this·is·set·to·``True``·then·the·lock·will·be·acquired·in·an·executor.
202	········:param·executor:·The·executor·to·use.·If·not·specified,·the·default·executor·will·be·used.	208	········:param·executor:·The·executor·to·use.·If·not·specified,·the·default·executor·will·be·used.

203	········"""	209	········"""
204	········self._creator_pid·=·os.getpid()	210	········self._creator_pid·=·os.getpid()
205	········self._is_thread_local·=·thread_local	211	········self._is_thread_local·=·thread_local
206	········self._is_singleton·=·is_singleton	212	········self._is_singleton·=·is_singleton
207	········self._context_error_policy·=·context_error_policy··#·already·validated·by·the·metaclass	213	········self._context_error_policy·=·context_error_policy··#·already·validated·by·the·metaclass
208	········self._close_error_policy·=·close_error_policy··#·already·validated·by·the·metaclass	214	········self._close_error_policy·=·close_error_policy··#·already·validated·by·the·metaclass
Max diff block lines reached; 17305/24240 bytes (71.39%) of diff not shown.


Offset 14, 11 lines modified		Offset 14, 11 lines modified
14	version:·str	14	version:·str
15	__version__:·str	15	__version__:·str
16	__version_tuple__:·tuple[int·\|·str,·...]	16	__version_tuple__:·tuple[int·\|·str,·...]
17	version_tuple:·tuple[int·\|·str,·...]	17	version_tuple:·tuple[int·\|·str,·...]
18	commit_id:·str·\|·None	18	commit_id:·str·\|·None
19	__commit_id__:·str·\|·None	19	__commit_id__:·str·\|·None

20	__version__·=·version·=·'3.32.0'	20	__version__·=·version·=·'4.1.1'
21	__version_tuple__·=·version_tuple·=·(3,·32,·0)	21	__version_tuple__·=·version_tuple·=·(4,·1,·1)

22	__commit_id__·=·commit_id·=·None	22	__commit_id__·=·commit_id·=·None


Offset 1, 8 lines modified		Offset 1, 8 lines modified
1	"""Cross-process·and·cross-host·reader/writer·lock·on·~~:class:`~file~~lock.SoftFi~~leLock`·primitive~~s."""	1	"""Cross-process·and·cross-host·reader/writer·lock·over·a·generation·log·of·immutable·snapshots."""

2	from·__future__·import·annotations	2	from·__future__·import·annotations

3	from·._async·import·AsyncAcquireSoftReadWriteReturnProxy,·AsyncSoftReadWriteLock	3	from·._async·import·AsyncAcquireSoftReadWriteReturnProxy,·AsyncSoftReadWriteLock
4	from·._sync·import·SoftReadWriteLock	4	from·._sync·import·SoftReadWriteLock

5	__all__·=·[	5	__all__·=·[


Offset 2, 42 lines modified		Offset 2, 60 lines modified

2	from·__future__·import·annotations	2	from·__future__·import·annotations

3	import·asyncio	3	import·asyncio
4	import·functools	4	import·functools
5	import·os	5	import·os
6	from·contextlib·import·asynccontextmanager	6	from·contextlib·import·asynccontextmanager
7	from·typing·import·TYPE_CHECKING,·ParamSpec,·TypeVar	7	from·typing·import·TYPE_CHECKING,·Literal,·ParamSpec,·TypeVar

		8	from·filelock._async·import·(
		9	····_BackendOutcome,
		10	····_capture_call,
		11	····_drain_future,
		12	····_future_result,
		13	····_raise_cancelled_error,
		14	····_task_owners_for,
		15	····_wait_until_done,
		16	)

8	from·._sync·import·SoftReadWriteLock	17	from·._sync·import·SoftReadWriteLock

9	if·TYPE_CHECKING:	18	if·TYPE_CHECKING:
10	····from·collections.abc·import·AsyncGenerator,·Callable	19	····from·collections.abc·import·AsyncGenerator,·Callable
11	····from·concurrent·import·futures	20	····from·concurrent·import·futures
12	····from·types·import·TracebackType	21	····from·types·import·TracebackType

		22	····from·filelock._api·import·AcquireReturnProxy
		23	····from·filelock._lease·import·LeaseCompromise

13	_P·=·ParamSpec("_P")	24	_P·=·ParamSpec("_P")
14	_R·=·TypeVar("_R")	25	_R·=·TypeVar("_R")


15	class·AsyncSoftReadWriteLock:	26	class·AsyncSoftReadWriteLock:
16	····"""	27	····"""
17	····Async·wrapper·around·:class:`SoftReadWriteLock`·for·``asyncio``·applications.	28	····Async·wrapper·around·:class:`SoftReadWriteLock`·for·``asyncio``·applications.

18	····The·sync·class's·blocking·filesystem·operations·run·on·a·thread·pool·via·``loop.run_in_executor()``.·~~The~~	29	····The·sync·class's·blocking·filesystem·operations·run·on·a·thread·pool·via·``loop.run_in_executor()``.·Each
19	····underlying·:class:`SoftReadWriteLock`·handles·reentrancy,·upgrade/downgrade·rules,·fork·handling,·heartbeat·and
20	····TTL·stale·~~det~~e~~cti~~on,·and·singleton·~~behav~~i~~or.~~	30	····``asyncio``·task·owns·its·own·hold.·Tasks·share·a·read·lock,·and·a·task·asking·for·the·write·lock·waits·until·the
		31	····other·holders·release,·with·waiting·writers·ahead·of·new·readers.·Upgrading·or·downgrading·a·held·lock·raises
		32	····:class:`RuntimeError`.·The·underlying·:class:`SoftReadWriteLock`·handles·forks,·the·heartbeat,·and·stale·eviction.
		33	····Singleton·wrappers·share·one·sync·lock·and·its·task·holds.

21	····:param·lock_file:·path·to·the·lock·file;·sidecar·st~~ate/wr~~i~~te/~~re~~ade~~rs·live·next·to·it	34	····:param·lock_file:·path·to·the·lock·file;·the·protocol·directory·lives·next·to·it·as·``<lock_file>.rw``
22	····:param·timeout:·maximum·wait·time·in·seconds;·``-1``·means·block·indefinitely	35	····:param·timeout:·maximum·wait·time·in·seconds;·``-1``·means·block·indefinitely
23	····:param·blocking:·if·``False``,·raise·:class:`~filelock.Timeout`·immediately·on·contention	36	····:param·blocking:·if·``False``,·raise·:class:`~filelock.Timeout`·immediately·on·contention
24	····:param·is_singleton:·if·``True``,·reuse·existing·:class:`SoftReadWriteLock`·instances·per·resolved·path	37	····:param·is_singleton:·if·``True``,·reuse·existing·:class:`SoftReadWriteLock`·instances·per·resolved·path
25	····:param·heartbeat_interval:·seconds·between·heartbeat·refreshes;·default·30·s	38	····:param·heartbeat_interval:·seconds·between·heartbeat·refreshes;·default·30·s
26	····:param·stale_threshold:·seconds·of·~~mtim~~e~~·inactivit~~y·before·~~a·marker~~·~~is·stal~~e;·def~~aults~~·to·``3·*·~~hear~~t~~bea~~t_~~int~~e~~rva~~l``	39	····:param·stale_threshold:·seconds·a·holder·record·may·stay·unchanged·before·a·contender·evicts·it;·defaults·to
		40	········``3·*·heartbeat_interval``
27	····:param·poll_interval:·seconds·between·acquire·retries·under·contention;·default·0.25·s	41	····:param·poll_interval:·seconds·between·acquire·retries·under·contention;·default·0.25·s
		42	····:param·on_compromise:·called·from·the·heartbeat·thread·with·a·:class:`~filelock.LeaseCompromise`·when·the·hold·is
		43	········lost
28	····:param·loop:·event·loop·for·``run_in_executor``;·``None``·uses·the·running·loop	44	····:param·loop:·event·loop·for·``run_in_executor``;·``None``·uses·the·running·loop
29	····:param·executor:·executor·for·``run_in_executor``;·``None``·uses·the·default·executor	45	····:param·executor:·executor·for·``run_in_executor``;·``None``·uses·the·default·executor

30	····..·versionadded::·3.27.0	46	····..·versionadded::·3.27.0

31	····"""	47	····"""

Offset 47, 27 lines modified		Offset 65, 30 lines modified
47	········timeout:·float·=·-1,	65	········timeout:·float·=·-1,
48	········*,	66	········*,
49	········blocking:·bool·=·True,	67	········blocking:·bool·=·True,
50	········is_singleton:·bool·=·True,	68	········is_singleton:·bool·=·True,
51	········heartbeat_interval:·float·=·30.0,	69	········heartbeat_interval:·float·=·30.0,
52	········stale_threshold:·float·\|·None·=·None,	70	········stale_threshold:·float·\|·None·=·None,
53	········poll_interval:·float·=·0.25,	71	········poll_interval:·float·=·0.25,
		72	········on_compromise:·Callable[[LeaseCompromise],·None]·\|·None·=·None,
54	········loop:·asyncio.AbstractEventLoop·\|·None·=·None,	73	········loop:·asyncio.AbstractEventLoop·\|·None·=·None,
55	········executor:·futures.Executor·\|·None·=·None,	74	········executor:·futures.Executor·\|·None·=·None,
56	····)·->·None:	75	····)·->·None:
57	········self._creator_pid·=·os.getpid()	76	········self._creator_pid·=·os.getpid()
58	········self._lock·=·SoftReadWriteLock(	77	········self._lock·=·SoftReadWriteLock(
59	············lock_file,	78	············lock_file,
60	············timeout,	79	············timeout,
61	············blocking=blocking,	80	············blocking=blocking,
62	············is_singleton=is_singleton,	81	············is_singleton=is_singleton,
63	············heartbeat_interval=heartbeat_interval,	82	············heartbeat_interval=heartbeat_interval,
64	············stale_threshold=stale_threshold,	83	············stale_threshold=stale_threshold,
65	············poll_interval=poll_interval,	84	············poll_interval=poll_interval,
		85	············on_compromise=on_compromise,
66	········)	86	········)
		87	········self._owners·=·_task_owners_for(self._lock)
67	········self._loop·=·loop	88	········self._loop·=·loop
68	········self._executor·=·executor	89	········self._executor·=·executor

69	····@property	90	····@property
70	····def·lock_file(self)·->·str:	91	····def·lock_file(self)·->·str:
71	········"""The·path·to·the·lock·file·passed·to·the·constructor."""	92	········"""The·path·to·the·lock·file·passed·to·the·constructor."""
72	········return·self._lock.lock_file	93	········return·self._lock.lock_file
Offset 79, 14 lines modified		Offset 100, 24 lines modified

79	····@property	100	····@property
80	····def·blocking(self)·->·bool:	101	····def·blocking(self)·->·bool:
81	········"""Whether·``acquire_*``·defaults·to·blocking;·``False``·makes·contention·raise·immediately."""	102	········"""Whether·``acquire_*``·defaults·to·blocking;·``False``·makes·contention·raise·immediately."""
82	········return·self._lock.blocking	103	········return·self._lock.blocking

83	····@property	104	····@property
		105	····def·generation(self)·->·int·\|·None:
		106	········"""The·generation·the·current·hold·was·granted·at,·a·fencing·token;·``None``·when·no·lock·is·held."""
		107	········return·self._lock.generation

		108	····@property
		109	····def·compromise(self)·->·LeaseCompromise·\|·None:
		110	········"""How·the·current·hold·was·lost,·or·``None``·while·it·stands."""
		111	········return·self._lock.compromise

		112	····@property
84	····def·loop(self)·->·asyncio.AbstractEventLoop·\|·None:	113	····def·loop(self)·->·asyncio.AbstractEventLoop·\|·None:
85	········"""The·event·loop·used·for·``run_in_executor``,·or·``None``·for·the·running·loop."""	114	········"""The·event·loop·used·for·``run_in_executor``,·or·``None``·for·the·running·loop."""
86	········return·self._loop	115	········return·self._loop

87	····@property	116	····@property
88	····def·executor(self)·->·futures.Executor·\|·None:	117	····def·executor(self)·->·futures.Executor·\|·None:
89	········"""The·executor·used·for·``run_in_executor``,·or·``None``·for·the·default·executor."""	118	········"""The·executor·used·for·``run_in_executor``,·or·``None``·for·the·default·executor."""
Offset 96, 16 lines modified		Offset 127, 18 lines modified
96	····async·def·read_lock(self,·timeout:·float·\|·None·=·None,·*,·blocking:·bool·\|·None·=·None)·->·AsyncGenerator[None]:	127	····async·def·read_lock(self,·timeout:·float·\|·None·=·None,·*,·blocking:·bool·\|·None·=·None)·->·AsyncGenerator[None]:
97	········"""	128	········"""
98	········Async·context·manager·that·acquires·and·releases·a·shared·read·lock.	129	········Async·context·manager·that·acquires·and·releases·a·shared·read·lock.

99	········:param·timeout:·maximum·wait·time·in·seconds,·or·``None``·to·use·the·instance·default	130	········:param·timeout:·maximum·wait·time·in·seconds,·or·``None``·to·use·the·instance·default
100	········:param·blocking:·if·``False``,·raise·:class:`~filelock.Timeout`·immediately;·``None``·uses·the·instance·default	131	········:param·blocking:·if·``False``,·raise·:class:`~filelock.Timeout`·immediately;·``None``·uses·the·instance·default

101	········:raises·RuntimeError:·if·a~~·write·~~l~~ock~~·is·already·held·on·th~~is·~~i~~nstan~~ce	132	········:raises·RuntimeError:·if·the·calling·task·already·holds·the·write·lock
102	········:raises·Timeout:·if·the·lock·cannot·be·acquired·within·timeout·seconds	133	········:raises·Timeout:·if·the·lock·cannot·be·acquired·within·timeout·seconds
Max diff block lines reached; 9263/15244 bytes (60.76%) of diff not shown.


Offset 1, 88 lines modified		Offset 1, 82 lines modified
1	"""Cross-process·and·cross-host·reader/writer·lock·~~built~~·on~~·:class:`S~~oftFi~~leLock`·primitive~~s."""	1	"""Cross-process·and·cross-host·reader/writer·lock·over·a·generation·log·of·immutable·snapshots."""

2	from·__future__·import·annotations	2	from·__future__·import·annotations

3	import·atexit	3	import·atexit
4	import·hmac
5	import·os	4	import·os
6	import·re
7	import·secrets
8	import·socket
9	import·stat
10	import·sys
11	import·threading	5	import·threading
12	import·time	6	import·time
13	import·uuid
14	from·contextlib·import·c~~losing,·c~~ontextmanager,·suppress	7	from·contextlib·import·contextmanager,·suppress
15	from·dataclasses·import·dataclass	8	from·dataclasses·import·dataclass
16	from·path~~lib~~·import·Path	9	from·math·import·isfinite
17	from·typing·import·TYPE_CHECKING,·Final~~,·Literal~~	10	from·typing·import·TYPE_CHECKING,·Final
18	from·weakref·import·WeakValueDictionary	11	from·weakref·import·WeakValueDictionary

19	from·filelock._api·import·(	12	from·filelock._api·import·(
20	····AcquireReturnProxy,	13	····AcquireReturnProxy,
		14	····_canonical,
		15	····_check_timeout_max,
21	····_ensure_current_process,	16	····_ensure_current_process,
22	····_fork_transition,
23	····_raise_grouped_errors,
24	····_register_fork_class,	17	····_register_fork_class,
25	····_register_fork_object,	18	····_register_fork_object,
26	····_register_owned_descriptor,
27	····_unre~~gist~~er_o~~wne~~d_~~descr~~iptor,	19	····_resolve_read_write_timeout,
		20	····_seconds,
		21	····_timeout_behavior,
28	)	22	)
29	from·filelock._error·import·Timeout	23	from·filelock._error·import·Timeout
30	from·filelock._soft·import·SoftFileLock
31	from·filelock._~~util~~·import·~~ensu~~re_directo~~ry_exists,·t~~o~~uch,·w~~rite~~_all~~	24	from·filelock._lease·import·LeaseCompromise

		25	from·._protocol·import·GenerationLog,·Ledger,·Mode,·Participant
		26	from·._storage·import·OsFiles

32	if·TYPE_CHECKING:	27	if·TYPE_CHECKING:
33	····from·collections.abc·import·Callable,·Generator	28	····from·collections.abc·import·Callable,·Generator

		29	····from·filelock._lease·import·CompromiseReason

34	_Mode·=·Literal["read",·"write"]
35	_BREAK_SUFFIX:·Final[str]·=·".break"
36	_MAX_MARKER_SIZE:·Final[int]·=·1024
37	_O_NOFOLLOW:·Final[int]·=·getattr(os,·"O_NOFOLLOW",·0)
38	_O_NONBLOCK:·Final[int]·=·getattr(os,·"O_NONBLOCK",·0)
39	#·dirfd-relative·I/O·is·a·Unix-only·optimization;·Windows·cannot·``os.open()``·a·directory·at·all,·and
40	#·its·``os``·module·skips·dir_fd·support·entirely.·When·disabled,·callers·fall·back·to·full-path·ops.
41	_SUPPORTS_DIR_FD:·Final[bool]·=·sys.platform·!=·"win32"·and·os.open·in·os.supports_dir_fd

42	_ALL_INSTANCES:·Final[WeakValueDictionary[int,·SoftReadWriteLock]]·=·WeakValueDictionary()	30	_ALL_INSTANCES:·Final[WeakValueDictionary[int,·SoftReadWriteLock]]·=·WeakValueDictionary()
43	_ALL_INSTANCES_LOCK:·threading.Lock·=·threading.Lock()	31	_ALL_INSTANCES_LOCK:·threading.Lock·=·threading.Lock()
44	_SINGLETONS_UNDER_CONSTRUCTION:·Final[set[Path]]·=·set()	32	_SINGLETONS_UNDER_CONSTRUCTION:·Final[set[str]]·=·set()


45	class·_SoftRWMeta(type):	33	class·_SoftRWMeta(type):
46	····_instances:·WeakValueDictionary[Path,·SoftReadWriteLock]	34	····_instances:·WeakValueDictionary[str,·SoftReadWriteLock]
47	····_instances_lock:·threading.RLock	35	····_instances_lock:·threading.RLock

48	····def·__call__(··#·ruff:ignore[too-many-arguments]··#·forwards·the·public·constructor's·documented·parameters	36	····def·__call__(··#·ruff:ignore[too-many-arguments]··#·forwards·the·public·constructor's·documented·parameters
49	········cls,	37	········cls,
50	········lock_file:·str·\|·os.PathLike[str],	38	········lock_file:·str·\|·os.PathLike[str],
51	········timeout:·float·=·-1,	39	········timeout:·float·=·-1,
52	········*,	40	········*,
53	········blocking:·bool·=·True,	41	········blocking:·bool·=·True,
54	········is_singleton:·bool·=·True,	42	········is_singleton:·bool·=·True,
55	········heartbeat_interval:·float·=·30.0,	43	········heartbeat_interval:·float·=·30.0,
56	········stale_threshold:·float·\|·None·=·None,	44	········stale_threshold:·float·\|·None·=·None,
57	········poll_interval:·float·=·0.25,	45	········poll_interval:·float·=·0.25,
		46	········on_compromise:·Callable[[LeaseCompromise],·None]·\|·None·=·None,
58	····)·->·SoftReadWriteLock:	47	····)·->·SoftReadWriteLock:
59	········_ensure_current_process()	48	········_ensure_current_process()
		49	········timeout·=·_seconds("timeout",·timeout)
		50	········#·Passed·through·only·when·set,·so·a·subclass·that·declares·its·own·constructor·without·it·keeps·working.
		51	········extra·=·{}·if·on_compromise·is·None·else·{"on_compromise":·on_compromise}
60	········if·not·is_singleton:	52	········if·not·is_singleton:
61	············return·super().__call__(	53	············return·super().__call__(
62	················lock_file,	54	················lock_file,
63	················timeout,	55	················timeout,
64	················blocking=blocking,	56	················blocking=blocking,
65	················is_singleton=is_singleton,	57	················is_singleton=is_singleton,
66	················heartbeat_interval=heartbeat_interval,	58	················heartbeat_interval=heartbeat_interval,
67	················stale_threshold=stale_threshold,	59	················stale_threshold=stale_threshold,
68	················poll_interval=poll_interval,	60	················poll_interval=poll_interval,
		61	················**extra,
69	············)	62	············)

		63	········#·Keyed·like·the·log·root,·so·one·instance·never·spans·two·logs.
70	········normalized·=·Path(lock_fi~~le).reso~~lve()	64	········normalized·=·_canonical(lock_file)
71	········with·cls._instances_lock:	65	········with·cls._instances_lock:
72	············instance·=·cls._instances.get(normalized)	66	············instance·=·cls._instances.get(normalized)
73	············if·instance·is·None:	67	············if·instance·is·None:
74	················if·normalized·in·_SINGLETONS_UNDER_CONSTRUCTION:··#·pragma:·needs·fork	68	················if·normalized·in·_SINGLETONS_UNDER_CONSTRUCTION:··#·pragma:·needs·fork
75	····················msg·=·f"Singleton·lock·construction·is·already·active·for·{lock_file!s}"	69	····················msg·=·f"Singleton·lock·construction·is·already·active·for·{lock_file!s}"
76	····················raise·RuntimeError(msg)	70	····················raise·RuntimeError(msg)
77	················construction_pid·=·os.getpid()	71	················construction_pid·=·os.getpid()
Offset 92, 150 lines modified		Offset 86, 190 lines modified
92	························lock_file,	86	························lock_file,
93	························timeout,	87	························timeout,
94	························blocking=blocking,	88	························blocking=blocking,
95	························is_singleton=is_singleton,	89	························is_singleton=is_singleton,
96	························heartbeat_interval=heartbeat_interval,	90	························heartbeat_interval=heartbeat_interval,
97	························stale_threshold=stale_threshold,	91	························stale_threshold=stale_threshold,
98	························poll_interval=poll_interval,	92	························poll_interval=poll_interval,
		93	························**extra,
99	····················)	94	····················)
100	················finally:	95	················finally:
101	····················_SINGLETONS_UNDER_CONSTRUCTION.discard(normalized)	96	····················_SINGLETONS_UNDER_CONSTRUCTION.discard(normalized)
102	················if·os.getpid()·!=·construction_pid:··#·pragma:·needs·fork	97	················if·os.getpid()·!=·construction_pid:··#·pragma:·needs·fork
103	····················msg·=·"Lock·construction·cannot·continue·after·fork;·construct·a·new·lock·in·the·child"	98	····················msg·=·"Lock·construction·cannot·continue·after·fork;·construct·a·new·lock·in·the·child"
104	····················raise·RuntimeError(msg)	99	····················raise·RuntimeError(msg)
105	················cls._instances[normalized]·=·instance	100	················cls._instances[normalized]·=·instance
		101	············elif·(
		102	················_timeout_behavior(instance.timeout,·any_negative=False)
		103	················!=·_timeout_behavior(timeout,·any_negative=False)
106	············~~elif~~·~~instance.timeout~~·!=·~~timeout~~·or·instance.blocking·!=·blocking:	104	················or·instance.blocking·!=·blocking
		105	············):
107	················msg·=·(	106	················msg·=·(
108	····················f"Singleton·lock·created·with·timeout={instance.timeout},·blocking={instance.blocking},"	107	····················f"Singleton·lock·created·with·timeout={instance.timeout},·blocking={instance.blocking},"
109	····················f"·cannot·be·changed·to·timeout={timeout},·blocking={blocking}"	108	····················f"·cannot·be·changed·to·timeout={timeout},·blocking={blocking}"
110	················)	109	················)
Max diff block lines reached; 55213/60862 bytes (90.72%) of diff not shown.


Offset 1, 13 lines modified		Offset 1, 13 lines modified
1	#Copyright·ReportLab·Europe·Ltd.·2000-2026	1	#Copyright·ReportLab·Europe·Ltd.·2000-2026
2	#see·license.txt·for·license·details	2	#see·license.txt·for·license·details
3	__doc__="""The·Reportlab·PDF·generation·library."""	3	__doc__="""The·Reportlab·PDF·generation·library."""
4	Version·=·"5.0.0"	4	Version·=·"5.0.1"
5	__version__=Version	5	__version__=Version
6	__date__='20260~~618~~'	6	__date__='20260820'

7	import·sys,·os	7	import·sys,·os

8	__min_python_version__·=·(3,9)	8	__min_python_version__·=·(3,9)
9	if·sys.version_info<·__min_python_version__:	9	if·sys.version_info<·__min_python_version__:
10	····raise·ImportError("""reportlab·requires·%s.%s+;·other·versions·are·unsupported.	10	····raise·ImportError("""reportlab·requires·%s.%s+;·other·versions·are·unsupported.
11	If·you·want·to·try·with·other·python·versions·edit·line·10·of·reportlab/__init__	11	If·you·want·to·try·with·other·python·versions·edit·line·10·of·reportlab/__init__


Offset 291, 15 lines modified		Offset 291, 15 lines modified
291	····an·A4·page·with·a·title·above·it·-·possibly·overflowing	291	····an·A4·page·with·a·title·above·it·-·possibly·overflowing
292	····if·too·big."""	292	····if·too·big."""
293	····d·=·renderScaledDrawing(d)	293	····d·=·renderScaledDrawing(d)
294	····for·x·in·('Name','Size'):	294	····for·x·in·('Name','Size'):
295	········a·=·'initialFont'+x	295	········a·=·'initialFont'+x
296	········kwds[a]·=·getattr(d,a,kwds.pop(a,STATE_DEFAULTS['font'+x]))	296	········kwds[a]·=·getattr(d,a,kwds.pop(a,STATE_DEFAULTS['font'+x]))
297	····metadataPath·=·kwds.pop('metadataPath',None)	297	····metadataPath·=·kwds.pop('metadataPath',None)
298	····c·=·Canvas(fn,**kwds)	298	····c·=·kwds.pop('canvasMaker',Canvas)(fn,**kwds)
299	····if·msg:	299	····if·msg:
300	········c.setFont(rl_config.defaultGraphicsFontName,·36)	300	········c.setFont(rl_config.defaultGraphicsFontName,·36)
301	········c.drawString(80,·750,·msg)	301	········c.drawString(80,·750,·msg)
302	····c.setTitle(msg)	302	····c.setTitle(msg)

303	····if·autoSize:	303	····if·autoSize:
304	········c.setPageSize((d.width,·d.height))	304	········c.setPageSize((d.width,·d.height))


Offset 5, 14 lines modified		Offset 5, 19 lines modified
5	#hopefully·we·are·standing·on·giants'·shoulders	5	#hopefully·we·are·standing·on·giants'·shoulders
6	import·sys,·os,·ast,·re,·weakref,·time,·copy,·math,·types	6	import·sys,·os,·ast,·re,·weakref,·time,·copy,·math,·types
7	eval_debug·=·int(os.environ.get('EVAL_DEBUG','0'))	7	eval_debug·=·int(os.environ.get('EVAL_DEBUG','0'))
8	strTypes·=·(bytes,str)	8	strTypes·=·(bytes,str)
9	isPy39·=·sys.version_info[:2]>=(3,9)	9	isPy39·=·sys.version_info[:2]>=(3,9)
10	isPy313·=·sys.version_info[:2]>=(3,13)	10	isPy313·=·sys.version_info[:2]>=(3,13)

		11	try:
		12	» GenericAlias·=·types.GenericAlias
		13	except:
		14	» GenericAlias·=·None

11	import·textwrap	15	import·textwrap

12	class·BadCode(ValueError):	16	class·BadCode(ValueError):
13	» pass	17	» pass

14	#·For·AugAssign·the·operator·must·be·converted·to·a·string.	18	#·For·AugAssign·the·operator·must·be·converted·to·a·string.
15	augOps·=·{	19	augOps·=·{
Offset 915, 24 lines modified		Offset 920, 26 lines modified
915	» » #these·are·used·in·the·tree·visitor	920	» » #these·are·used·in·the·tree·visitor
916	» » __rl_builtins__['__rl_add__']·=·self.__rl_add__	921	» » __rl_builtins__['__rl_add__']·=·self.__rl_add__
917	» » __rl_builtins__['__rl_mult__']·=·self.__rl_mult__	922	» » __rl_builtins__['__rl_mult__']·=·self.__rl_mult__
918	» » __rl_builtins__['__rl_pow__']·=·self.__rl_pow__	923	» » __rl_builtins__['__rl_pow__']·=·self.__rl_pow__
919	» » __rl_builtins__['__rl_sd__']·=·self.__rl_sd__	924	» » __rl_builtins__['__rl_sd__']·=·self.__rl_sd__
920	» » __rl_builtins__['__rl_augAssign__']·=·self.__rl_augAssign__	925	» » __rl_builtins__['__rl_augAssign__']·=·self.__rl_augAssign__
921	» » __rl_builtins__['__rl_getitem__']·=·self.__rl_getitem__	926	» » __rl_builtins__['__rl_getitem__']·=·self.__rl_getitem__
		927	» » __rl_builtins__['__rl_setattr__']·=·self.__rl_setattr__
922	» » __rl_builtins__['__rl_getattr__']·=·self.__rl_getattr__	928	» » __rl_builtins__['__rl_getattr__']·=·self.__rl_getattr__
923	» » __rl_builtins__['__rl_getiter__']·=·self.__rl_getiter__	929	» » __rl_builtins__['__rl_getiter__']·=·self.__rl_getiter__
924	» » __rl_builtins__['__rl_max_len__']·=·self.__rl_max_len__	930	» » __rl_builtins__['__rl_max_len__']·=·self.__rl_max_len__
925	» » __rl_builtins__['__rl_max_pow_digits__']·=·self.__rl_max_pow_digits__	931	» » __rl_builtins__['__rl_max_pow_digits__']·=·self.__rl_max_pow_digits__
926	» » __rl_builtins__['__rl_iter_unpack_sequence__']·=·self.__rl_iter_unpack_sequence__	932	» » __rl_builtins__['__rl_iter_unpack_sequence__']·=·self.__rl_iter_unpack_sequence__
927	» » __rl_builtins__['__rl_unpack_sequence__']·=·self.__rl_unpack_sequence__	933	» » __rl_builtins__['__rl_unpack_sequence__']·=·self.__rl_unpack_sequence__
928	» » __rl_builtins__['__rl_apply__']·=·lambda·func,args,*kwds:·self.__rl_apply__(func,args,kwds)	934	» » __rl_builtins__['__rl_apply__']·=·lambda·func,args,*kwds:·self.__rl_apply__(func,args,kwds)
929	» » __rl_builtins__['__rl_SafeIter__']·=·__rl_SafeIter__	935	» » __rl_builtins__['__rl_SafeIter__']·=·__rl_SafeIter__

930	» » #these·are·tested·builtins	936	» » #these·are·tested·builtins
		937	» » __rl_builtins__['setattr']·=·self.__rl_setattr__
931	» » __rl_builtins__['getattr']·=·self.__rl_getattr__	938	» » __rl_builtins__['getattr']·=·self.__rl_getattr__
932	» » __rl_builtins__['dict']·=·__rl_dict__	939	» » __rl_builtins__['dict']·=·__rl_dict__
933	» » __rl_builtins__['iter']·=·self.__rl_getiter__	940	» » __rl_builtins__['iter']·=·self.__rl_getiter__
934	» » __rl_builtins__['pow']·=·self.__rl_pow__	941	» » __rl_builtins__['pow']·=·self.__rl_pow__
935	» » __rl_builtins__['list']·=·self.__rl_list__	942	» » __rl_builtins__['list']·=·self.__rl_list__
936	» » __rl_builtins__['type']·=·self.__rl_type__	943	» » __rl_builtins__['type']·=·self.__rl_type__
937	» » __rl_builtins__['max']·=·self.__rl_max__	944	» » __rl_builtins__['max']·=·self.__rl_max__
Offset 1071, 15 lines modified		Offset 1078, 20 lines modified

1071	» def·__rl_getattr__(self,·obj,·a,·*args):	1078	» def·__rl_getattr__(self,·obj,·a,·*args):
1072	» » if·isinstance(obj,·strTypes)·and·a=='format':	1079	» » if·isinstance(obj,·strTypes)·and·a=='format':
1073	» » » raise·BadCode('%s.format·is·not·implemented'·%·type(obj))	1080	» » » raise·BadCode('%s.format·is·not·implemented'·%·type(obj))
1074	» » self.__rl_is_allowed_name__(a)	1081	» » self.__rl_is_allowed_name__(a)
1075	» » return·getattr(obj,a,*args)	1082	» » return·getattr(obj,a,*args)

		1083	» def·__rl_setattr__(self,·obj,·a,·v,·*args):
		1084	» » #remediation·for·using·odd·magics
		1085	» » self.__rl_is_allowed_name__(a)
		1086	» » return·setattr(obj,a,v,*args)

1076	» def·__rl_getitem__(self,·obj,·a):	1087	» def·__inner_rl_getitem__(self,·obj,·a):
1077	» » if·type(a)·is·self.__slicetype__:	1088	» » if·type(a)·is·self.__slicetype__:
1078	» » » if·a.step·is·not·None:	1089	» » » if·a.step·is·not·None:
1079	» » » » v·=·obj[a]	1090	» » » » v·=·obj[a]
1080	» » » else:	1091	» » » else:
1081	» » » » start·=·a.start	1092	» » » » start·=·a.start
1082	» » » » stop·=·a.stop	1093	» » » » stop·=·a.stop
1083	» » » » if·start·is·None:	1094	» » » » if·start·is·None:
Offset 1090, 14 lines modified		Offset 1102, 25 lines modified
1090	» » » » » v·=·obj[start:stop]	1102	» » » » » v·=·obj[start:stop]
1091	» » » return·v	1103	» » » return·v
1092	» » elif·isinstance(a,strTypes):	1104	» » elif·isinstance(a,strTypes):
1093	» » » self.__rl_is_allowed_name__(a)	1105	» » » self.__rl_is_allowed_name__(a)
1094	» » » return·obj[a]	1106	» » » return·obj[a]
1095	» » return·obj[a]	1107	» » return·obj[a]

		1108	» def·__rl_getitem__(self,·obj,·a):
		1109	» » try:
		1110	» » » v·=·self.__inner_rl_getitem__(obj,a)
		1111	» » except·(IndexError,KeyError,KeyboardInterrupt,ValueError,TypeError):
		1112	» » » raise
		1113	» » except:
		1114	» » » raise·BadCode("subscript·operation·%s[%r]·failed"·%·(obj.__class__.__name__,a))
		1115	» » if·isinstance(v,GenericAlias):
		1116	» » » raise·BadCode("subscript·operation·%s[%r]·created·a·GenericAlias"·%·(obj.__class__.__name__,a))
		1117	» » return·v

1096	» __rl_tmax__·=·5	1118	» __rl_tmax__·=·5
1097	» __rl_max_len__·=·100000	1119	» __rl_max_len__·=·100000
1098	» __rl_max_pow_digits__·=·100	1120	» __rl_max_pow_digits__·=·100

1099	» def·__rl_add__(self,·a,·b):	1121	» def·__rl_add__(self,·a,·b):
1100	» » if·(hasattr(a,·'__len__')·and·hasattr(b,·'__len__')	1122	» » if·(hasattr(a,·'__len__')·and·hasattr(b,·'__len__')
1101	» » » » and·(len(a)·+·len(b))·>·self.__rl_max_len__):	1123	» » » » and·(len(a)·+·len(b))·>·self.__rl_max_len__):