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

⊟

3.66 MB

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

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

⊟

8.2 KB

APK Signing Block ¶

⊟

3.02 KB

zipinfo {} ¶

⊟

3.64 MB

assets/chaquopy/requirements-common.imy ¶

⊟

25.9 KB

zipinfo {} ¶

⊟

6.14 KB

zipnote «TEMP»/diffoscope_ck0yund1_unsigned/tmp1hex3_fp_.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 ¶

⊟

7.29 KB

filelock/__init__.py ¶

⊟

96.2 KB

filelock/_api.py ¶

⊟

21.1 KB

filelock/_async.py ¶

⊟

18.8 KB

filelock/_async_read_write.py ¶

⊟

3.02 KB

filelock/_descriptor.py ¶

⊟

3.25 KB

filelock/_error.py ¶

⊟

13.8 KB

filelock/_identity.py ¶

⊟

24.7 KB

filelock/_lease.py ¶

⊟

9.3 KB

filelock/_marker.py ¶

⊟

67.1 KB

filelock/_read_write.py ¶

⊟

36.1 KB

filelock/_soft.py ¶

⊟

298 B

filelock/_soft_protocol.py ¶

⊟

56.8 KB

filelock/_strict.py ¶

⊟

13.6 KB

filelock/_unix.py ¶

⊟

21.8 KB

filelock/_util.py ¶

⊟

37.7 KB

filelock/_windows.py ¶

⊟

28.7 KB

filelock/asyncio.py ¶

⊟

420 B

filelock/version.py ¶

⊟

764 B

filelock/_soft_rw/__init__.py ¶

⊟

19.0 KB

filelock/_soft_rw/_async.py ¶

⊟

65.7 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 ¶

⊟

34.9 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.2.dist-info/METADATA vs.

filelock-4.2.4.dist-info/METADATA ¶

Files 96% similar despite different names

⊟

122 B

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

filelock-4.2.4.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

⊟

529 B

svglib-2.1.0.dist-info/METADATA vs.

svglib-2.3.0.dist-info/METADATA ¶

Files 99% similar despite different names

⊟

125 B

svglib-2.1.0.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': '246acc8cd3abe0efee954a99a486485b0bceeabb'}"}

+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: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+Key·0xf05368c0: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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.2.dist-info/	913	Filename:·filelock-4.2.4.dist-info/
910	Comment:·	914	Comment:·

911	Filename:·filelock-3.32.2.dist-info/INSTALLER	915	Filename:·filelock-4.2.4.dist-info/INSTALLER
912	Comment:·	916	Comment:·

913	Filename:·filelock-3.32.2.dist-info/METADATA	917	Filename:·filelock-4.2.4.dist-info/METADATA
914	Comment:·	918	Comment:·

915	Filename:·filelock-3.32.2.dist-info/licenses/	919	Filename:·filelock-4.2.4.dist-info/licenses/
916	Comment:·	920	Comment:·

917	Filename:·filelock-3.32.2.dist-info/licenses/LICENSE	921	Filename:·filelock-4.2.4.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; 2670775/2891748 bytes (92.36%) of diff not shown.


Offset 1, 8 lines modified		Offset 1, 8 lines modified
1	Zip·file·size:·63~~382292~~·bytes,·number·of·entries:·219	1	Zip·file·size:·63428637·bytes,·number·of·entries:·216
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·····6979·b-·stor·81-Jan-01·01:01·assets/dexopt/baseline.prof	4	-rw-r--r--··0.0·unx·····6979·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··4070296·b-·defN·81-Jan-01·01:01·classes2.dex	7	-rw-r--r--··0.0·unx··4070296·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··3~~7398~~30·b-·stor·81-Jan-01·01:01·assets/chaquopy/requirements-common.imy	77	-rw-r--r--··0.0·unx··3810937·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 211, 11 lines modified		Offset 211, 8 lines modified
211	-rw----·····0.0·fat······225·b-·stor·81-Jan-01·01:01·res/wN.9.png	211	-rw----·····0.0·fat······225·b-·stor·81-Jan-01·01:01·res/wN.9.png
212	-rw----·····0.0·fat·····2456·b-·defN·81-Jan-01·01:01·res/xN.xml	212	-rw----·····0.0·fat·····2456·b-·defN·81-Jan-01·01:01·res/xN.xml
213	-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/xa.9.png
214	-rw----·····0.0·fat······221·b-·stor·81-Jan-01·01:01·res/z-.9.png	214	-rw----·····0.0·fat······221·b-·stor·81-Jan-01·01:01·res/z-.9.png
215	-rw----·····0.0·fat······206·b-·stor·81-Jan-01·01:01·res/zL.png	215	-rw----·····0.0·fat······206·b-·stor·81-Jan-01·01:01·res/zL.png
216	-rw----·····0.0·fat······884·b-·stor·81-Jan-01·01:01·res/zz.png	216	-rw----·····0.0·fat······884·b-·stor·81-Jan-01·01:01·res/zz.png
217	-rw----·····0.0·fat···416072·b-·stor·81-Jan-01·01:01·resources.arsc	217	-rw----·····0.0·fat···416072·b-·stor·81-Jan-01·01:01·resources.arsc
218	-rw----·····2.0·fat····22728·b-·defN·81-Jan-01·01:01·META-INF/57818ACA.SF
219	-rw----·····2.0·fat·····1344·b-·defN·81-Jan-01·01:01·META-INF/57818ACA.RSA
220	-rw----·····2.0·fat····22601·b-·defN·81-Jan-01·01:01·META-INF/MANIFEST.MF
221	219·files,·747~~64908~~·bytes·uncompressed,·62~~854572~~·bytes·compressed:··15.9%	218	216·files,·74789342·bytes·uncompressed,·62907998·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:·3~~7398~~30·bytes,·number·of·entries:·773	1	Zip·file·size:·3810937·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, 81 lines modified		Offset 1, 136 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

		9	__lazy_modules__·=·["filelock._descriptor",·"filelock._error",·"importlib"]

7	import·sys	10	import·sys
8	import·warnings	11	import·warnings
		12	from·importlib·import·import_module
9	from·typing·import·TYPE_CHECKING,·Final	13	from·typing·import·TYPE_CHECKING,·Final

10	from·._api·import·AcquireReturnProxy,·BaseFileLock,·CloseErrorPolicy,·ContextErrorPolicy,·LockOptions	14	from·filelock._api·import·AcquireReturnProxy,·BaseFileLock,·CloseErrorPolicy,·ContextErrorPolicy,·LockOptions
11	from·._descriptor·import·lock_descriptor,·unlock_descriptor	15	from·filelock._descriptor·import·lock_descriptor,·unlock_descriptor
12	from·._error·import·LeaseSettingsMismatch,·SoftFileLockLifetimeWarning,·SoftFileLockProtocolError,·Timeout	16	from·filelock._error·import·LeaseSettingsMismatch,·SoftFileLockLifetimeWarning,·SoftFileLockProtocolError,·Timeout
13	from·._lease·import·LeaseCompromise,·SoftFileLease
14	from·~~._mar~~ker·import·~~MarkerSoft~~FileLock~~,·OwnerRecord~~	17	from·filelock._unix·import·UnixFileLock
		18	from·filelock._unix·import·has_fcntl·as·_has_fcntl
		19	from·filelock._windows·import·WindowsFileLock

		20	#·Keeps·``filelock.version``·the·string·4.0.12·exposed·rather·than·the·submodule.
		21	from·filelock.version·import·version

15	if·TYPE_CHECKING:	22	if·TYPE_CHECKING:
16	····from·~~._asyn~~c_~~read_w~~rite·i~~mport·(~~	23	····from·filelock·import·asyncio
		24	····from·filelock._async_read_write·import·AsyncAcquireReadWriteReturnProxy,·AsyncReadWriteLock
		25	····from·filelock._lease·import·CompromiseReason,·LeaseCompromise,·SoftFileLease
		26	····from·filelock._marker·import·MarkerSoftFileLock,·OwnerMode,·OwnerRecord
		27	····from·filelock._read_write·import·ReadWriteLock


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

		2	__lazy_modules__·=·[
		3	····"atexit",
		4	····"decimal",
		5	····"filelock._error",
		6	····"filelock._util",
		7	····"inspect",
		8	····"math",
		9	····"numbers",
		10	····"secrets",
		11	····"types",
		12	····"warnings",
		13	]

		14	import·atexit
2	import·contextlib	15	import·contextlib
3	import·inspect	16	import·inspect
4	import·logging	17	import·logging
5	import·math	18	import·math
6	import·os	19	import·os
7	import·secrets	20	import·secrets
		21	import·stat
8	import·sys	22	import·sys
9	import·time	23	import·time
		24	import·types
10	import·warnings	25	import·warnings
11	from·abc·import·ABCMeta,·abstractmethod	26	from·abc·import·ABCMeta,·abstractmethod
12	from·collections.abc·import·Callable,·Hashable	27	from·collections.abc·import·Callable,·Hashable
13	from·contextlib·import·contextmanager	28	from·contextlib·import·contextmanager
14	from·dataclasses·import·dataclass	29	from·dataclasses·import·dataclass,·fields
		30	from·decimal·import·Decimal
		31	from·functools·import·cache,·partial
15	from·itertools·import·count,·starmap	32	from·itertools·import·count,·starmap
		33	from·numbers·import·Real
16	from·threading·import·Condition,·RLock,·get_ident,·local	34	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	35	from·typing·import·TYPE_CHECKING,·Final,·Generic,·Literal,·NoReturn,·TypedDict,·TypeVar,·cast
18	from·weakref·import·WeakKeyDictionary,·WeakValueDictionary	36	from·weakref·import·WeakKeyDictionary,·WeakValueDictionary,·ref


Offset 1, 117 lines modified		Offset 1, 429 lines modified
1	"""Separate·caller·cancellation·from·backend·task·and·executor-future·results."""	1	"""Separate·caller·cancellation·from·backend·task·and·executor-future·results."""

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

		3	__lazy_modules__·=·["asyncio",·"collections",·"concurrent.futures",·"filelock._error"]

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

10	from·~~._a~~pi·~~imp~~o~~rt·~~_a~~ppend_exce~~pti~~on_context,~~·~~_raise_cha~~i~~ned_er~~r~~ors~~	13	from·filelock._api·import·(
		14	····_append_exception_context,
		15	····_fork_transition,
		16	····_raise_chained_errors,
		17	····_resolve_read_write_timeout,
		18	)
		19	from·filelock._error·import·Timeout

11	if·TYPE_CHECKING:	20	if·TYPE_CHECKING:
12	····from·collections.abc·import·AsyncIterator,·Awaitable,·Callable	21	····from·collections.abc·import·AsyncGenerator,·Awaitable,·Callable
		22	····from·concurrent.futures·import·Executor

		23	····from·filelock._read_write·import·ReadWriteLock
		24	····from·filelock._soft_rw·import·SoftReadWriteLock

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

		26	#:·The·holder·an·async·wrapper·records·its·backend·level·under.·No·thread·has·this·identifier,·so·sync·code·on·the
		27	#:·executor·thread·that·took·the·level·cannot·re-enter·or·release·it.
		28	_TASKS_THREAD_ID:·Final[int]·=·0


Offset 1, 56 lines modified		Offset 1, 66 lines modified
1	"""Async·wrapper·around·:class:`ReadWriteLock`·for·use·with·``asyncio``."""	1	"""Async·wrapper·around·:class:`ReadWriteLock`·for·use·with·``asyncio``."""

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

		3	__lazy_modules__·=·["asyncio",·"concurrent.futures",·"filelock._async",·"filelock._error",·"functools",·"threading"]

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

10	from·._api·import·(	13	from·filelock._api·import·(
11	····_append_exception_context,	14	····_append_exception_context,
12	····_ensure_current_process,	15	····_ensure_current_process,
13	····_fork_transition,	16	····_fork_transition,
14	····_register_fork_object,	17	····_register_fork_object,
15	)	18	)
16	from·._async·import·(	19	from·filelock._async·import·(
		20	····_TASKS_THREAD_ID,
17	····_BackendOutcome,	21	····_BackendOutcome,
18	····_capture_call,	22	····_capture_call,
19	····_drain_future,	23	····_drain_future,
20	····_future_result,	24	····_future_result,
21	····_raise_cancelled_error,	25	····_raise_cancelled_error,
		26	····_task_owners_for,
22	····_wait_until_done,	27	····_wait_until_done,
23	)	28	)
		29	from·filelock._error·import·Timeout
24	from·._read_write·import·ReadWriteLock	30	from·filelock._read_write·import·ReadWriteLock

25	if·TYPE_CHECKING:	31	if·TYPE_CHECKING:
26	····from·collections.abc·import·AsyncGenerator,·Callable	32	····from·collections.abc·import·AsyncGenerator,·Callable,·MutableMapping
27	····from·concurrent·import·futures	33	····from·concurrent·import·futures
28	····from·types·import·TracebackType	34	····from·types·import·TracebackType

29	····from·._api·import·AcquireReturnProxy	35	····from·filelock._api·import·AcquireReturnProxy


30	_P·=·ParamSpec("_P")	36	_P·=·ParamSpec("_P")
31	_R·=·TypeVar("_R")	37	_R·=·TypeVar("_R")


32	class·AsyncReadWriteLock:	38	class·AsyncReadWriteLock:
33	····"""	39	····"""
34	····Async·wrapper·around·:class:`ReadWriteLock`·for·use·in·``asyncio``·applications.	40	····Async·wrapper·around·:class:`ReadWriteLock`·for·use·in·``asyncio``·applications.

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

38	····:param·lock_file:·path·to·the·SQLite·database·file·used·as·the·lock	46	····:param·lock_file:·path·to·the·SQLite·database·file·used·as·the·lock
39	····:param·timeout:·maximum·wait·time·in·seconds;·``-1``·~~mean~~s·block·~~inde~~f~~ini~~tely	47	····:param·timeout:·maximum·wait·time·in·seconds;·``-1``·waits·up·to·SQLite's·busy-timeout·cap·of·about·23·days
40	····:param·blocking:·if·``False``,·raise·:class:`~filelock.Timeout`·immediately·when·the·lock·is·unavailable	48	····:param·blocking:·if·``False``,·raise·:class:`~filelock.Timeout`·immediately·when·the·lock·is·unavailable
41	····:param·is_singleton:·if·``True``,·reuse·existing·:class:`ReadWriteLock`·instances·for·the·same·resolved·path	49	····:param·is_singleton:·if·``True``,·reuse·existing·:class:`ReadWriteLock`·instances·for·the·same·resolved·path
42	····:param·loop:·event·loop·for·``run_in_executor``;·``None``·uses·the·running·loop	50	····:param·loop:·event·loop·for·``run_in_executor``;·``None``·uses·the·running·loop
43	····:param·executor:·executor·for·``run_in_executor``.·When·``None``·this·lock·creates·and·owns·a·dedicated	51	····:param·executor:·executor·for·``run_in_executor``.·When·``None``·this·lock·creates·and·owns·a·dedicated
44	········single-thread·executor·so·every·operation·runs·on·the·same·thread·(SQLite·affinity·requires·this)·and·shuts·it	52	········single-thread·executor·so·every·operation·runs·on·the·same·thread·(SQLite·affinity·requires·this)·and·shuts·it
45	········down·in·:meth:`close`.·This·lock·uses·a·caller-supplied·executor·as-is·and·never·shuts·it·down,·so·after·passing	53	········down·in·:meth:`close`.·This·lock·uses·a·caller-supplied·executor·as-is·and·never·shuts·it·down,·so·after·passing
46	········no·executor·call·:meth:`close`·to·release·the·owned·one.	54	········no·executor·call·:meth:`close`·to·release·the·owned·one.
Offset 69, 17 lines modified		Offset 79, 21 lines modified
69	········loop:·asyncio.AbstractEventLoop·\|·None·=·None,	79	········loop:·asyncio.AbstractEventLoop·\|·None·=·None,
70	········executor:·futures.Executor·\|·None·=·None,	80	········executor:·futures.Executor·\|·None·=·None,
71	····)·->·None:	81	····)·->·None:
72	········creator_pid·=·os.getpid()	82	········creator_pid·=·os.getpid()
73	········self._creator_pid·=·creator_pid	83	········self._creator_pid·=·creator_pid
74	········self._fork_invalidated·=·False	84	········self._fork_invalidated·=·False
75	········self._closed·=·False	85	········self._closed·=·False
		86	········self._owns_backend·=·not·is_singleton
		87	········#:·Marks·the·task·holds·taken·through·this·wrapper,·which·its·close()·ends.
		88	········self._via:·Final·=·object()
76	········_register_fork_object(self)	89	········_register_fork_object(self)
77	········with·_fork_transition():	90	········with·_fork_transition():
78	············self._lock·=·ReadWriteLock(lock_file,·timeout,·blocking=blocking,·is_singleton=is_singleton)	91	············self._lock·=·ReadWriteLock(lock_file,·timeout,·blocking=blocking,·is_singleton=is_singleton)
		92	············self._owners·=·_task_owners_for(self._lock)
79	············self._loop·=·loop	93	············self._loop·=·loop
80	············self._owns_executor·=·executor·is·None	94	············self._owns_executor·=·executor·is·None
81	············self._executor·=·executor·or·ThreadPoolExecutor(max_workers=1)	95	············self._executor·=·executor·or·ThreadPoolExecutor(max_workers=1)
82	············if·os.getpid()·!=·creator_pid:··#·pragma:·forked·child	96	············if·os.getpid()·!=·creator_pid:··#·pragma:·forked·child
83	················msg·=·"AsyncReadWriteLock·construction·cannot·continue·after·fork"	97	················msg·=·"AsyncReadWriteLock·construction·cannot·continue·after·fork"
84	················raise·RuntimeError(msg)	98	················raise·RuntimeError(msg)

Offset 115, 18 lines modified		Offset 129, 14 lines modified

115	········Falls·back·to·instance·defaults·for·timeout·and·blocking·when·``None``.	129	········Falls·back·to·instance·defaults·for·timeout·and·blocking·when·``None``.

116	········: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
117	········: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

118	········"""	132	········"""
119	········if·timeout·is·None:
120	············timeout·=·self._lock.timeout
121	········if·blocking·is·None:
122	············blocking·=·self._lock.blocking
123	········await·self.acquire_read(timeout,·blocking=blocking)	133	········await·self.acquire_read(timeout,·blocking=blocking)
124	········body_error:·BaseException·\|·None·=·None	134	········body_error:·BaseException·\|·None·=·None
125	········try:	135	········try:
126	············yield	136	············yield
127	········except·BaseException·as·error:	137	········except·BaseException·as·error:
128	············body_error·=·error	138	············body_error·=·error
129	············raise	139	············raise
Offset 140, 18 lines modified		Offset 150, 14 lines modified

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

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

143	········"""	153	········"""
144	········if·timeout·is·None:
145	············timeout·=·self._lock.timeout
146	········if·blocking·is·None:
147	············blocking·=·self._lock.blocking
148	········await·self.acquire_write(timeout,·blocking=blocking)	154	········await·self.acquire_write(timeout,·blocking=blocking)
149	········body_error:·BaseException·\|·None·=·None	155	········body_error:·BaseException·\|·None·=·None
150	········try:	156	········try:
151	············yield	157	············yield
152	········except·BaseException·as·error:	158	········except·BaseException·as·error:
153	············body_error·=·error	159	············body_error·=·error
154	············raise	160	············raise
Max diff block lines reached; 13240/19148 bytes (69.15%) of diff not shown.


Offset 1, 20 lines modified		Offset 1, 24 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	__lazy_modules__·=·["filelock._unix",·"threading",·"typing"]

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

		8	from·filelock._api·import·_seconds

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


11	def·lock_descriptor(fd:·int,·*,·blocking:·bool·=·True,·poll_interval:·float·=·0.05)·->·bool:	13	def·lock_descriptor(fd:·int,·*,·blocking:·bool·=·True,·poll_interval:·float·=·0.05)·->·bool:
12	····"""	14	····"""
13	····Take·the·native·OS·lock·on·fd,·a·file·descriptor·the·caller·opened·and·owns.	15	····Take·the·native·OS·lock·on·fd,·a·file·descriptor·the·caller·opened·and·owns.

14	····This·is·the·same·one-byte·exclusive·lock·:class:`FileLock`·uses,·so·a·descriptor·lock·and·a·path·lock·on·the·same	16	····This·is·the·same·one-byte·exclusive·lock·:class:`FileLock`·uses,·so·a·descriptor·lock·and·a·path·lock·on·the·same
Offset 24, 30 lines modified		Offset 28, 31 lines modified

24	····For·timeout,·reentrancy,·singleton,·lifetime,·or·stale-break·behavior,·use·:class:`FileLock`.·There·is·no·async	28	····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.	29	····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.	30	····: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	31	····:param·blocking:·when·``True``·(default),·retry·the·nonblocking·attempt·every·poll_interval·seconds·until·it
28	········succeeds;·when·``False``,·make·one·attempt.	32	········succeeds;·when·``False``,·make·one·attempt.
29	····:param·poll_interval:·finite,·positive·seconds·between·attempts·while·blocking;·ignored·when·blocking·is
30	········~~``F~~alse``.	33	····:param·poll_interval:·positive·seconds·between·attempts·while·blocking,·at·most·:data:`threading.TIMEOUT_MAX`;
		34	········ignored·when·blocking·is·``False``.

31	····:returns:·``True``·once·the·lock·is·held,·or·``False``·on·contention·when·``blocking``·is·``False``.	35	····: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	36	····: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.	37	········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.	38	····:raises·ValueError:·if·a·blocking·call·receives·a·poll_interval·outside·that·range,·including·``nan``.

35	····..·versionadded::·3.30.0	39	····..·versionadded::·3.30.0

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


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


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

		2	__lazy_modules__·=·["typing"]

		3	from·typing·import·Final


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

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

7	····def·__reduce__(self)·->·tuple[type[Timeout],·tuple[str]]:	10	····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~~	11	········#·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,)	12	········return·self.__class__,·(self._lock_file,),·self.__dict__

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

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

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


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

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

		29	····"""


20	class·LeaseSettingsMismatch(ValueError):··#·ruff:ignore[error-suffix-on-exception-name]··#·public·exception·name;·renaming·breaks·the·API	30	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."""	31	····"""A·lease·contender·disagrees·with·the·published·claim·about·how·long·the·lease·lasts."""


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

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

47	····def·__str__(self)·->·str:	63	····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}"	64	········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}"	65	········return·f"Invalid·strict·soft-lock·state·at·{location}:·{self._reason}"

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


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

		2	__lazy_modules__·=·["hashlib",·"pathlib",·"socket",·"typing"]

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

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


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

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

		33	····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
		34	····kept·prefix·one·identity,·and·:func:`owner_is_stale`·would·then·probe·a·local·PID·for·another·host's·holder.
		35	····"""
		36	····name·=·(
		37	········"".join(
		38	············chr(byte)·if·byte·in·_HOST_NAME_VERBATIM·else·f"?{byte:02x}"
		39	············for·byte·in·socket.gethostname().encode("utf-8",·"surrogateescape")
		40	········)
		41	········+·_pid_namespace_suffix()
		42	····)
		43	····if·len(name)·>·_HOST_NAME_LIMIT:
		44	········keep·=·_HOST_NAME_LIMIT·-·_HOST_NAME_DIGEST_LEN·-·1
		45	········name·=·f"{name[:keep]}-{hashlib.sha256(name[keep:].encode()).hexdigest()[:_HOST_NAME_DIGEST_LEN]}"
		46	····#·An·escape·is·three·characters·and·a·kept·byte·is·never·'?',·so·a·bare·'?'·can·only·mean·an·empty·hostname.
		47	····return·name·or·"?"


		48	def·_pid_namespace_suffix()·->·str:
		49	····try:
		50	········namespace:·Final·=·Path("/proc/self/ns/pid").stat().st_ino
		51	····except·OSError:··#·only·Linux·3.8+·has·the·file,·and·a·sandbox·may·hide·it;·nothing·else·tells·namespaces·apart
		52	········return·""
		53	····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:	54	def·owner_is_stale(pid:·int,·hostname:·str,·start_token:·int·\|·None)·->·bool:
12	····"""	55	····"""
13	····Whether·the·recorded·owner·is·provably·gone,·so·reclaiming·its·marker·cannot·detach·a·live·holder.	56	····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	57	····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	58	····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	59	····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	60	····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.	61	····and·treat·an·unreadable·or·foreign·owner·as·still·holding.
19	····"""	62	····"""
20	····if·hostname·!=·host_name():	63	····if·hostname·!=·host_name():
21	········return·False	64	········return·False
22	····if·~~not·~~process_alive(pid):	65	····if·process_alive(pid)·and·(
23	········return·True
24	····if·start_token·is·None:	66	········start_token·is·None·or·(current·:=·process_start_token(pid))·is·None·or·_same_start(current,·start_token)
		67	····):
25	········return·False	68	········return·False
26	····current·=·process_start_token(pid)
27	····return·current·is·not·None·~~and~~·~~cur~~rent~~·!=~~·sta~~rt_tok~~en	69	····#·Only·a·bare·hostname·can·be·an·older·release's,·written·from·a·container·that·shares·this·host's·name.
		70	····return·_NAMESPACE_MARK·in·hostname·or·not·_owner_runs_elsewhere(pid,·start_token)


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

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


		81	def·_same_start(current:·int,·recorded:·int)·->·bool:
		82	····#·A·Linux·token·carries·the·boot·id·in·its·high·64·bits,·or·0·there·when·the·process·could·not·read·the·boot·id.
		83	····#·systemd's·ProcSubset=pid·hides·/proc/sys·from·one·unit,·so·one·process·may·lack·the·boot·id·while·its·peer·has
		84	····#·it.·A·missing·boot·id·then·proves·nothing,·and·only·starttime·is·compared.·Other·platforms'·tokens·fit·in·the
		85	····#·low·bits.
		86	····return·current·==·recorded·or·(0·in·{current·>>·64,·recorded·>>·64}·and·current·%·264·==·recorded·%·264)


28	if·sys.platform·==·"win32":··#·pragma:·win32·cover	87	if·sys.platform·==·"win32":··#·pragma:·win32·cover
29	····import·ctypes	88	····import·ctypes
30	····from·ctypes·import·wintypes	89	····from·ctypes·import·wintypes

31	····_KERNEL32:·Final[ctypes.WinDLL]·=·ctypes.WinDLL("kernel32",·use_last_error=True)	90	····_KERNEL32:·Final[ctypes.WinDLL]·=·ctypes.WinDLL("kernel32",·use_last_error=True)
Offset 103, 41 lines modified		Offset 174, 112 lines modified
103	········#·comm·(field·2)·is·wrapped·in·parentheses·and·may·itself·contain·spaces·or·a·')',·so·the·fixed·fields·start	174	········#·comm·(field·2)·is·wrapped·in·parentheses·and·may·itself·contain·spaces·or·a·')',·so·the·fixed·fields·start
104	········#·after·the·final·')'.·starttime·is·field·22·overall,·the·twentieth·of·those·trailing·fields·(index·19).	175	········#·after·the·final·')'.·starttime·is·field·22·overall,·the·twentieth·of·those·trailing·fields·(index·19).
105	········_STARTTIME_INDEX:·Final[int]·=·19	176	········_STARTTIME_INDEX:·Final[int]·=·19

106	········def·_read_boot_id()·->·int:	177	········def·_read_boot_id()·->·int:
107	············#·starttime·is·measured·in·clock·ticks·since·boot,·so·on·its·own·it·repeats·across·a·reboot.·Folding·the	178	············#·starttime·is·measured·in·clock·ticks·since·boot,·so·on·its·own·it·repeats·across·a·reboot.·Folding·the
108	············#·boot·id·into·the·high·bits·makes·the·Linux·token·reboot-safe·like·the·absolute·clocks·macOS·and·Windows	179	············#·boot·id·into·the·high·bits·makes·the·Linux·token·reboot-safe·like·the·absolute·clocks·macOS·and·Windows
109	············#·expose,·while·staying·a·single·integer·so·a·3.29·reader·still·parses·the·third·marker·line.·0·when·the	180	············#·expose,·while·staying·a·single·integer·so·a·3.29·reader·still·parses·the·third·marker·line.·0·when·this
		181	············#·process·cannot·read·the·boot·id·leaves·the·bare·starttime,·which·_same_start·compares·alone.
110	············#·kernel·does·not·expose·a·boot·id·degrades·to·bare·starttime,·which·stays·safe·(a·reboot·collision·fails
111	············#·closed·rather·than·reclaiming·a·live·marker).
112	············try:	182	············try:
113	················boot_id·=·Path("/proc/sys/kernel/random/boot_id").read_text(encoding="ascii")	183	················boot_id·=·Path("/proc/sys/kernel/random/boot_id").read_text(encoding="ascii")
Max diff block lines reached; 6404/14093 bytes (45.44%) of diff not shown.


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

		2	__lazy_modules__·=·[
		3	····"contextlib",
		4	····"filelock._error",
		5	····"filelock._identity",
		6	····"filelock._soft",
		7	····"filelock._util",
		8	····"math",
		9	····"secrets",
		10	····"threading",
		11	····"weakref",
		12	]

2	import·os	13	import·os
3	import·secrets	14	import·secrets
		15	import·sys
4	import·time	16	import·time
5	from·contextlib·import·suppress	17	from·contextlib·import·suppress
6	from·dataclasses·import·dataclass	18	from·dataclasses·import·dataclass
		19	from·math·import·isfinite
7	from·threading·import·Event,·Thread,·current_thread~~,·local~~	20	from·threading·import·Event,·Thread,·current_thread
8	from·typing·import·TYPE_CHECKING,·Literal	21	from·typing·import·TYPE_CHECKING,·Final,·Literal,·cast
		22	from·weakref·import·WeakMethod

		23	from·filelock._api·import·_check_timeout_max,·_seconds
9	from·._error·import·LeaseSettingsMismatch	24	from·filelock._error·import·LeaseSettingsMismatch
10	from·._identity·import·owner_is_stale	25	from·filelock._identity·import·owner_is_stale
11	from·._marker·import·MarkerSoftFileLock,·OwnerMode,·OwnerRecord,·parse_marker	26	from·filelock._marker·import·MarkerSoftFileLock,·OwnerMode,·OwnerRecord,·parse_marker
12	from·._soft·import·_read_lock_file	27	from·filelock._soft·import·_read_lock_file
13	from·._util·import·br~~eak~~_~~lock_fil~~e,·touch	28	from·filelock._util·import·pin_inode,·touch

14	if·TYPE_CHECKING:	29	if·TYPE_CHECKING:
15	····import·sys
16	····from·collections.abc·import·Callable	30	····from·collections.abc·import·Callable,·Mapping
		31	····from·typing·import·Unpack

17	····from·._api·import·LockOptions

		32	····from·filelock._api·import·LockOptions,·_ExtraValue
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

		33	#:·``evicted``·is·a·:class:`~filelock.SoftReadWriteLock`·loss:·a·peer·waited·out·the·stale·threshold·and·committed·a
		34	#:·generation·without·this·holder.
22	CompromiseReason·=·Literal["marker-missing",·"owner-changed",·"refresh-failed"]	35	CompromiseReason·=·Literal["marker-missing",·"owner-changed",·"refresh-failed",·"evicted"]

23	_RefreshOutcome·=·Literal["ok",·"lost",·"transient"]	36	_RefreshOutcome·=·Literal["ok",·"transient",·"marker-missing",·"owner-changed"]
		37	_DEFAULT_LEASE_DURATION:·Final[float]·=·30.0


24	@dataclass(frozen=True)	38	@dataclass(frozen=True)
25	class·LeaseCompromise:	39	class·LeaseCompromise:
26	····"""Why·a·held·lease·stopped·being·this·process's·to·hold."""	40	····"""Why·a·held·lease·stopped·being·this·process's·to·hold,·and·the·error·that·ended·its·refresh,·if·any."""

27	····lock_file:·str	41	····lock_file:·str
28	····token:·str	42	····token:·str
29	····reason:·CompromiseReason	43	····reason:·CompromiseReason
30	····error:·~~OSErr~~or·\|·None·=·None	44	····error:·Exception·\|·None·=·None


31	@dataclass(frozen=True)	45	@dataclass(frozen=True)
32	class·_Heartbeat:	46	class·_Heartbeat:
33	····"""A·running·heartbeat·and·the·event·that·stops·it,·which·only·ever·exist·together."""	47	····"""A·running·heartbeat·and·the·event·that·stops·it,·which·only·ever·exist·together."""

34	····thread:·Thread	48	····thread:·Thread
Offset 53, 36 lines modified		Offset 67, 23 lines modified
53	····"""The·state·of·one·claim:·its·token,·its·heartbeat,·and·how·that·claim·was·lost."""	67	····"""The·state·of·one·claim:·its·token,·its·heartbeat,·and·how·that·claim·was·lost."""

54	····token:·str·\|·None·=·None	68	····token:·str·\|·None·=·None
55	····compromise:·LeaseCompromise·\|·None·=·None	69	····compromise:·LeaseCompromise·\|·None·=·None
56	····heartbeat:·_Heartbeat·\|·None·=·None	70	····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):	71	class·SoftFileLease(MarkerSoftFileLock):
66	····"""	72	····"""
67	····Existence·lock·whose·claim·expires,·so·a·peer·may·take·it·while·the·previous·holder·still·runs.	73	····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	74	····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	75	····``heartbeat_interval``·seconds;·a·contender·takes·the·marker·once·it·has·seen·no·refresh·for·``lease_duration``
		76	····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	77	····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.	78	····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	79	····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,	80	····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.	81	····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	82	····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	83	····different·duration·raises·:class:`LeaseSettingsMismatch·<filelock.LeaseSettingsMismatch>`·rather·than·apply·its·own
Offset 108, 54 lines modified		Offset 109, 80 lines modified
108	····_lifetime_supported:·bool·=·False	109	····_lifetime_supported:·bool·=·False
109	····_lifetime_unsupported_reason:·str·=·"lease_duration·sets·when·a·lease·expires"	110	····_lifetime_unsupported_reason:·str·=·"lease_duration·sets·when·a·lease·expires"

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

121	········:param·lease_duration:·seconds·~~of·mark~~er·stale~~ness~~·after·~~which·a·cont~~ender·may·take·the·claim.~~·Every·contender~~	122	········: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.	123	············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	124	········: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``.	125	············for·two·missed·refreshes·before·a·peer·may·take·the·claim.·Must·be·shorter·than·``lease_duration``·and·at
		126	············most·:data:`threading.TIMEOUT_MAX`.
Max diff block lines reached; 18842/25278 bytes (74.54%) of diff not shown.


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

		2	__lazy_modules__·=·["contextlib",·"filelock._identity",·"filelock._util",·"math"]

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

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

9	#:·Protocol·1·is·the·legacy·``<pid>\n<hostname>\n[<start_token>\n]``·marker·that·:class:`SoftFileLock`·still·writes.	11	#:·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	12	#:·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.	13	#:·and·evicts·it·after·its·grace·period,·so·the·two·never·guarantee·mutual·exclusion·against·each·other.
12	_PROTOCOL:·Final[str]·=·"filelock/2"	14	_PROTOCOL:·Final[str]·=·"filelock/2"

13	_MAX_PID:·Final[int]·=·2**31·-·1	15	_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"]~~	16	#:·The·forms·``repr``·gives·a·non-negative·finite·float·or·int;·``float()``·would·also·accept·whitespace,·underscores
		17	#:·and·non-ASCII·digits.
		18	_DURATION:·Final[re.Pattern[str]]·=·re.compile(r"[0-9]+(?:\.[0-9]+)?(?:e[+-][0-9]+)?",·re.ASCII)

		19	#:·Preserve·unknown·contracts·so·contenders·cannot·mistake·them·for·malformed,·reclaimable·markers.
		20	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):	21	class·MarkerSoftFileLock(SoftFileLock):
26	····"""An·existence·lock·whose·marker·carries·a·protocol·2·owner·record."""	22	····"""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~~.	23	····#:·Age-based·expiry·requires·a·lease·contract;·an·exclusive·holder·grants·none.
28	····_owner_mode:·OwnerMode	24	····_owner_mode:·OwnerMode·=·"exclusive"

29	····@property	25	····@property
30	····def·owner(self)·->·OwnerRecord·\|·None:	26	····def·owner(self)·->·OwnerRecord·\|·None:
31	········"""	27	········"""
32	········The·owner·named·by·the·marker·on·disk.	28	········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	29	········:returns:·the·published·record,·or·``None``·when·no·marker·exists·or·its·record·is·malformed·or·protocol·1
Offset 59, 61 lines modified		Offset 54, 99 lines modified
59	········return·None·if·(owner·:=·self._read_owner())·is·None·else·owner.pid	54	········return·None·if·(owner·:=·self._read_owner())·is·None·else·owner.pid

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

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

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

68	····def·force_break(self)·->·None:	63	····def·force_break(self)·->·None:
69	········"""	64	········"""
70	········Remove·the·marker·whoever·holds·it,·so·a·later·contender·can·acquire.	65	········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	66	········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.	67	········protects.·Reserve·it·for·an·operator·clearing·a·marker·whose·holder·is·known·to·be·gone.
73	········"""	68	········"""
74	········self.break_lock()	69	········self.break_lock()

		70	····def·_try_break_stale_lock(self)·->·None:
		71	········with·suppress(OSError,·ValueError),·pin_inode(self._lock_path)·as·pinned:
		72	············content,·marker·=·_read_lock_file(self._lock_path)
		73	············owner:·Final[OwnerRecord·\|·None]
		74	············if·pinned·not·in·{None,·marker.st_ino}:··#·pragma:·win32·no·cover··#·Windows·pins·nothing
		75	················return··#·replaced·before·the·read,·so·nothing·keeps·the·number·read·from·reuse
		76	············if·(owner·:=·parse_marker(content))·is·None:
		77	················super()._try_break_stale_lock()
		78	············elif·owner.mode·!=·"unknown"·and·owner_is_stale(owner.pid,·owner.hostname,·owner.start):
		79	················self._take_over(marker,·owner.pid)

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

		85	····@classmethod
		86	····def·_marker_is_live(cls,·content:·str·\|·None,·breaker_pid:·int)·->·bool:··#·pragma:·win32·no·cover
		87	········if·(owner·:=·parse_marker(content))·is·None:
		88	············return·super()._marker_is_live(content,·breaker_pid)
		89	········return·owner.mode·==·"unknown"·or·(
		90	············(owner.pid·!=·breaker_pid·or·owner.hostname·!=·host_name())
		91	············and·not·owner_is_stale(owner.pid,·owner.hostname,·owner.start)
		92	········)

75	····def·_read_owner(self)·->·OwnerRecord·\|·None:	93	····def·_read_owner(self)·->·OwnerRecord·\|·None:
76	········with·suppress(OSError,·ValueError):	94	········with·suppress(OSError,·ValueError):
77	············return·parse_marker(_read_lock_file(self.lock_~~file~~)[0])	95	············return·parse_marker(_read_lock_file(self._lock_path)[0])
78	········return·None	96	········return·None

79	····def·_write_lock_info(self,·fd:·int)·->·None:	97	····def·_write_lock_info(self,·fd:·int)·->·None:
80	········write_all(fd,·encode_marker(self._published_record()))	98	········write_all(fd,·encode_marker(self._published_record()))

81	····def·_published_record(self)·->·OwnerRecord:	99	····def·_published_record(self)·->·OwnerRecord:
82	········return·OwnerRecord(	100	········return·OwnerRecord(
83	············pid=os.getpid(),	101	············pid=os.getpid(),
84	············hostname=host_name(),	102	············hostname=host_name(),
85	············mode=self._owner_mode,	103	············mode=self._owner_mode,
86	············start=process_start_token(os.getpid()),	104	············start=process_start_token(os.getpid()),
87	········)	105	········)


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

		108	····pid:·int
		109	····hostname:·str
		110	····mode:·OwnerMode
		111	····token:·str·\|·None·=·None
		112	····lease_duration:·float·\|·None·=·None
Max diff block lines reached; 3521/9488 bytes (37.11%) of diff not shown.


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

		2	__lazy_modules__·=·[
		3	····"collections",
		4	····"filelock._error",
		5	····"filelock._identity",
		6	····"hashlib",
		7	····"itertools",
		8	····"pathlib",
		9	····"secrets",
		10	····"tempfile",
		11	]

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

12	from·._api·import·(	29	from·filelock._api·import·(
13	····AcquireReturnProxy,	30	····AcquireReturnProxy,
		31	····_acquire_thread_lock,
		32	····_canonical,
14	····_ensure_current_process,	33	····_ensure_current_process,
15	····_fork_transition,	34	····_fork_transition,
16	····_raise_chained_errors,	35	····_raise_chained_errors,
17	····_register_fork_class,	36	····_register_fork_class,
18	····_register_fork_object,	37	····_register_fork_object,
		38	····_register_owned_descriptor,
		39	····_resolve_lazy_imports_before_shutdown,
		40	····_resolve_read_write_timeout,
		41	····_seconds,
		42	····_timeout_behavior,
		43	····_unregister_owned_descriptor,
19	)	44	)
20	from·._error·import·Timeout	45	from·filelock._error·import·Timeout
		46	from·filelock._identity·import·host_name,·owner_is_stale,·process_start_token

		47	if·sys.platform·==·"win32":··#·pragma:·win32·cover
		48	····from·filelock._windows·import·(
		49	········_directory_is_private,
		50	········_identity_at,
		51	········_identity_of_fd,
		52	········_make_private_directory,
		53	········_open_non_reparse_fd,
		54	········_pinned,
		55	····)

21	if·TYPE_CHECKING:	56	if·TYPE_CHECKING:
22	····from·collections.abc·import·Callable,·Generator	57	····from·collections.abc·import·Callable,·Generator
		58	····from·typing·import·Self

		59	····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")	60	_LOGGER:·Final[logging.Logger]·=·logging.getLogger("filelock")
28	_GETPID:·Final[Callable[[],·int]]·=·os.getpid	61	_GETPID:·Final[Callable[[],·int]]·=·os.getpid
29	_IS_PYPY:·Final[bool]·=·sys.implementation.name·==·"pypy"	62	_IS_PYPY:·Final[bool]·=·sys.implementation.name·==·"pypy"
30	_NEEDS_CONNECTION_ESCROW:·Final[bool]·=·(	63	_NEEDS_CONNECTION_ESCROW:·Final[bool]·=·(
31	····hasattr(os,·"register_at_fork")·and·sys.implementation.name·==·"cpython"·and·sys.version_info·<·(3,·12)	64	····hasattr(os,·"register_at_fork")·and·sys.implementation.name·==·"cpython"·and·sys.version_info·<·(3,·12)
32	)	65	)
33	_ConnectionParameter:·TypeAlias·=·(	66	_ConnectionParameter:·TypeAlias·=·(
34	····str·\|·bytes·\|·os.PathLike[str]·\|·os.PathLike[bytes]·\|·float·\|·int·\|·type[sqlite3.Connection]·\|·None	67	····str·\|·bytes·\|·os.PathLike[str]·\|·os.PathLike[bytes]·\|·float·\|·int·\|·type[sqlite3.Connection]·\|·None
35	)	68	)
36	_DatabaseIdentity:·TypeAlias·=·tuple[int,·int]	69	_DatabaseIdentity:·TypeAlias·=·tuple[int,·int]

37	#·sqlite3_busy_timeout()·accepts·a·C·int,·max·2_147_483_647·on·32-bit.·Use·a·lower·value·to·be·safe·(~23·days).	70	#·sqlite3_busy_timeout()·accepts·a·C·int,·max·2_147_483_647·on·32-bit.·Use·a·lower·value·to·be·safe·(~23·days).
38	_MAX_SQLITE_TIMEOUT_MS:·Final[int]·=·2_000_000_000·-·1	71	_MAX_SQLITE_TIMEOUT_MS:·Final[int]·=·2_000_000_000·-·1
		72	#·How·long·a·wait·that·its·caller·may·abandon·runs·before·it·checks·whether·it·should·stop.
		73	_CANCEL_POLL_INTERVAL:·Final[float]·=·0.1
39	_UNSAFE_FORK_EXIT_STATUS:·Final[int]·=·70	74	_UNSAFE_FORK_EXIT_STATUS:·Final[int]·=·70
		75	#:·The·longest·a·contended·acquisition·waits·for·the·database·inside·one·fork·transition,·in·seconds.
		76	_MAX_TRANSITION_WAIT:·Final[float]·=·0.05
		77	#·O_NONBLOCK·keeps·an·open·from·blocking·on·a·FIFO·planted·at·the·path;·the·regular-file·check·then·rejects·it.
		78	_DB_OPEN_FLAGS:·Final[int]·=·os.O_RDWR·\|·os.O_CREAT·\|·getattr(os,·"O_NOFOLLOW",·0)·\|·getattr(os,·"O_NONBLOCK",·0)
		79	_DIRECTORY_FLAGS:·Final[int]·=·os.O_RDONLY·\|·getattr(os,·"O_DIRECTORY",·0)·\|·getattr(os,·"O_NOFOLLOW",·0)
		80	#·Header·bytes·18·and·19·hold·the·file·format·versions,·2·in·WAL·mode:·https://www.sqlite.org/fileformat.html
		81	_SQLITE_MAGIC:·Final[bytes]·=·b"SQLite·format·3\x00"
		82	_FORMAT_VERSIONS:·Final[slice]·=·slice(18,·20)
		83	_HEADER_SIZE:·Final[int]·=·20
		84	_WAL_FORMAT_VERSION:·Final[int]·=·2


40	class·_SQLiteTransitionContext(threading.local):	85	class·_SQLiteTransitionContext(threading.local):
41	····depth:·int·=·0	86	····depth:·int·=·0


42	_SQLITE_TRANSITION_CONTEXT:·Final·=·_SQLiteTransitionContext()	87	_SQLITE_TRANSITION_CONTEXT:·Final·=·_SQLiteTransitionContext()
Offset 130, 54 lines modified		Offset 177, 203 lines modified
130	········except·OSError:	177	········except·OSError:
131	············return·None	178	············return·None
132	········return·stat_result.st_dev,·stat_result.st_ino	179	········return·stat_result.st_dev,·stat_result.st_ino


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

		181	_LINK_PREFIX:·Final[str]·=·".filelock-"
		182	_LINK_NAME:·Final[str]·=·"lock.db"
		183	_SWEPT_DATABASES:·Final[set[_DatabaseIdentity]]·=·set()


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

		193	····def·adopt(self,·database:·str,·claimed:·list[_Probe])·->·_Probe·\|·None:··#·pragma:·win32·no·cover
Max diff block lines reached; 59914/68691 bytes (87.22%) of diff not shown.


Offset 1, 27 lines modified		Offset 1, 63 lines modified
1	from·__future__·import·annotations	1	from·__future__·import·annotations

		2	__lazy_modules__·=·[
		3	····"contextlib",
		4	····"filelock._identity",
		5	····"filelock._soft_protocol",
		6	····"filelock._util",
		7	····"itertools",
		8	····"pathlib",
		9	····"re",
		10	····"secrets",
		11	····"typing",
		12	]

2	import·os	13	import·os
		14	import·re
		15	import·secrets
3	import·stat	16	import·stat
4	import·sys	17	import·sys
		18	import·threading
5	import·time	19	import·time
6	from·contextlib·import·suppress	20	from·contextlib·import·suppress
7	from·errno·import·EACCES,·EEXIST,·EPERM	21	from·errno·import·EACCES,·EEXIST,·EPERM
		22	from·itertools·import·islice
8	from·pathlib·import·Path	23	from·pathlib·import·Path
9	from·typing·import·Final	24	from·typing·import·Final

10	from·._api·import·BaseFileLock,·_raise_grouped_errors	25	from·filelock._api·import·BaseFileLock,·_raise_grouped_errors
11	from·._identity·import·host_name,·owner_is_stale,·process_start_token	26	from·filelock._identity·import·host_name,·owner_is_current_process,·owner_is_stale,·process_start_token
12	from·._soft_protocol·import·STRICT_SOFT_SENTINEL_RECORD	27	from·filelock._soft_protocol·import·STRICT_SOFT_SENTINEL_RECORD
13	from·~~._u~~til~~·import·br~~e~~ak_~~lock~~_file,·ensur~~e_~~dire~~ct~~ory_ex~~i~~sts~~,·rai~~se_on~~_no~~t_w~~rit~~able_file,~~·~~write_al~~l	28	from·filelock._util·import·(
		29	····break_lock_file,
		30	····exchange_names,
		31	····exchange_supported,
		32	····pin_inode,
		33	····raise_on_not_writable_file,
		34	····remove_own_file,
		35	····write_all,
		36	)

		37	if·sys.platform·==·"win32":··#·pragma:·win32·cover
		38	····from·filelock._windows·import·open_read_without_oplock_wait
		39	····from·filelock._windows·import·unlink_without_oplock_wait·as·unlink_path
		40	else:··#·pragma:·win32·no·cover
		41	····from·filelock._util·import·unlink_path

14	_MALFORMED_LOCK_AGE_THRESHOLD:·Final[float]·=·2.0	42	MALFORMED_LOCK_AGE_THRESHOLD:·Final[float]·=·2.0
15	_MAX_LOCK_FILE_SIZE:·Final[int]·=·1024	43	_MAX_LOCK_FILE_SIZE:·Final[int]·=·1024
16	_UNLINK_MAX_RETRIES:·Final[int]·=·10	44	_UNLINK_MAX_RETRIES:·Final[int]·=·10
17	_MARKER_WITH_START_TOKEN_LINE_COUNT:·Final[int]·=·3	45	_MARKER_WITH_START_TOKEN_LINE_COUNT:·Final[int]·=·3
		46	#:·Contenders·act·on·the·record·in·the·marker,·so·no·other·account·may·write·it,·whatever·the·mode·or·umask.
		47	_OTHERS_WRITE:·Final[int]·=·stat.S_IWGRP·\|·stat.S_IWOTH
		48	#:·All·a·SoftFileLock·before·3.22·writes,·and·what·a·current·one·shows·between·creating·its·marker·and·writing·it.
		49	_RECORDLESS_MARKER:·Final[str]·=·""
		50	_CLAIMS_IN_PROGRESS:·Final[set[str]]·=·set()
		51	_CLAIMS_LOCK:·Final[threading.Lock]·=·threading.Lock()


18	class·SoftFileLock(BaseFileLock):	52	class·SoftFileLock(BaseFileLock):
19	····"""	53	····"""
20	····Cooperative·file·lock·based·on·a·shared·existence·marker.	54	····Cooperative·file·lock·based·on·a·shared·existence·marker.

21	····Unlike·:class:`UnixFileLock·<filelock.UnixFileLock>`·and·:class:`WindowsFileLock·<filelock.WindowsFileLock>`,·this	55	····Unlike·:class:`UnixFileLock·<filelock.UnixFileLock>`·and·:class:`WindowsFileLock·<filelock.WindowsFileLock>`,·this
Offset 44, 68 lines modified		Offset 80, 277 lines modified

44	····#:·An·existence·lock·unlinks·its·marker·to·release,·so·it·cannot·promise·to·keep·the·pathname.	80	····#:·An·existence·lock·unlinks·its·marker·to·release,·so·it·cannot·promise·to·keep·the·pathname.
45	····_preserve_lock_file_supported:·bool·=·False	81	····_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.	82	····#:·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	83	····_on_acquired_supported:·bool·=·False

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

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

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

48	····def·_acquire(self)·->·None:	90	····def·_acquire(self)·->·None:
		91	········self._finish_marker_cleanup()
49	········raise_on_not_writable_file(self.lock_~~file~~)	92	········raise_on_not_writable_file(self._lock_path)
50	········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	93	········#·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.	94	········#·means·this·process·now·holds·the·lock.
53	········flags·=·os.O_WRONLY·\|·os.O_CREAT·\|·os.O_EXCL·\|·os.O_TRUNC	95	········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	96	········if·(o_nofollow·:=·getattr(os,·"O_NOFOLLOW",·None))·is·not·None:··#·pragma:·needs·o-nofollow
55	············flags·\|=·o_nofollow	97	············flags·\|=·o_nofollow
56	········try:	98	········try:
57	············fd·=·os.open(self.lock_~~file~~,·flags,·self._open_mode())	99	············fd·=·os.open(self._lock_path,·flags,·self._open_mode()·&·~_OTHERS_WRITE)
58	········except·OSError·as·exception:	100	········except·OSError·as·exception:
59	············if·not·(	101	············if·not·(
60	················exception.errno·==·EEXIST·or·(exception.errno·==·EACCES·and·sys.platform·==·"win32")	102	················exception.errno·==·EEXIST·or·(exception.errno·==·EACCES·and·sys.platform·==·"win32")
61	············):··#·pragma:·win32·no·cover	103	············):··#·pragma:·win32·no·cover
62	················raise	104	················raise
63	············self._try_break_stale_lock()	105	············self._try_break_stale_lock()
64	············return	106	············return
65	········self._mark_descriptor_pending(fd)
66	········self._publish_held_marker(fd)

67	····def·_publish_held_marker(self,·fd:·int)·->·None:
68	········#·Publish·held·state·only·once·the·record·is·~~fully·~~on·disk.·O~~n·a~~ny·failure,·including·cancella~~tion~~,·close·the	107	········#·Publish·held·state·only·once·the·record·is·on·disk.·On·failure,·cancellation·included,·close·the·descriptor
69	········#·descriptor·and·unlink·the·path·only·while·it·still·names·the·file·we·opened,·so·a·rollback·never·deletes·a
70	········#·su~~ccessor's~~·marker·~~that~~·~~rep~~l~~aced~~·~~ours~~·at·the·~~sam~~e·p~~ath~~·after·our·lease·e~~xpi~~red.	108	········#·and·unlink·the·path·only·while·it·still·names·the·file·we·opened:·after·an·expired·lease·a·successor's
		109	········#·marker·may·sit·at·the·same·path.·The·guard·starts·at·the·open,·so·a·signal·handler·that·raises·before
		110	········#·_mark_descriptor_owned·leaves·no·marker·behind.
71	········identity:·tuple[int,·int]·\|·None·=·None	111	········identity:·tuple[int,·int]·\|·None·=·None
72	········try:	112	········try:
73	············identity·=·_file_identity(os.fstat(fd))	113	············identity·=·_file_identity(os.fstat(fd))
		114	············self._mark_descriptor_pending(fd)
		115	············self._apply_explicit_mode(fd)
74	············self._write_lock_info(fd)	116	············self._write_lock_info(fd)
		117	············self._mark_descriptor_owned(fd,·identity)
75	········except·BaseException:	118	········except·BaseException:
76	············self._mark_descriptor_released()	119	············self._mark_descriptor_released()
77	············~~os.close(fd)~~	120	············try:
		121	················if·sys.platform·!=·"win32":··#·pragma:·win32·no·cover
		122	····················#·Before·the·close:·our·open·descriptor·keeps·the·inode·allocated,·so·a·successor's·marker·cannot
		123	····················#·carry·its·number.
78	············with·suppress(OSError):	124	····················with·suppress(OSError):
79	················if·identity·is·not·None·and·_file_identity(os.lstat(self.lock_file))·==·identity:
80	····················~~Path(self.l~~ock_file~~).un~~link()	125	························remove_own_file(self._lock_path,·fd)
		126	············finally:
		127	················try:
		128	····················os.close(fd)
		129	················finally:
Max diff block lines reached; 30656/36960 bytes (82.94%) of diff not shown.


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

		2	__lazy_modules__·=·["typing"]

2	from·typing·import·Final	3	from·typing·import·Final

3	STRICT_SOFT_SENTINEL_RECORD:·Final[str]·=·"1\nfilelock-strict-v1\x00\n0\n"	4	STRICT_SOFT_SENTINEL_RECORD:·Final[str]·=·"1\nfilelock-strict-v1\x00\n0\n"

4	__all__·=·[	5	__all__·=·[
5	····"STRICT_SOFT_SENTINEL_RECORD",	6	····"STRICT_SOFT_SENTINEL_RECORD",
6	]	7	]


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

		2	__lazy_modules__·=·[
		3	····"contextlib",
		4	····"filelock._error",
		5	····"filelock._identity",
		6	····"filelock._marker",
		7	····"filelock._soft",
		8	····"filelock._util",
		9	····"functools",
		10	····"pathlib",
		11	····"secrets",
		12	····"tempfile",
		13	]

2	import·contextlib	14	import·contextlib
3	import·errno	15	import·errno
		16	import·functools
4	import·os	17	import·os
5	import·secrets	18	import·secrets
6	import·stat	19	import·stat
7	import·sys	20	import·sys
8	import·tempfile	21	import·tempfile
9	import·time	22	import·time
10	from·dataclasses·import·dataclass	23	from·dataclasses·import·dataclass
11	from·errno·import·EACCES,·EEXIST,·ENOENT,·ENOSYS,·EPERM,·ESTALE,·EXDEV	24	from·errno·import·EACCES,·EEXIST,·ENOENT,·ENOSYS,·EPERM,·ESTALE,·EXDEV
12	from·pathlib·import·Path	25	from·pathlib·import·Path
13	from·typing·import·TYPE_CHECKING,·Final,·Literal,·cast	26	from·typing·import·TYPE_CHECKING,·Final,·Literal,·cast

14	from·._api·import·BaseFileLock,·_canonical,·_raise_cleanup_errors	27	from·filelock._api·import·BaseFileLock,·ThreadLocalFileContext,·_canonical,·_raise_cleanup_errors
15	from·._error·import·SoftFileLockProtocolError	28	from·filelock._error·import·SoftFileLockProtocolError
16	from·._identity·import·host_name,·process_start_token	29	from·filelock._identity·import·host_name,·owner_is_stale,·process_start_token
		30	from·filelock._marker·import·parse_marker
		31	from·filelock._soft·import·MALFORMED_LOCK_AGE_THRESHOLD,·_parse_lock_holder
17	from·._soft_protocol·import·STRICT_SOFT_SENTINEL_RECORD	32	from·filelock._soft_protocol·import·STRICT_SOFT_SENTINEL_RECORD
18	from·._util·import·~~ensure~~_directory_e~~xists~~,·write_all	33	from·filelock._util·import·foreign_directory_owner,·write_all

		34	if·sys.platform·==·"win32":··#·pragma:·win32·cover
		35	····from·filelock._windows·import·_is_unlinked,·_open_deletable_for_reading,·_pin_directory,·_unpin_directory

19	if·TYPE_CHECKING:	36	if·TYPE_CHECKING:
20	····from·collections.abc·import·Iterator	37	····from·collections.abc·import·Callable,·Iterator

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

22	_CLAIM_STATES:·Final[frozenset[str]]·=·frozenset({"intent",·"held"})	40	_CLAIM_STATES:·Final[frozenset[str]]·=·frozenset({"intent",·"held"})
23	_COORDINATION_SUFFIX:·Final[str]·=·".filelock"	41	_COORDINATION_SUFFIX:·Final[str]·=·".filelock"
24	_CLAIM_DIRECTORY_NAME:·Final[str]·=·"claims"	42	_CLAIM_DIRECTORY_NAME:·Final[str]·=·"claims"
25	_CLAIM_MAGIC:·Final[str]·=·"filelock-strict-v1"	43	_CLAIM_MAGIC:·Final[str]·=·"filelock-strict-v1"
26	_CLAIM_RECORD_LIMIT:·Final[int]·=·1024	44	_CLAIM_RECORD_LIMIT:·Final[int]·=·1024
27	_CLAIM_NAME_PART_COUNT:·Final[int]·=·3	45	_CLAIM_NAME_PART_COUNT:·Final[int]·=·3
Offset 35, 14 lines modified		Offset 55, 17 lines modified
35	_PRIVATE_RECORD_SUFFIX:·Final[str]·=·".tmp"	55	_PRIVATE_RECORD_SUFFIX:·Final[str]·=·".tmp"
36	_PRIVATE_RECORD_RANDOM_HEX_LENGTH:·Final[int]·=·32	56	_PRIVATE_RECORD_RANDOM_HEX_LENGTH:·Final[int]·=·32
37	_PRIVATE_RECORD_GRACE:·Final[float]·=·2.0	57	_PRIVATE_RECORD_GRACE:·Final[float]·=·2.0
38	_UNLINK_MAX_RETRIES:·Final[int]·=·10	58	_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.	59	#:·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	60	_CLAIM_READ_GRACE:·Final[float]·=·0.5
41	_CLAIM_READ_RETRY:·Final[float]·=·0.002	61	_CLAIM_READ_RETRY:·Final[float]·=·0.002
		62	#:·Rides·out·a·peer·replacing·the·lock·path·mid-inspection;·a·foreign·node·or·unreadable·record·outlasting·it·is·damage.
		63	_SENTINEL_READ_GRACE:·Final[float]·=·0.5
		64	_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.	65	#:·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.	66	#:·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)	67	_O_BINARY:·Final[int]·=·getattr(os,·"O_BINARY",·0)
45	_LEGACY_SENTINEL:·Final[bytes]·=·STRICT_SOFT_SENTINEL_RECORD.encode()	68	_LEGACY_SENTINEL:·Final[bytes]·=·STRICT_SOFT_SENTINEL_RECORD.encode()
46	_WINDOWS_HARD_LINK_UNSUPPORTED:·Final[frozenset[int]]·=·frozenset({1,·17,·50})	69	_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	70	#·Termux/Android·CPython·ships·without·os.link·(bionic·long·had·only·linkat),·so·the·strict·backend's·whole·hard-link
Offset 52, 14 lines modified		Offset 75, 16 lines modified

52	#·Probe·dir_fd·capability·once·at·import.·A·per-call·``os.unlink·in·os.supports_dir_fd``·check·flips·to·False·the·moment	75	#·Probe·dir_fd·capability·once·at·import.·A·per-call·``os.unlink·in·os.supports_dir_fd``·check·flips·to·False·the·moment
53	#·a·test·mocks·os.unlink,·silently·diverting·the·code·to·a·different·branch·than·the·one·under·test.	76	#·a·test·mocks·os.unlink,·silently·diverting·the·code·to·a·different·branch·than·the·one·under·test.
54	_OPEN_SUPPORTS_DIR_FD:·Final[bool]·=·os.open·in·os.supports_dir_fd	77	_OPEN_SUPPORTS_DIR_FD:·Final[bool]·=·os.open·in·os.supports_dir_fd
55	_UNLINK_SUPPORTS_DIR_FD:·Final[bool]·=·os.unlink·in·os.supports_dir_fd	78	_UNLINK_SUPPORTS_DIR_FD:·Final[bool]·=·os.unlink·in·os.supports_dir_fd
56	_STAT_SUPPORTS_DIR_FD:·Final[bool]·=·os.stat·in·os.supports_dir_fd	79	_STAT_SUPPORTS_DIR_FD:·Final[bool]·=·os.stat·in·os.supports_dir_fd
57	_LINK_SUPPORTS_DIR_FD:·Final[bool]·=·_HAS_LINK·and·os.link·in·os.supports_dir_fd	80	_LINK_SUPPORTS_DIR_FD:·Final[bool]·=·_HAS_LINK·and·os.link·in·os.supports_dir_fd
		81	_MKDIR_SUPPORTS_DIR_FD:·Final[bool]·=·os.mkdir·in·os.supports_dir_fd
		82	_SCANDIR_SUPPORTS_FD:·Final[bool]·=·os.scandir·in·os.supports_fd


58	def·_probe_link_follow_symlinks()·->·bool:	83	def·_probe_link_follow_symlinks()·->·bool:
59	····#·os.supports_follow_symlinks·lists·os.link·on·PyPy,·but·its·linkat·then·rejects·follow_symlinks=False·with·EINVAL,	84	····#·os.supports_follow_symlinks·lists·os.link·on·PyPy,·but·its·linkat·then·rejects·follow_symlinks=False·with·EINVAL,
60	····#·and·Windows·raises·NotImplementedError·for·the·option·outright.·Link·a·throwaway·file·for·real·so·the·answer	85	····#·and·Windows·raises·NotImplementedError·for·the·option·outright.·Link·a·throwaway·file·for·real·so·the·answer
61	····#·reflects·the·runtime·rather·than·its·advertisement,·and·treat·any·failure·as·"not·honored":·the·option·only	86	····#·reflects·the·runtime·rather·than·its·advertisement,·and·treat·any·failure·as·"not·honored":·the·option·only
62	····#·hardens·a·source·this·process·created·with·O_EXCL,·so·skipping·it·is·safe,·and·a·real·environment·fault·surfaces	87	····#·hardens·a·source·this·process·created·with·O_EXCL,·so·skipping·it·is·safe,·and·a·real·environment·fault·surfaces
Offset 97, 166 lines modified		Offset 122, 230 lines modified

97	····_preserve_lock_file_supported:·bool·=·True	122	····_preserve_lock_file_supported:·bool·=·True
98	····_on_acquired_supported:·bool·=·False	123	····_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	124	····#:·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.	125	····#:·out,·so·only·force_break()·removes·it.
101	····_lifetime_supported:·bool·=·False	126	····_lifetime_supported:·bool·=·False
102	····_lifetime_unsupported_reason:·str·=·"a·strict·claim·is·never·broken·by·age,·only·by·force_break()"	127	····_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	128	····#:·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~~.	129	····#:·poll_interval·below·this·cap·jitters;·the·default·equals·it·and·keeps·a·fixed·cadence.
107	····_poll_backoff_cap:·float·=·0.05	130	····_poll_backoff_cap:·float·=·0.05
		131	····_occupant_seen:·tuple[tuple[float,·int,·int],·float]·\|·None·=·None
		132	····#:·Set·by·the·finalizer,·after·which·no·retry·of·a·failed·cleanup·can·run.
		133	····_finalizing:·bool·=·False

108	····def·_acquire(self)·->·None:	134	····def·_acquire(self)·->·None:
		135	········#·Finish·a·doorway·whose·claim·cleanup·failed·before·publishing,·so·this·owner·never·contends·with·leftovers.
		136	········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
110	········#·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:
112	············claim_root·=·self._context.claim_root·=·_canonical(self.lock_file)
113	········lock_path·=·Path(~~claim~~_root)	137	········lock_path·=·Path(self._lock_path)
114	········coordination_directory·=·Path(f"{lock_path}{_COORDINATION_SUFFIX}")	138	········coordination_directory·=·Path(f"{lock_path}{_COORDINATION_SUFFIX}")
115	········claim_directory·=·coordination_directory·/·_CLAIM_DIRECTORY_NAME	139	········claim_directory·=·coordination_directory·/·_CLAIM_DIRECTORY_NAME
116	········ensure_directory_exists~~(os.fsp~~ath(lock~~_path))~~	140	········#·A·process·that·can·write·these·directories·can·remove·claims·from·them,·so·they·take·the·lock's·mode·plus
		141	········#·search·permission·where·the·mode·grants·read.
		142	········directory_mode:·Final·=·(mode·:=·self._open_mode())·\|·(mode·&·0o444)·>>·2
117	········_ensure_protocol_directory(self.lock_file,·coordination_directory)	143	········_ensure_protocol_directory(self.lock_file,·coordination_directory,·directory_mode)
118	········_ensure_~~protocol~~_directory(self.lock_file,·claim_directory)	144	········_ensure_claim_directory(self.lock_file,·claim_directory,·directory_mode)
119	········if·(~~sentinel_fd·:=·_open_or_create_sentinel(self.lock_file,·lock_path,·self._open_mode()))·is·None:~~	145	········if·(
		146	············sentinel_fd·:=·_open_or_create_sentinel(
		147	················self.lock_file,·lock_path,·self._open_mode(),·self._occupant_unchanged_for
		148	············)
		149	········)·is·None:
120	············return	150	············return
121	········try:	151	········try:
122	············sentinel_identity·=·_file_identity(os.fstat(sentinel_fd))	152	············sentinel_identity·=·_file_identity(os.fstat(sentinel_fd))
Max diff block lines reached; 50467/58145 bytes (86.80%) of diff not shown.


Offset 1, 19 lines modified		Offset 1, 21 lines modified
1	from·__future__·import·annotations	1	from·__future__·import·annotations

		2	__lazy_modules__·=·["contextlib",·"filelock._util",·"pathlib",·"typing",·"warnings"]

2	import·os	3	import·os
3	import·sys	4	import·sys
4	import·warnings	5	import·warnings
5	from·contextlib·import·suppress	6	from·contextlib·import·suppress
6	from·errno·import·EACCES,·EAGAIN,·ENOSYS,·EWOULDBLOCK	7	from·errno·import·EACCES,·EAGAIN,·ENOSYS,·EWOULDBLOCK
7	from·pathlib·import·Path	8	from·pathlib·import·Path
8	from·typing·import·Final,·cast	9	from·typing·import·Final,·cast

9	from·._api·import·BaseFileLock	10	from·filelock._api·import·BaseFileLock
10	from·._util·import·~~ensu~~re_~~dir~~ectory_exists	11	from·filelock._util·import·remove_own_file

11	has_fcntl·=·False	12	has_fcntl·=·False
12	if·sys.platform·==·"win32":··#·pragma:·win32·cover	13	if·sys.platform·==·"win32":··#·pragma:·win32·cover

13	····class·UnixFileLock(BaseFileLock):	14	····class·UnixFileLock(BaseFileLock):
14	········"""Uses·the·:func:`fcntl.flock`·to·hard·lock·the·lock·file·on·unix·systems."""	15	········"""Uses·the·:func:`fcntl.flock`·to·hard·lock·the·lock·file·on·unix·systems."""

Offset 53, 124 lines modified		Offset 55, 154 lines modified
53	····················return·False	55	····················return·False
54	················raise	56	················raise
55	············return·True	57	············return·True

56	········def·_unlock_fd(fd:·int)·->·None:	58	········def·_unlock_fd(fd:·int)·->·None:
57	············fcntl.flock(fd,·fcntl.LOCK_UN)	59	············fcntl.flock(fd,·fcntl.LOCK_UN)

		60	····def·_flock_is_missing(fd:·int)·->·bool:
		61	········try:
		62	············_lock_fd_nonblocking(fd)
		63	········except·OSError·as·exception:
		64	············return·exception.errno·==·ENOSYS
		65	········return·False··#·a·flock·the·probe·won·is·released·when·the·caller·closes·fd

58	····class·UnixFileLock(BaseFileLock):	66	····class·UnixFileLock(BaseFileLock):
59	········"""	67	········"""
60	········Uses·the·:func:`fcntl.flock`·to·hard·lock·the·lock·file·on·unix·systems.	68	········Uses·the·:func:`fcntl.flock`·to·hard·lock·the·lock·file·on·unix·systems.

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

65	········def·_acquire(self)·->·None:	73	········def·_acquire(self)·->·None:
66	············missing_flock·=·self._acquire_native()	74	············if·(missing_flock·:=·self._acquire_native())·is·not·None:
67	············if·missing_flock·is·not·None:
68	················~~sel~~f.~~_swit~~ch_to_soft_lock(*missing_flock)	75	················fd,·exception,·created·=·missing_flock
		76	················self._switch_to_soft_lock(fd,·exception,·created=created)

69	········def·_acquire_native(self)·->·tuple[int,·OSError]·\|·None:	77	········def·_acquire_native(self)·->·tuple[int,·OSError,·bool]·\|·None:
70	············ensure_directory_exists(self.lock_file)
71	············#·Open·without·O_TRUNC·and·defer·truncation·and·fchmod·until·after·flock·succeeds:·a·contender·that·loses
72	············#·the·lock·must·not·truncate·the·holder's·file·(erasing·caller·diagnostics)·or·change·its·mode.·The·winner
73	············#~~·truncat~~es·and·~~normaliz~~e~~s·m~~o~~de·onc~~e~~·it~~·owns~~·the~~·lo~~ck·(#591).~~	78	············if·(opened·:=·self._open_lock_file())·is·None:
		79	················return·None
		80	············fd,·created·=·opened
		81	············self._mark_descriptor_pending(fd)
		82	············if·created:
		83	················#·Before·the·flock:·a·peer·may·win·it·first,·and·only·the·creator·may·set·the·mode.·Outside·the·flock
		84	················#·handler·below:·an·fchmod·that·answers·ENOSYS·says·nothing·about·flock.
		85	················try:
		86	····················self._apply_explicit_mode(fd)
		87	················except·BaseException:
		88	····················self._mark_descriptor_released()
		89	····················os.close(fd)
		90	····················raise
		91	············#·One·guard·covers·the·flock·through·the·recording·of·the·hold.·A·signal·handler·that·raises·in·between
		92	············#·would·otherwise·leave·an·unreferenced·descriptor,·and·its·flock,·open·until·the·process·exits.
		93	············locked·=·False
		94	············try:
		95	················locked·=·_lock_fd_nonblocking(fd)
		96	················if·locked·and·self._finalize_locked_fd(fd):
		97	····················return·None
		98	············except·BaseException·as·exception:
		99	················if·not·locked·and·isinstance(exception,·OSError)·and·exception.errno·==·ENOSYS:
		100	····················return·fd,·exception,·created
		101	················#·Contention·returns·False·from·_lock_fd_nonblocking,·so·a·raise·here·is·a·failure.
		102	················self._mark_descriptor_released()
		103	················os.close(fd)
		104	················raise
		105	············self._mark_descriptor_released()
		106	············os.close(fd)··#·contention·or·an·unlinked·inode;·let·the·retry·loop·try·again
		107	············return·None

		108	········def·_open_lock_file(self)·->·tuple[int,·bool]·\|·None:
		109	············#·No·O_TRUNC:·a·contender·that·loses·the·flock·must·not·truncate·the·holder's·file·(#591),·and·neither·may
		110	············#·the·winner,·since·a·file·renamed·or·hard-linked·to·the·lock·path·is·indistinguishable·from·a·lock·file.
		111	············#·O_EXCL·tells·whether·this·attempt·created·the·inode:·only·then·does·it·get·the·explicit·mode,·and·the
		112	············#·ENOSYS·fallback·removes·only·its·own·placeholder.·O_NONBLOCK:·a·lease·(Linux·F_SETLEASE)·on·the·file·would
		113	············#·otherwise·block·the·open·for·up·to·fs.lease-break-time,·beyond·timeout,·blocking=False·and·cancel_check.
74	············open_flags·=·os.O_RDWR	114	············open_flags·=·os.O_RDWR·\|·os.O_NONBLOCK
75	············if·(o_nofollow·:=·getattr(os,·"O_NOFOLLOW",·None))·is·not·None:	115	············if·(o_nofollow·:=·getattr(os,·"O_NOFOLLOW",·None))·is·not·None:
76	················open_flags·\|=·o_nofollow	116	················open_flags·\|=·o_nofollow
77	············open_flags·\|=·os.O_CREAT
78	············open_mode·=·self._open_mode()	117	············open_mode·=·self._open_mode()
79	············try:	118	············try:
80	················~~fd·=~~·os.open(self.lock_~~file~~,·open_flags,·open_mode)	119	················return·os.open(self._lock_path,·open_flags·\|·os.O_CREAT·\|·os.O_EXCL,·open_mode),·True
		120	············except·FileExistsError:
		121	················pass
81	············except·FileNotFoundError:	122	············except·FileNotFoundError:
82	················#·On·FUSE/NFS,·os.open(O_CREAT)·is·not·atomic;·a·split·LOOKUP·+·CREATE·lets·a·concurrent·unlink()
83	················#·delete·the·file·between·them.·For·a·valid·path,·treat·ENOENT·as·transient·contention.·For·an
84	················#·invalid·path·(e.g.·empty·string),·re-raise·to·avoid·an·infinite·retry·loop.
85	················if·sel~~f.lock_fi~~le·a~~nd·Path(self.~~lock~~_fil~~e~~).pa~~rent~~.ex~~ists~~():~~	123	················#·On·FUSE/NFS·a·split·LOOKUP·+·CREATE·lets·a·concurrent·unlink()·race·the·create,·so·ENOENT·is·transient
		124	················#·contention.·An·empty·or·separator-terminated·path·(Path()·strips·the·separator)·fails·this·way·on
		125	················#·every·attempt·on·macOS,·so·re-raise·rather·than·retry·forever.
		126	················if·self._lock_path·and·not·self._lock_path.endswith(os.sep)·and·Path(self._lock_path).parent.exists():
86	····················return·None	127	····················return·None
87	················raise	128	················raise
88	············except·PermissionError:	129	············except·PermissionError:
89	················#·Sticky-bit·dirs·(e.g.·/tmp):·O_CREAT·fails·if·the~~·fil~~e·is·own~~ed·b~~y·~~ano~~ther·~~user~~·(#317).	130	················#·Sticky-bit·dirs·(e.g.·/tmp):·O_CREAT·fails·if·another·user·owns·the·file·(#317).
90	················#·Fall·back·to·opening·the·existing·file·without·O_CREAT.
91	················if·not·Path(self.lock_~~file~~).exists():	131	················if·not·Path(self._lock_path).exists():
92	····················raise	132	····················raise
		133	············return·self._open_existing_lock_file(open_flags,·open_mode)

		134	········def·_open_existing_lock_file(self,·open_flags:·int,·open_mode:·int)·->·tuple[int,·bool]·\|·None:
		135	············try:
		136	················return·os.open(self._lock_path,·open_flags,·open_mode),·False
		137	············except·FileNotFoundError:
		138	················return·None··#·unlinked·since·the·create·attempt;·let·the·retry·loop·start·over
		139	············except·BlockingIOError:
		140	················return·None··#·a·lease·is·breaking:·contention,·so·the·retry·loop·keeps·the·deadline
		141	············except·PermissionError:
		142	················#·A·marker·another·account·left·is·readable·but·not·writable.·Without·flock,·waiting·on·it·only·needs
Max diff block lines reached; 6442/13888 bytes (46.39%) of diff not shown.


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

		2	__lazy_modules__·=·["pathlib",·"platform",·"secrets"]

		3	import·errno
2	import·os	4	import·os
		5	import·platform
3	import·secrets	6	import·secrets
4	import·stat	7	import·stat
5	import·sys	8	import·sys
		9	from·contextlib·import·contextmanager,·suppress
6	from·errno·import·EACCES,·EIO,·EISDIR	10	from·errno·import·EACCES,·EINVAL,·EIO,·EISDIR,·ENOSYS,·EXDEV
		11	from·functools·import·cache
7	from·pathlib·import·Path	12	from·pathlib·import·Path
8	from·typing·import·Final	13	from·typing·import·TYPE_CHECKING,·Final,·cast

		14	if·TYPE_CHECKING:
		15	····import·ctypes
		16	····from·collections.abc·import·Callable,·Generator
		17	····from·contextlib·import·AbstractContextManager


9	def·write_all(fd:·int,·data:·bytes)·->·None:	18	def·write_all(fd:·int,·data:·bytes)·->·None:
10	····"""	19	····"""
11	····Write·the·whole·buffer·to·fd,·looping·over·the·short·writes·~~``os.wri~~te``·is·~~allow~~ed·to·make.	20	····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.~~	21	····A·caller·that·stopped·after·one·short·write·would·leave·a·truncated·marker·behind.·A·peer·that·reads·between·two
		22	····writes·sees·a·prefix·of·the·record;·each·caller·has·to·tolerate·that.·Lock·records·need·not·survive·a·power·loss,·so
		23	····we·skip·``fsync``.

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

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

18	····"""	27	····"""
Offset 46, 92 lines modified		Offset 57, 343 lines modified
46	········#·make·stat·inspect·the·link·target,·letting·an·attacker·turn·a·contended·acquire·into·a·misleading	57	········#·make·stat·inspect·the·link·target,·letting·an·attacker·turn·a·contended·acquire·into·a·misleading
47	········#·PermissionError·/·IsADirectoryError·and·probe·that·target's·attributes.·The·real·open·passes·O_NOFOLLOW·and	58	········#·PermissionError·/·IsADirectoryError·and·probe·that·target's·attributes.·The·real·open·passes·O_NOFOLLOW·and
48	········#·refuses·the·symlink·anyway.	59	········#·refuses·the·symlink·anyway.
49	········file_stat·=·os.lstat(filename)	60	········file_stat·=·os.lstat(filename)
50	····except·OSError:	61	····except·OSError:
51	········return··#·does·not·exist,·or·an·error·the·caller·cannot·act·on	62	········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	····#·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	····if·not·(file_stat.st_mode·&·stat.S_IWUSR):
56	········raise·PermissionError(EACCES,·"Permission·denied",·filename)

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

		67	····#·No·mtime·guard:·the·old·`if·st_mtime·!=·0`·skip·covered·NFS/Linux·quirks·where·os.lstat·returned·an·all-zero
		68	····#·struct,·which·it·no·longer·does.·Skipping·on·mtime·0·let·a·read-only·file·or·a·directory·at·the·lock·path·pass
		69	····#·as·missing,·so·acquire()·blocked·forever·on·an·open·that·cannot·succeed.
		70	····#·Match·open()·credentials·where·supported;·group·permissions·and·ACLs·can·grant·access·without·S_IWUSR.·Do·not
		71	····#·follow·a·symlink,·as·the·lstat·above·does·not:·one·swapped·in·since·would·be·judged·by·its·target.
		72	····if·not·(file_stat.st_mode·&·stat.S_IWUSR)·and·not·os.access(
		73	········filename,
		74	········os.W_OK,
		75	········effective_ids=os.access·in·os.supports_effective_ids,
		76	········follow_symlinks=os.access·not·in·os.supports_follow_symlinks,
		77	····):
		78	········try:
		79	············os.lstat(filename)
		80	········except·FileNotFoundError:
		81	············#·A·holder·may·unlink·its·marker·between·lstat()·and·access();·let·the·caller·attempt·creation.
		82	············return
		83	········raise·PermissionError(EACCES,·"Permission·denied",·filename)


61	def·ensure_directory_exists(filename:·Path·\|·str)·->·None:	84	def·ensure_directory_exists(filename:·Path·\|·str)·->·None:
62	····"""	85	····"""
63	····Ensure·the·directory·containing·the·file·exists·(create·it·if·necessary).	86	····Ensure·the·directory·containing·the·file·exists·(create·it·if·necessary).

64	····:param·filename:·file.	87	····:param·filename:·file.

65	····"""	88	····"""
66	····Path(filename).parent.mkdir(parents=True,·exist_ok=True)	89	····Path(filename).parent.mkdir(parents=True,·exist_ok=True)


		90	@contextmanager
		91	def·pin_inode(lock_file:·str)·->·Generator[int·\|·None]:
		92	····"""
		93	····Keep·the·file·at·lock_file·allocated·for·the·length·of·the·block·and·yield·its·inode·number.

		94	····An·inode·is·the·kernel's·identity·for·a·file,·independent·of·its·name,·and·its·number·names·a·file·only·while·the
		95	····inode·stays·allocated.·ext4·hands·a·freed·number·to·the·next·file·created.·Once·a·stale·marker·is·unlinked,·the·next
		96	····holder's·marker·can·therefore·carry·the·number·a·contender·read·a·moment·ago.·A·caller·that·reads·the·marker·inside
		97	····the·block,·gives·up·unless·it·read·the·yielded·inode,·and·breaks·the·marker·before·leaving·can·rely·on·the·number.

		98	····:param·lock_file:·path·to·the·lock·file·about·to·be·read·and·perhaps·broken.

		99	····:returns:·the·pinned·inode·number,·or·``None``·where·nothing·can·be·pinned.·Windows·cannot·rename·a·file·this
		100	········process·holds·open,·so·it·needs·no·pin.·Without·``O_PATH``·a·symlink·or·a·socket·cannot·be·opened.

		101	····:raises·FileNotFoundError:·if·the·path·is·gone.

		102	····"""
		103	····if·sys.platform·==·"win32":··#·pragma:·win32·cover
		104	········yield·None
		105	····else:··#·pragma:·win32·no·cover
		106	········#·O_PATH·pins·any·node,·a·symlink·or·socket·included,·without·read·permission·and·without·the·filesystem·seeing
		107	········#·an·open;·elsewhere·a·nonblocking·read-only·open·pins·what·it·can.
		108	········flags:·Final·=·getattr(os,·"O_PATH",·os.O_RDONLY·\|·getattr(os,·"O_NONBLOCK",·0))·\|·getattr(os,·"O_NOFOLLOW",·0)
		109	········try:
		110	············fd·=·os.open(lock_file,·flags)
		111	········except·FileNotFoundError:
		112	············raise
		113	········except·OSError:
		114	············yield·None
		115	············return
		116	········try:
		117	············yield·os.fstat(fd).st_ino
		118	········finally:
		119	············os.close(fd)


		120	def·remove_own_file(lock_file:·str,·fd:·int)·->·None:··#·pragma:·win32·no·cover
		121	····"""
		122	····Remove·lock_file·while·it·still·names·the·file·open·as·fd;·the·caller·closes·the·descriptor·afterwards.

Max diff block lines reached; 14156/22246 bytes (63.63%) of diff not shown.


Offset 1, 61 lines modified		Offset 1, 102 lines modified
1	from·__future__·import·annotations	1	from·__future__·import·annotations

		2	__lazy_modules__·=·["filelock._util",·"msvcrt",·"struct"]

2	import·os	3	import·os
		4	import·struct
3	import·sys	5	import·sys
		6	import·time
4	from·contextlib·import·suppress	7	from·contextlib·import·contextmanager,·suppress
5	from·pa~~thlib~~·import·~~Path~~	8	from·errno·import·ENOENT,·ENOTDIR,·EWOULDBLOCK
		9	from·functools·import·cache
6	from·typing·import·Final,·cast	10	from·typing·import·TYPE_CHECKING,·Final,·cast

		11	from·filelock._api·import·BaseFileLock
		12	from·filelock._util·import·raise_on_not_writable_file

7	from·._api·import·BaseFileLock
8	~~from·._util·import·ensure_directory_ex~~i~~sts~~,·~~raise_on_not~~_~~writable_file~~	13	if·TYPE_CHECKING:
		14	····from·collections.abc·import·Generator

9	if·sys.platform·==·"win32":··#·pragma:·win32·cover	15	if·sys.platform·==·"win32":··#·pragma:·win32·cover
10	····import·ctypes	16	····import·ctypes
11	····import·msvcrt	17	····import·msvcrt
12	····from·ctypes·import·wintypes	18	····from·ctypes·import·wintypes

13	····_GENERIC_READ:·Final[int]·=·0x80000000	19	····_GENERIC_READ:·Final[int]·=·0x80000000
14	····_GENERIC_WRITE:·Final[int]·=·0x40000000	20	····_GENERIC_WRITE:·Final[int]·=·0x40000000
15	····_SYNCHRONIZE:·Final[int]·=·0x00100000	21	····_SYNCHRONIZE:·Final[int]·=·0x00100000
		22	····_DELETE:·Final[int]·=·0x00010000
16	····_DESIRED_ACCESS:·Final[int]·=·_GENERIC_READ·\|·_GENERIC_WRITE·\|·_SYNCHRONIZE	23	····_DESIRED_ACCESS:·Final[int]·=·_GENERIC_READ·\|·_GENERIC_WRITE·\|·_SYNCHRONIZE
17	····_FILE_SHARE_READ_WRITE:·Final[int]·=·(	24	····_FILE_SHARE_READ_WRITE:·Final[int]·=·(
18	········0x00000001·\|·0x00000002	25	········0x00000001·\|·0x00000002
19	····)··#·read·\|·write;·matches·os.open·(_SH_DENYNO),·no·delete	26	····)··#·read·\|·write;·matches·os.open·(_SH_DENYNO),·no·delete
		27	····_FILE_OPEN:·Final[int]·=·1··#·open·the·file·only·if·it·exists;·the·NtCreateFile·OPEN_EXISTING
20	····_FILE_OPEN_IF:·Final[int]·=·3··#·open·the·file·if·it·exists,·create·it·otherwise;·the·NtCreateFile·OPEN_ALWAYS	28	····_FILE_OPEN_IF:·Final[int]·=·3··#·open·the·file·if·it·exists,·create·it·otherwise;·the·NtCreateFile·OPEN_ALWAYS
		29	····#·Attribute-only·access·skips·share-mode·checks,·so·the·probe·sees·a·name's·deletion·state·rather·than·a·reader.
		30	····_FILE_READ_ATTRIBUTES:·Final[int]·=·0x00000080
		31	····_FILE_SHARE_ALL:·Final[int]·=·0x00000001·\|·0x00000002·\|·0x00000004··#·read·\|·write·\|·delete
21	····_FILE_ATTRIBUTE_READONLY:·Final[int]·=·0x00000001	32	····_FILE_ATTRIBUTE_READONLY:·Final[int]·=·0x00000001
22	····_FILE_ATTRIBUTE_NORMAL:·Final[int]·=·0x00000080	33	····_FILE_ATTRIBUTE_NORMAL:·Final[int]·=·0x00000080
23	····_FILE_ATTRIBUTE_REPARSE_POINT:·Final[int]·=·0x00000400	34	····_FILE_ATTRIBUTE_REPARSE_POINT:·Final[int]·=·0x00000400
24	····#·CreateOptions:·keep·the·handle·synchronous·(the·CRT·and·msvcrt.locking·rely·on·a·maintained·file·position),	35	····#·CreateOptions:·keep·the·handle·synchronous·(the·CRT·and·msvcrt.locking·rely·on·a·maintained·file·position),
		36	····#·refuse·a·directory,·return·at·once·instead·of·waiting·for·an·oplock·holder·to·answer·the·break,·and·open·a
25	····#·re~~fuse·a·directory,·and·open·a·re~~parse·point·rather·than·following·it·so·the·check·below·acts·on·the·link·itself.	37	····#·reparse·point·rather·than·following·it·so·the·check·below·acts·on·the·link·itself.
26	····_FILE_SYNCHRONOUS_IO_NONALERT:·Final[int]·=·0x00000020	38	····_FILE_SYNCHRONOUS_IO_NONALERT:·Final[int]·=·0x00000020
27	····_FILE_NON_DIRECTORY_FILE:·Final[int]·=·0x00000040	39	····_FILE_NON_DIRECTORY_FILE:·Final[int]·=·0x00000040
		40	····_FILE_DELETE_ON_CLOSE:·Final[int]·=·0x00001000
		41	····_FILE_COMPLETE_IF_OPLOCKED:·Final[int]·=·0x00000100
28	····_FILE_OPEN_REPARSE_POINT:·Final[int]·=·0x00200000	42	····_FILE_OPEN_REPARSE_POINT:·Final[int]·=·0x00200000
		43	····_CREATE_OPTIONS:·Final[int]·=·(
		44	········_FILE_SYNCHRONOUS_IO_NONALERT·\|·_FILE_NON_DIRECTORY_FILE·\|·_FILE_COMPLETE_IF_OPLOCKED·\|·_FILE_OPEN_REPARSE_POINT
		45	····)
		46	····#·Listing·access·takes·part·in·share-mode·checks,·unlike·attribute-only·access,·so·a·handle·that·holds·it·without
		47	····#·FILE_SHARE_DELETE·blocks·renames·and·removals·of·the·directory·until·it·closes.
		48	····_FILE_LIST_DIRECTORY:·Final[int]·=·0x00000001
		49	····_FILE_DIRECTORY_FILE:·Final[int]·=·0x00000001
29	····_CREATE_OPTIONS:·Final[int]·=·_FILE_SYNCHRONOUS_IO_NONALERT·\|·_FILE~~_NON~~_DIRECTORY_FILE·\|·_FILE_OPEN_REPARSE_POINT	50	····_DIRECTORY_OPTIONS:·Final[int]·=·_FILE_SYNCHRONOUS_IO_NONALERT·\|·_FILE_DIRECTORY_FILE·\|·_FILE_OPEN_REPARSE_POINT
30	····_OBJ_CASE_INSENSITIVE:·Final[int]·=·0x00000040··#·Win32·name·lookups·are·case-insensitive	51	····_OBJ_CASE_INSENSITIVE:·Final[int]·=·0x00000040··#·Win32·name·lookups·are·case-insensitive
31	····_OWNER_WRITE:·Final[int]·=·0o200	52	····_OWNER_WRITE:·Final[int]·=·0o200
		53	····_GROUP_AND_OTHERS:·Final[int]·=·0o077
		54	····#·The·DACL·os.mkdir(mode=0o700)·applies,·less·the·inheritance·flags·a·file·has·no·use·for:·protected,·so·the
		55	····#·directory's·inheritable·entries·stay·out,·with·full·access·for·SYSTEM,·Administrators·and·the·owner.
		56	····_OWNER_ONLY_SDDL:·Final[str]·=·"D:P(A;;FA;;;SY)(A;;FA;;;BA)(A;;FA;;;OW)"
		57	····_SDDL_REVISION_1:·Final[int]·=·1
		58	····_INVALID_HANDLE_VALUE:·Final[int·\|·None]·=·ctypes.c_void_p(-1).value

32	····#·LockFileEx·locks·a·byte·range·at·an·offset·carried·in·OVERLAPPED,·independent·of·the·descriptor's·file·position.	59	····#·LockFileEx·locks·a·byte·range·at·an·offset·carried·in·OVERLAPPED,·independent·of·the·descriptor's·file·position.
33	····#·msvcrt.locking·starts·at·the·current·position·instead,·so·a·metadata·write·between·lock·and·unlock·could·shift	60	····#·msvcrt.locking·starts·at·the·current·position·instead,·so·a·metadata·write·between·lock·and·unlock·could·shift
34	····#·the·byte·a·later·unlock·targets;·the·explicit·offset·removes·that·hazard·for·both·the·path·lock·and·#608's	61	····#·the·byte·a·later·unlock·targets;·the·explicit·offset·removes·that·hazard·for·both·the·path·lock·and·#608's
35	····#·descriptor·lock.	62	····#·descriptor·lock.
36	····_LOCKFILE_FAIL_IMMEDIATELY:·Final[int]·=·0x00000001	63	····_LOCKFILE_FAIL_IMMEDIATELY:·Final[int]·=·0x00000001
37	····_LOCKFILE_EXCLUSIVE_LOCK:·Final[int]·=·0x00000002	64	····_LOCKFILE_EXCLUSIVE_LOCK:·Final[int]·=·0x00000002
		65	····_ERROR_ACCESS_DENIED:·Final[int]·=·5
38	····_ERROR_LOCK_VIOLATION:·Final[int]·=·33··#·another·handle·holds·the·byte·range	66	····_ERROR_LOCK_VIOLATION:·Final[int]·=·33··#·another·handle·holds·the·byte·range
		67	····_ERROR_NOT_LOCKED:·Final[int]·=·158··#·the·byte·range·is·not·locked

39	····#·NtCreateFile·returns·the·raw·NTSTATUS·as·its·value,·where·CreateFileW·collapses·several·of·these·into·one	68	····#·NtCreateFile·returns·the·raw·NTSTATUS·as·its·value,·where·CreateFileW·collapses·several·of·these·into·one
40	····#·ERROR_ACCESS_DENIED.·Telling·them·apart·is·the·point·(#604):·a·name·pending·deletion·or·a·share·conflict·is	69	····#·ERROR_ACCESS_DENIED.·Telling·them·apart·is·the·point·(#604):·a·name·pending·deletion·or·a·share·conflict·is
41	····#·transient·and·worth·a·retry,·a·real·access·denial·is·not.	70	····#·transient·and·worth·a·retry,·a·real·access·denial·is·not.
42	····_STATUS_SUCCESS:·Final[int]·=·0x00000000	71	····_STATUS_SUCCESS:·Final[int]·=·0x00000000
		72	····#·A·success·code·that·comes·with·a·handle:·another·handle's·oplock·is·breaking·and·its·holder·has·not·answered·yet.
		73	····_STATUS_OPLOCK_BREAK_IN_PROGRESS:·Final[int]·=·0x00000108
43	····_STATUS_ACCESS_DENIED:·Final[int]·=·0xC0000022	74	····_STATUS_ACCESS_DENIED:·Final[int]·=·0xC0000022
		75	····_STATUS_OBJECT_NAME_NOT_FOUND:·Final[int]·=·0xC0000034
		76	····_STATUS_OBJECT_PATH_NOT_FOUND:·Final[int]·=·0xC000003A
44	····_STATUS_SHARING_VIOLATION:·Final[int]·=·0xC0000043	77	····_STATUS_SHARING_VIOLATION:·Final[int]·=·0xC0000043
45	····_STATUS_DELETE_PENDING:·Final[int]·=·0xC0000056	78	····_STATUS_DELETE_PENDING:·Final[int]·=·0xC0000056
		79	····#:·Probes,·2·ms·apart,·for·transient·STATUS_ACCESS_DENIED·while·a·peer·unlinks·the·name·(#604).·A·count·ensures
		80	····#:·every·probe·runs·even·when·the·process·stalls;·oplock·breaks·use·the·caller's·wait·instead.
		81	····_ACCESS_DENIED_PROBES:·Final[int]·=·250
		82	····_ACCESS_DENIED_GRACE:·Final[float]·=·0.5
		83	····_ACCESS_DENIED_RETRY:·Final[float]·=·0.002

46	····_ntdll:·Final[ctypes.WinDLL]·=·ctypes.WinDLL("ntdll")	84	····_ntdll:·Final[ctypes.WinDLL]·=·ctypes.WinDLL("ntdll")
47	····_kernel32:·Final[ctypes.WinDLL]·=·ctypes.WinDLL("kernel32",·use_last_error=True)	85	····_kernel32:·Final[ctypes.WinDLL]·=·ctypes.WinDLL("kernel32",·use_last_error=True)
		86	····_advapi32:·Final[ctypes.WinDLL]·=·ctypes.WinDLL("advapi32",·use_last_error=True)

48	····class·_UNICODE_STRING(ctypes.Structure):··#·ruff:ignore[invalid-class-name]··#·mirrors·the·Win32·struct·name	87	····class·_UNICODE_STRING(ctypes.Structure):··#·ruff:ignore[invalid-class-name]··#·mirrors·the·Win32·struct·name
49	········_fields_·=·(	88	········_fields_·=·(
50	············("Length",·wintypes.USHORT),··#·byte·length,·not·character·count	89	············("Length",·wintypes.USHORT),··#·byte·length,·not·character·count
51	············("MaximumLength",·wintypes.USHORT),	90	············("MaximumLength",·wintypes.USHORT),
52	············("Buffer",·wintypes.LPWSTR),	91	············("Buffer",·wintypes.LPWSTR),
53	········)	92	········)
Offset 72, 14 lines modified		Offset 113, 21 lines modified

72	····class·_IO_STATUS_BLOCK(ctypes.Structure):··#·ruff:ignore[invalid-class-name]··#·mirrors·the·Win32·struct·name	113	····class·_IO_STATUS_BLOCK(ctypes.Structure):··#·ruff:ignore[invalid-class-name]··#·mirrors·the·Win32·struct·name
73	········_fields_·=·(	114	········_fields_·=·(
74	············("Status",·ctypes.c_void_p),··#·a·union·of·NTSTATUS·and·PVOID,·so·it·is·pointer-sized	115	············("Status",·ctypes.c_void_p),··#·a·union·of·NTSTATUS·and·PVOID,·so·it·is·pointer-sized
75	············("Information",·ctypes.c_void_p),	116	············("Information",·ctypes.c_void_p),
76	········)	117	········)

		118	····class·_SECURITY_ATTRIBUTES(ctypes.Structure):··#·ruff:ignore[invalid-class-name]··#·mirrors·the·Win32·struct·name
		119	········_fields_·=·(
		120	············("nLength",·wintypes.DWORD),
		121	············("lpSecurityDescriptor",·ctypes.c_void_p),
		122	············("bInheritHandle",·wintypes.BOOL),
		123	········)

77	····class·_OVERLAPPED(ctypes.Structure):··#·mirrors·the·Win32·struct·name	124	····class·_OVERLAPPED(ctypes.Structure):··#·mirrors·the·Win32·struct·name
78	········_fields_·=·(	125	········_fields_·=·(
79	············("Internal",·ctypes.c_void_p),··#·ULONG_PTR:·pointer-sized,·not·DWORD,·or·the·x64·layout·corrupts·Offset	126	············("Internal",·ctypes.c_void_p),··#·ULONG_PTR:·pointer-sized,·not·DWORD,·or·the·x64·layout·corrupts·Offset
80	············("InternalHigh",·ctypes.c_void_p),	127	············("InternalHigh",·ctypes.c_void_p),
81	············("Offset",·wintypes.DWORD),··#·the·DUMMYUNIONNAME·struct,·flattened:·low·32·bits·of·the·byte·offset	128	············("Offset",·wintypes.DWORD),··#·the·DUMMYUNIONNAME·struct,·flattened:·low·32·bits·of·the·byte·offset
82	············("OffsetHigh",·wintypes.DWORD),	129	············("OffsetHigh",·wintypes.DWORD),
83	············("hEvent",·wintypes.HANDLE),	130	············("hEvent",·wintypes.HANDLE),
Offset 142, 14 lines modified		Offset 190, 65 lines modified
142	········wintypes.HANDLE,	190	········wintypes.HANDLE,
Max diff block lines reached; 31085/38526 bytes (80.69%) of diff not shown.


Offset 1, 75 lines modified		Offset 1, 93 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	__lazy_modules__·=·[
		4	····"asyncio",
		5	····"concurrent",
		6	····"contextlib",
		7	····"filelock._async",
		8	····"filelock._error",
		9	····"filelock._util",
		10	····"functools",
		11	····"inspect",
		12	····"threading",
		13	]

3	import·asyncio	14	import·asyncio
4	import·contextlib	15	import·contextlib
		16	import·functools
5	import·logging	17	import·logging
6	import·os	18	import·os
		19	import·sys
7	import·time	20	import·time
		21	from·concurrent·import·futures
8	from·dataclasses·import·dataclass	22	from·dataclasses·import·dataclass,·field,·fields
9	from·inspect·import·iscoroutinefunction	23	from·inspect·import·iscoroutinefunction
10	from·threading·import·local	24	from·threading·import·RLock
11	from·typing·import·TYPE_CHECKING,·Final,·NoReturn,·TypeVar,·cast	25	from·typing·import·TYPE_CHECKING,·Final,·NoReturn,·TypeVar,·cast

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

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

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


55	_LOGGER:·Final[logging.Logger]·=·logging.getLogger("filelock")	71	_LOGGER:·Final[logging.Logger]·=·logging.getLogger("filelock")
56	_ASYNC_RELEASE_CANCELLATION_ERRORS:·Final[str]·=·"lock·release·cancellation·and·backend·release·both·failed"	72	_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"	73	_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"	74	_ASYNC_RELEASE_CANCELLATION_MARKER_ATTR:·Final[str]·=·"_filelock_async_release_cancellation"
59	_ASYNC_RELEASE_CANCELLATION_MARKER:·Final[list[None]]·=·[]	75	_ASYNC_RELEASE_CANCELLATION_MARKER:·Final[list[None]]·=·[]
		76	_FINALIZER_RELEASES:·Final[set[asyncio.Task[None]·\|·futures.Future[None]]]·=·set()

60	_AT·=·TypeVar("_AT",·bound="BaseAsyncFileLock")	77	_AT·=·TypeVar("_AT",·bound="BaseAsyncFileLock")
		78	_T·=·TypeVar("_T")


61	class·AsyncFileLockMeta(FileLockMeta):	79	class·AsyncFileLockMeta(FileLockMeta):
62	····def·__call__(··#·ruff:ignore[too-many-arguments]··#·forwards·the·public·constructor's·documented·parameters	80	····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	81	········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],	82	········lock_file:·str·\|·os.PathLike[str],
65	········timeout:·float·=·-1,	83	········timeout:·float·=·-1,
Offset 159, 20 lines modified		Offset 177, 20 lines modified
159	········:param·lock_file:·path·to·the·file	177	········: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	178	········: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	179	············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.	180	············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	181	········: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.	182	············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	183	········: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	184	············``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``,	185	············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	186	············``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	187	············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``.	188	············at·construction·time.·``mode``·has·no·setter,·so·construction·is·the·only·place·it·is·ever·set.·If·you·need
		189	············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	190	········: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	191	········: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	192	············file.·This·is·useful·if·you·want·to·use·the·lock·object·for·reentrant·locking·without·needing·to·pass·the
175	············same·object·around.	193	············same·object·around.
176	········:param·poll_interval:·default·interval·for·polling·the·lock·file,·in·seconds.·It·will·be·used·as·fallback·value	194	········: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.	195	············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	196	········:param·lifetime:·for·:class:`AsyncSoftFileLock`,·the·age·in·seconds·after·which·a·waiting·process·may·delete
Offset 193, 66 lines modified		Offset 211, 88 lines modified
193	············identity·(Windows·skips·its·unlink,·Unix·refuses·the·``ENOSYS``·soft·fallback).·:class:`AsyncSoftFileLock`	211	············identity·(Windows·skips·its·unlink,·Unix·refuses·the·``ENOSYS``·soft·fallback).·:class:`AsyncSoftFileLock`
194	············rejects·``True``.	212	············rejects·``True``.
195	········:param·on_acquired:·for·native·locks·(:class:`AsyncFileLock`),·a·callable·invoked·with·the·borrowed·lock	213	········: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	214	············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	215	············:meth:`~BaseAsyncFileLock.acquire`·returns.·With·``run_in_executor=True``·(the·default)·it·runs·in·the
Max diff block lines reached; 22781/29310 bytes (77.72%) 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.2'	20	__version__·=·version·=·'4.2.4'
21	__version_tuple__·=·version_tuple·=·(3,·32,·2)	21	__version_tuple__·=·version_tuple·=·(4,·2,·4)

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


Offset 1, 12 lines modified		Offset 1, 14 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	__lazy_modules__·=·["filelock._soft_rw._async"]

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

5	__all__·=·[	6	__all__·=·[
6	····"AsyncAcquireSoftReadWriteReturnProxy",	7	····"AsyncAcquireSoftReadWriteReturnProxy",
7	····"AsyncSoftReadWriteLock",	8	····"AsyncSoftReadWriteLock",
8	····"SoftReadWriteLock",	9	····"SoftReadWriteLock",
9	]	10	]


Offset 1, 54 lines modified		Offset 1, 65 lines modified
1	"""Async·wrapper·around·:class:`SoftReadWriteLock`·for·use·with·``asyncio``."""	1	"""Async·wrapper·around·:class:`SoftReadWriteLock`·for·use·with·``asyncio``."""

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

		3	__lazy_modules__·=·["asyncio",·"filelock._async",·"filelock._error",·"functools",·"threading"]

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

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

16	from·~~._sync·impo~~r~~t·SoftReadWr~~iteLock	20	from·filelock._error·import·Timeout
		21	from·filelock._soft_rw._sync·import·SoftReadWriteLock,·_lost_hold_error

17	if·TYPE_CHECKING:	22	if·TYPE_CHECKING:
18	····from·collections.abc·import·AsyncGenerator,·Callable	23	····from·collections.abc·import·AsyncGenerator,·Callable
19	····from·concurrent·import·futures	24	····from·concurrent·import·futures
20	····from·types·import·TracebackType	25	····from·types·import·TracebackType

21	····from·filelock._api·import·AcquireReturnProxy	26	····from·filelock._api·import·AcquireReturnProxy
		27	····from·filelock._lease·import·LeaseCompromise

22	_P·=·ParamSpec("_P")	28	_P·=·ParamSpec("_P")
23	_R·=·TypeVar("_R")	29	_R·=·TypeVar("_R")


24	class·AsyncSoftReadWriteLock:	30	class·AsyncSoftReadWriteLock:
25	····"""	31	····"""
26	····Async·wrapper·around·:class:`SoftReadWriteLock`·for·``asyncio``·applications.	32	····Async·wrapper·around·:class:`SoftReadWriteLock`·for·``asyncio``·applications.

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

30	····:param·lock_file:·path·to·the·lock·file;·sidecar·st~~ate/wr~~i~~te/~~re~~ade~~rs·live·next·to·it	38	····:param·lock_file:·path·to·the·lock·file;·the·protocol·directory·lives·next·to·it·as·``<lock_file>.rw``
31	····:param·timeout:·maximum·wait·time·in·seconds;·``-1``·means·block·indefinitely	39	····:param·timeout:·maximum·wait·time·in·seconds;·``-1``·means·block·indefinitely
32	····:param·blocking:·if·``False``,·raise·:class:`~filelock.Timeout`·immediately·on·contention	40	····:param·blocking:·if·``False``,·raise·:class:`~filelock.Timeout`·immediately·on·contention
33	····:param·is_singleton:·if·``True``,·reuse·existing·:class:`SoftReadWriteLock`·instances·per·resolved·path	41	····:param·is_singleton:·if·``True``,·reuse·existing·:class:`SoftReadWriteLock`·instances·per·resolved·path
34	····:param·heartbeat_interval:·seconds·between·heartbeat·refreshes;·default·30·s	42	····:param·heartbeat_interval:·seconds·between·heartbeat·refreshes;·default·30·s
35	····: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``	43	····:param·stale_threshold:·seconds·a·holder·record·may·stay·unchanged·before·a·contender·evicts·it;·defaults·to
		44	········``3·*·heartbeat_interval``
36	····:param·poll_interval:·seconds·between·acquire·retries·under·contention;·default·0.25·s	45	····:param·poll_interval:·seconds·between·acquire·retries·under·contention;·default·0.25·s
		46	····:param·on_compromise:·called·from·the·heartbeat·thread·with·a·:class:`~filelock.LeaseCompromise`·when·the·hold·is
		47	········lost
37	····:param·loop:·event·loop·for·``run_in_executor``;·``None``·uses·the·running·loop	48	····:param·loop:·event·loop·for·``run_in_executor``;·``None``·uses·the·running·loop
38	····:param·executor:·executor·for·``run_in_executor``;·``None``·uses·the·default·executor	49	····:param·executor:·executor·for·``run_in_executor``;·``None``·uses·the·default·executor

39	····..·versionadded::·3.27.0	50	····..·versionadded::·3.27.0

40	····"""	51	····"""

Offset 58, 27 lines modified		Offset 69, 34 lines modified
58	········timeout:·float·=·-1,	69	········timeout:·float·=·-1,
59	········*,	70	········*,
60	········blocking:·bool·=·True,	71	········blocking:·bool·=·True,
61	········is_singleton:·bool·=·True,	72	········is_singleton:·bool·=·True,
62	········heartbeat_interval:·float·=·30.0,	73	········heartbeat_interval:·float·=·30.0,
63	········stale_threshold:·float·\|·None·=·None,	74	········stale_threshold:·float·\|·None·=·None,
64	········poll_interval:·float·=·0.25,	75	········poll_interval:·float·=·0.25,
		76	········on_compromise:·Callable[[LeaseCompromise],·None]·\|·None·=·None,
65	········loop:·asyncio.AbstractEventLoop·\|·None·=·None,	77	········loop:·asyncio.AbstractEventLoop·\|·None·=·None,
66	········executor:·futures.Executor·\|·None·=·None,	78	········executor:·futures.Executor·\|·None·=·None,
67	····)·->·None:	79	····)·->·None:
68	········self._creator_pid·=·os.getpid()	80	········self._creator_pid·=·os.getpid()
		81	········self._closed·=·False
		82	········self._owns_backend·=·not·is_singleton
		83	········#:·Marks·the·task·holds·taken·through·this·wrapper,·which·its·close()·ends.
		84	········self._via:·Final·=·object()
69	········self._lock·=·SoftReadWriteLock(	85	········self._lock·=·SoftReadWriteLock(
70	············lock_file,	86	············lock_file,
71	············timeout,	87	············timeout,
72	············blocking=blocking,	88	············blocking=blocking,
73	············is_singleton=is_singleton,	89	············is_singleton=is_singleton,
74	············heartbeat_interval=heartbeat_interval,	90	············heartbeat_interval=heartbeat_interval,
75	············stale_threshold=stale_threshold,	91	············stale_threshold=stale_threshold,
76	············poll_interval=poll_interval,	92	············poll_interval=poll_interval,
		93	············on_compromise=on_compromise,
77	········)	94	········)
		95	········self._owners·=·_task_owners_for(self._lock)
78	········self._loop·=·loop	96	········self._loop·=·loop
79	········self._executor·=·executor	97	········self._executor·=·executor

80	····@property	98	····@property
81	····def·lock_file(self)·->·str:	99	····def·lock_file(self)·->·str:
82	········"""The·path·to·the·lock·file·passed·to·the·constructor."""	100	········"""The·path·to·the·lock·file·passed·to·the·constructor."""
83	········return·self._lock.lock_file	101	········return·self._lock.lock_file
Offset 90, 14 lines modified		Offset 108, 24 lines modified

90	····@property	108	····@property
91	····def·blocking(self)·->·bool:	109	····def·blocking(self)·->·bool:
92	········"""Whether·``acquire_*``·defaults·to·blocking;·``False``·makes·contention·raise·immediately."""	110	········"""Whether·``acquire_*``·defaults·to·blocking;·``False``·makes·contention·raise·immediately."""
93	········return·self._lock.blocking	111	········return·self._lock.blocking

94	····@property	112	····@property
		113	····def·generation(self)·->·int·\|·None:
		114	········"""The·generation·the·current·hold·was·granted·at,·a·fencing·token;·``None``·when·no·lock·is·held."""
		115	········return·self._lock.generation

		116	····@property
		117	····def·compromise(self)·->·LeaseCompromise·\|·None:
		118	········"""How·the·current·hold·was·lost,·or·``None``·while·it·stands;·acquiring·raises·until·the·hold·is·released."""
		119	········return·self._lock.compromise

		120	····@property
95	····def·loop(self)·->·asyncio.AbstractEventLoop·\|·None:	121	····def·loop(self)·->·asyncio.AbstractEventLoop·\|·None:
96	········"""The·event·loop·used·for·``run_in_executor``,·or·``None``·for·the·running·loop."""	122	········"""The·event·loop·used·for·``run_in_executor``,·or·``None``·for·the·running·loop."""
97	········return·self._loop	123	········return·self._loop

98	····@property	124	····@property
99	····def·executor(self)·->·futures.Executor·\|·None:	125	····def·executor(self)·->·futures.Executor·\|·None:
100	········"""The·executor·used·for·``run_in_executor``,·or·``None``·for·the·default·executor."""	126	········"""The·executor·used·for·``run_in_executor``,·or·``None``·for·the·default·executor."""
Max diff block lines reached; 13672/19425 bytes (70.38%) of diff not shown.


Offset 1, 241 lines modified		Offset 1, 294 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	__lazy_modules__·=·[
		4	····"filelock._error",
		5	····"filelock._lease",
		6	····"filelock._soft_rw._protocol",
		7	····"filelock._soft_rw._storage",
		8	····"math",
		9	]

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

19	from·filelock._api·import·(	19	from·filelock._api·import·(
20	····AcquireReturnProxy,	20	····AcquireReturnProxy,
		21	····_acquire_thread_lock,
		22	····_canonical,
		23	····_check_timeout_max,
21	····_ensure_current_process,	24	····_ensure_current_process,
22	····_fork_transition,
23	····_raise_grouped_errors,
24	····_register_fork_class,	25	····_register_fork_class,
25	····_register_fork_object,	26	····_register_fork_object,
26	····_register_owned_descriptor,
27	····_unre~~gist~~er_o~~wne~~d_~~descr~~iptor,	27	····_resolve_read_write_timeout,
		28	····_seconds,
		29	····_timeout_behavior,
28	)	30	)
29	from·filelock._error·import·Timeout	31	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~~	32	from·filelock._lease·import·LeaseCompromise
		33	from·filelock._soft_rw._protocol·import·GenerationLog,·Ledger,·Mode,·Participant
		34	from·filelock._soft_rw._storage·import·OsFiles

32	if·TYPE_CHECKING:	35	if·TYPE_CHECKING:
33	····from·collections.abc·import·Callable,·Generator	36	····from·collections.abc·import·Callable,·Generator

		37	····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()	38	_ALL_INSTANCES:·Final[WeakValueDictionary[int,·SoftReadWriteLock]]·=·WeakValueDictionary()
43	_ALL_INSTANCES_LOCK:·threading.Lock·=·threading.Lock()	39	_ALL_INSTANCES_LOCK:·threading.Lock·=·threading.Lock()
44	_SINGLETONS_UNDER_CONSTRUCTION:·Final[set[Path]]·=·set()


45	class·_SoftRWMeta(type):	40	class·_SoftRWMeta(type):
46	····_instances:·WeakValueDictionary[Path,·SoftReadWriteLock]	41	····_instances:·WeakValueDictionary[str,·SoftReadWriteLock]
47	····_instances_lock:·threading.RLock	42	····_instances_lock:·threading.RLock
		43	····_instances_under_construction:·set[str]

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

		71	········#·Keyed·like·the·log·root,·so·one·instance·never·spans·two·logs.
70	········normalized·=·Path(lock_fi~~le).reso~~lve()	72	········normalized·=·_canonical(lock_file)
71	········with·cls._instances_lock:	73	········with·cls._instances_lock:
72	············instance·=·cls._instances.get(normalized)	74	············instance·=·cls._instances.get(normalized)
73	············if·instance·is·None:	75	············if·instance·is·None:
74	················if·normalized·in·~~_SINGLETONS_UNDER~~_~~CONSTRUCTION:··#·p~~rag~~ma:·needs·f~~ork	76	················if·normalized·in·cls._instances_under_construction:
75	····················msg·=·f"Singleton·lock·construction·is·already·active·for·{lock_file!s}"	77	····················msg·=·f"Singleton·lock·construction·is·already·active·for·{lock_file!s}"
76	····················raise·RuntimeError(msg)	78	····················raise·RuntimeError(msg)
77	················construction_pid·=·os.getpid()	79	················construction_pid·=·os.getpid()
78	················~~_SINGLETONS~~_~~UNDER_CONSTRUCTION.~~ad~~d(n~~o~~rmalized)~~	80	················construction_registry·=·cls._instances_under_construction
		81	················construction_registry.add(normalized)
79	················try:	82	················try:
80	····················instance·=·super().__call__(	83	····················instance·=·super().__call__(
81	························lock_file,	84	························lock_file,
82	························timeout,	85	························timeout,
83	························blocking=blocking,	86	························blocking=blocking,
84	························is_singleton=is_singleton,	87	························is_singleton=is_singleton,
85	························heartbeat_interval=heartbeat_interval,	88	························heartbeat_interval=heartbeat_interval,
86	························stale_threshold=stale_threshold,	89	························stale_threshold=stale_threshold,
87	························poll_interval=poll_interval,	90	························poll_interval=poll_interval,
		91	························**extra,
88	····················)	92	····················)
89	················finally:	93	················finally:
90	····················~~_SINGLETONS_UNDER~~_~~CONSTRUCTION~~.discard(normalized)	94	····················construction_registry.discard(normalized)
91	················if·os.getpid()·!=·construction_pid:··#·pragma:·needs·fork	95	················if·os.getpid()·!=·construction_pid:··#·pragma:·needs·fork
Max diff block lines reached; 61623/67182 bytes (91.73%) 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))