Add files using upload-large-folder tool

.gitattributes

@@ -421,3 +421,5 @@ material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:
 material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_TSEM/Image_Registration/Output/1908278/1908279.tif filter=lfs diff=lfs merge=lfs -text
 material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_Manual_4connected/1908280_m.tif filter=lfs diff=lfs merge=lfs -text
 material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_Manual_4connected/1908316_m.tif filter=lfs diff=lfs merge=lfs -text
+material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_TSEM/Image_Registration/Output/1908308/1908309.tif filter=lfs diff=lfs merge=lfs -text
+material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_TSEM/Image_Registration/Input/1908324/1908324.tif filter=lfs diff=lfs merge=lfs -text

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_deepreload.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+"""Test suite for the deepreload module."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import types
+from pathlib import Path
+
+import pytest
+from tempfile import TemporaryDirectory
+
+from IPython.lib.deepreload import modules_reloading
+from IPython.lib.deepreload import reload as dreload
+from IPython.utils.syspathcontext import prepended_to_syspath
+
+
+def test_deepreload():
+    "Test that dreload does deep reloads and skips excluded modules."
+    with TemporaryDirectory() as tmpdir:
+        with prepended_to_syspath(tmpdir):
+            tmpdirpath = Path(tmpdir)
+            with open(tmpdirpath / "A.py", "w", encoding="utf-8") as f:
+                f.write("class Object:\n    pass\nok = True\n")
+            with open(tmpdirpath / "B.py", "w", encoding="utf-8") as f:
+                f.write("import A\nassert A.ok, 'we are fine'\n")
+            import A
+            import B
+
+            # Test that A is not reloaded.
+            obj = A.Object()
+            dreload(B, exclude=["A"])
+            assert isinstance(obj, A.Object) is True
+
+            # Test that an import failure will not blow-up us.
+            A.ok = False
+            with pytest.raises(AssertionError, match="we are fine"):
+                dreload(B, exclude=["A"])
+            assert len(modules_reloading) == 0
+            assert not A.ok
+
+            # Test that A is reloaded.
+            obj = A.Object()
+            A.ok = False
+            dreload(B)
+            assert A.ok
+            assert isinstance(obj, A.Object) is False
+
+
+def test_not_module():
+    pytest.raises(TypeError, dreload, "modulename")
+
+
+def test_not_in_sys_modules():
+    fake_module = types.ModuleType("fake_module")
+    with pytest.raises(ImportError, match="not in sys.modules"):
+        dreload(fake_module)

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_display.py

@@ -0,0 +1,272 @@
+"""Tests for IPython.lib.display.
+
+"""
+#-----------------------------------------------------------------------------
+# Copyright (c) 2012, the IPython Development Team.
+#
+# Distributed under the terms of the Modified BSD License.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+from tempfile import NamedTemporaryFile, mkdtemp
+from os.path import split, join as pjoin, dirname
+import pathlib
+from unittest import TestCase, mock
+import struct
+import wave
+from io import BytesIO
+
+# Third-party imports
+import pytest
+
+try:
+    import numpy
+except ImportError:
+    pass
+
+# Our own imports
+from IPython.lib import display
+
+from IPython.testing.decorators import skipif_not_numpy
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+#--------------------------
+# FileLink tests
+#--------------------------
+
+def test_instantiation_FileLink():
+    """FileLink: Test class can be instantiated"""
+    fl = display.FileLink('example.txt')
+    # TODO: remove if when only Python >= 3.6 is supported
+    fl = display.FileLink(pathlib.PurePath('example.txt'))
+
+def test_warning_on_non_existent_path_FileLink():
+    """FileLink: Calling _repr_html_ on non-existent files returns a warning"""
+    fl = display.FileLink("example.txt")
+    assert fl._repr_html_().startswith("Path (<tt>example.txt</tt>)")
+
+
+def test_existing_path_FileLink():
+    """FileLink: Calling _repr_html_ functions as expected on existing filepath
+    """
+    tf = NamedTemporaryFile()
+    fl = display.FileLink(tf.name)
+    actual = fl._repr_html_()
+    expected = "<a href='%s' target='_blank'>%s</a><br>" % (tf.name, tf.name)
+    assert actual == expected
+
+
+def test_existing_path_FileLink_repr():
+    """FileLink: Calling repr() functions as expected on existing filepath
+    """
+    tf = NamedTemporaryFile()
+    fl = display.FileLink(tf.name)
+    actual = repr(fl)
+    expected = tf.name
+    assert actual == expected
+
+
+def test_error_on_directory_to_FileLink():
+    """FileLink: Raises error when passed directory
+    """
+    td = mkdtemp()
+    pytest.raises(ValueError, display.FileLink, td)
+
+#--------------------------
+# FileLinks tests
+#--------------------------
+
+def test_instantiation_FileLinks():
+    """FileLinks: Test class can be instantiated
+    """
+    fls = display.FileLinks('example')
+
+def test_warning_on_non_existent_path_FileLinks():
+    """FileLinks: Calling _repr_html_ on non-existent files returns a warning"""
+    fls = display.FileLinks("example")
+    assert fls._repr_html_().startswith("Path (<tt>example</tt>)")
+
+
+def test_existing_path_FileLinks():
+    """FileLinks: Calling _repr_html_ functions as expected on existing dir
+    """
+    td = mkdtemp()
+    tf1 = NamedTemporaryFile(dir=td)
+    tf2 = NamedTemporaryFile(dir=td)
+    fl = display.FileLinks(td)
+    actual = fl._repr_html_()
+    actual = actual.split('\n')
+    actual.sort()
+    # the links should always have forward slashes, even on windows, so replace
+    # backslashes with forward slashes here
+    expected = ["%s/<br>" % td,
+                "&nbsp;&nbsp;<a href='%s' target='_blank'>%s</a><br>" %\
+                 (tf2.name.replace("\\","/"),split(tf2.name)[1]),
+                "&nbsp;&nbsp;<a href='%s' target='_blank'>%s</a><br>" %\
+                 (tf1.name.replace("\\","/"),split(tf1.name)[1])]
+    expected.sort()
+    # We compare the sorted list of links here as that's more reliable
+    assert actual == expected
+
+
+def test_existing_path_FileLinks_alt_formatter():
+    """FileLinks: Calling _repr_html_ functions as expected w/ an alt formatter
+    """
+    td = mkdtemp()
+    tf1 = NamedTemporaryFile(dir=td)
+    tf2 = NamedTemporaryFile(dir=td)
+    def fake_formatter(dirname,fnames,included_suffixes):
+        return ["hello","world"]
+    fl = display.FileLinks(td,notebook_display_formatter=fake_formatter)
+    actual = fl._repr_html_()
+    actual = actual.split('\n')
+    actual.sort()
+    expected = ["hello","world"]
+    expected.sort()
+    # We compare the sorted list of links here as that's more reliable
+    assert actual == expected
+
+
+def test_existing_path_FileLinks_repr():
+    """FileLinks: Calling repr() functions as expected on existing directory """
+    td = mkdtemp()
+    tf1 = NamedTemporaryFile(dir=td)
+    tf2 = NamedTemporaryFile(dir=td)
+    fl = display.FileLinks(td)
+    actual = repr(fl)
+    actual = actual.split('\n')
+    actual.sort()
+    expected = ['%s/' % td, '  %s' % split(tf1.name)[1],'  %s' % split(tf2.name)[1]]
+    expected.sort()
+    # We compare the sorted list of links here as that's more reliable
+    assert actual == expected
+
+
+def test_existing_path_FileLinks_repr_alt_formatter():
+    """FileLinks: Calling repr() functions as expected w/ alt formatter
+    """
+    td = mkdtemp()
+    tf1 = NamedTemporaryFile(dir=td)
+    tf2 = NamedTemporaryFile(dir=td)
+    def fake_formatter(dirname,fnames,included_suffixes):
+        return ["hello","world"]
+    fl = display.FileLinks(td,terminal_display_formatter=fake_formatter)
+    actual = repr(fl)
+    actual = actual.split('\n')
+    actual.sort()
+    expected = ["hello","world"]
+    expected.sort()
+    # We compare the sorted list of links here as that's more reliable
+    assert actual == expected
+
+
+def test_error_on_file_to_FileLinks():
+    """FileLinks: Raises error when passed file
+    """
+    td = mkdtemp()
+    tf1 = NamedTemporaryFile(dir=td)
+    pytest.raises(ValueError, display.FileLinks, tf1.name)
+
+
+def test_recursive_FileLinks():
+    """FileLinks: Does not recurse when recursive=False
+    """
+    td = mkdtemp()
+    tf = NamedTemporaryFile(dir=td)
+    subtd = mkdtemp(dir=td)
+    subtf = NamedTemporaryFile(dir=subtd)
+    fl = display.FileLinks(td)
+    actual = str(fl)
+    actual = actual.split('\n')
+    assert len(actual) == 4, actual
+    fl = display.FileLinks(td, recursive=False)
+    actual = str(fl)
+    actual = actual.split('\n')
+    assert len(actual) == 2, actual
+
+def test_audio_from_file():
+    path = pjoin(dirname(__file__), 'test.wav')
+    display.Audio(filename=path)
+
+class TestAudioDataWithNumpy(TestCase):
+
+    @skipif_not_numpy
+    def test_audio_from_numpy_array(self):
+        test_tone = get_test_tone()
+        audio = display.Audio(test_tone, rate=44100)
+        assert len(read_wav(audio.data)) == len(test_tone)
+
+    @skipif_not_numpy
+    def test_audio_from_list(self):
+        test_tone = get_test_tone()
+        audio = display.Audio(list(test_tone), rate=44100)
+        assert len(read_wav(audio.data)) == len(test_tone)
+
+    @skipif_not_numpy
+    def test_audio_from_numpy_array_without_rate_raises(self):
+        self.assertRaises(ValueError, display.Audio, get_test_tone())
+
+    @skipif_not_numpy
+    def test_audio_data_normalization(self):
+        expected_max_value = numpy.iinfo(numpy.int16).max
+        for scale in [1, 0.5, 2]:
+            audio = display.Audio(get_test_tone(scale), rate=44100)
+            actual_max_value = numpy.max(numpy.abs(read_wav(audio.data)))
+            assert actual_max_value == expected_max_value
+
+    @skipif_not_numpy
+    def test_audio_data_without_normalization(self):
+        max_int16 = numpy.iinfo(numpy.int16).max
+        for scale in [1, 0.5, 0.2]:
+            test_tone = get_test_tone(scale)
+            test_tone_max_abs = numpy.max(numpy.abs(test_tone))
+            expected_max_value = int(max_int16 * test_tone_max_abs)
+            audio = display.Audio(test_tone, rate=44100, normalize=False)
+            actual_max_value = numpy.max(numpy.abs(read_wav(audio.data)))
+            assert actual_max_value == expected_max_value
+
+    def test_audio_data_without_normalization_raises_for_invalid_data(self):
+        self.assertRaises(
+            ValueError,
+            lambda: display.Audio([1.001], rate=44100, normalize=False))
+        self.assertRaises(
+            ValueError,
+            lambda: display.Audio([-1.001], rate=44100, normalize=False))
+
+def simulate_numpy_not_installed():
+    try:
+        import numpy
+        return mock.patch('numpy.array', mock.MagicMock(side_effect=ImportError))
+    except ModuleNotFoundError:
+        return lambda x:x
+
+@simulate_numpy_not_installed()
+class TestAudioDataWithoutNumpy(TestAudioDataWithNumpy):
+    # All tests from `TestAudioDataWithNumpy` are inherited.
+
+    @skipif_not_numpy
+    def test_audio_raises_for_nested_list(self):
+        stereo_signal = [list(get_test_tone())] * 2
+        self.assertRaises(TypeError, lambda: display.Audio(stereo_signal, rate=44100))
+
+
+@skipif_not_numpy
+def get_test_tone(scale=1):
+    return numpy.sin(2 * numpy.pi * 440 * numpy.linspace(0, 1, 44100)) * scale
+
+def read_wav(data):
+    with wave.open(BytesIO(data)) as wave_file:
+        wave_data = wave_file.readframes(wave_file.getnframes())
+        num_samples = wave_file.getnframes() * wave_file.getnchannels()
+        return struct.unpack('<%sh' % num_samples, wave_data)
+
+def test_code_from_file():
+    c = display.Code(filename=__file__)
+    assert c._repr_html_().startswith('<style>')

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_editorhooks.py

@@ -0,0 +1,32 @@
+"""Test installing editor hooks"""
+import sys
+from unittest import mock
+
+from IPython import get_ipython
+from IPython.lib import editorhooks
+
+def test_install_editor():
+    called = []
+    def fake_popen(*args, **kwargs):
+        called.append({
+            'args': args,
+            'kwargs': kwargs,
+        })
+        return mock.MagicMock(**{'wait.return_value': 0})
+    editorhooks.install_editor('foo -l {line} -f {filename}', wait=False)
+    
+    with mock.patch('subprocess.Popen', fake_popen):
+        get_ipython().hooks.editor('the file', 64)
+    
+    assert len(called) == 1
+    args = called[0]["args"]
+    kwargs = called[0]["kwargs"]
+
+    assert kwargs == {"shell": True}
+
+    if sys.platform.startswith("win"):
+        expected = ["foo", "-l", "64", "-f", "the file"]
+    else:
+        expected = "foo -l 64 -f 'the file'"
+    cmd = args[0]
+    assert cmd == expected

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_imports.py

@@ -0,0 +1,14 @@
+# encoding: utf-8
+from IPython.testing import decorators as dec
+
+
+def test_import_backgroundjobs():
+    from IPython.lib import backgroundjobs
+
+
+def test_import_deepreload():
+    from IPython.lib import deepreload
+
+
+def test_import_demo():
+    from IPython.lib import demo

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_latextools.py

@@ -0,0 +1,192 @@
+"""Tests for IPython.utils.path.py"""
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+from contextlib import contextmanager
+from unittest.mock import patch
+
+import pytest
+
+from IPython.lib import latextools
+from IPython.testing.decorators import (
+    onlyif_cmds_exist,
+    skipif_not_matplotlib,
+)
+from IPython.utils.process import FindCmdError
+
+
+@pytest.mark.parametrize('command', ['latex', 'dvipng'])
+def test_check_latex_to_png_dvipng_fails_when_no_cmd(command):
+    def mock_find_cmd(arg):
+        if arg == command:
+            raise FindCmdError
+
+    with patch.object(latextools, "find_cmd", mock_find_cmd):
+        assert latextools.latex_to_png_dvipng("whatever", True) is None
+
+
+@contextmanager
+def no_op(*args, **kwargs):
+    yield
+
+
+@onlyif_cmds_exist("latex", "dvipng")
+@pytest.mark.parametrize("s, wrap", [("$$x^2$$", False), ("x^2", True)])
+def test_latex_to_png_dvipng_runs(s, wrap):
+    """
+    Test that latex_to_png_dvipng just runs without error.
+    """
+    def mock_kpsewhich(filename):
+        assert filename == "breqn.sty"
+        return None
+
+    latextools.latex_to_png_dvipng(s, wrap)
+
+    with patch_latextool(mock_kpsewhich):
+        latextools.latex_to_png_dvipng(s, wrap)
+
+
+def mock_kpsewhich(filename):
+    assert filename == "breqn.sty"
+    return None
+
+@contextmanager
+def patch_latextool(mock=mock_kpsewhich):
+    with patch.object(latextools, "kpsewhich", mock):
+        yield
+
+@pytest.mark.parametrize('context', [no_op, patch_latextool])
+@pytest.mark.parametrize('s_wrap', [("$x^2$", False), ("x^2", True)])
+def test_latex_to_png_mpl_runs(s_wrap, context):
+    """
+    Test that latex_to_png_mpl just runs without error.
+    """
+    try:
+        import matplotlib
+    except ImportError:
+        pytest.skip("This needs matplotlib to be available")
+        return
+    s, wrap = s_wrap
+    with context():
+        latextools.latex_to_png_mpl(s, wrap)
+
+@skipif_not_matplotlib
+def test_latex_to_html():
+    img = latextools.latex_to_html("$x^2$")
+    assert "data:image/png;base64,iVBOR" in img
+
+
+def test_genelatex_no_wrap():
+    """
+    Test genelatex with wrap=False.
+    """
+    def mock_kpsewhich(filename):
+        assert False, ("kpsewhich should not be called "
+                       "(called with {0})".format(filename))
+
+    with patch_latextool(mock_kpsewhich):
+        assert '\n'.join(latextools.genelatex("body text", False)) == r'''\documentclass{article}
+\usepackage{amsmath}
+\usepackage{amsthm}
+\usepackage{amssymb}
+\usepackage{bm}
+\pagestyle{empty}
+\begin{document}
+body text
+\end{document}'''
+
+
+def test_genelatex_wrap_with_breqn():
+    """
+    Test genelatex with wrap=True for the case breqn.sty is installed.
+    """
+    def mock_kpsewhich(filename):
+        assert filename == "breqn.sty"
+        return "path/to/breqn.sty"
+
+    with patch_latextool(mock_kpsewhich):
+        assert '\n'.join(latextools.genelatex("x^2", True)) == r'''\documentclass{article}
+\usepackage{amsmath}
+\usepackage{amsthm}
+\usepackage{amssymb}
+\usepackage{bm}
+\usepackage{breqn}
+\pagestyle{empty}
+\begin{document}
+\begin{dmath*}
+x^2
+\end{dmath*}
+\end{document}'''
+
+
+def test_genelatex_wrap_without_breqn():
+    """
+    Test genelatex with wrap=True for the case breqn.sty is not installed.
+    """
+    def mock_kpsewhich(filename):
+        assert filename == "breqn.sty"
+        return None
+
+    with patch_latextool(mock_kpsewhich):
+        assert '\n'.join(latextools.genelatex("x^2", True)) == r'''\documentclass{article}
+\usepackage{amsmath}
+\usepackage{amsthm}
+\usepackage{amssymb}
+\usepackage{bm}
+\pagestyle{empty}
+\begin{document}
+$$x^2$$
+\end{document}'''
+
+
+@skipif_not_matplotlib
+@onlyif_cmds_exist('latex', 'dvipng')
+def test_latex_to_png_color():
+    """
+    Test color settings for latex_to_png.
+    """
+    latex_string = "$x^2$"
+    default_value = latextools.latex_to_png(latex_string, wrap=False)
+    default_hexblack = latextools.latex_to_png(latex_string, wrap=False,
+                                               color='#000000')
+    dvipng_default = latextools.latex_to_png_dvipng(latex_string, False)
+    dvipng_black = latextools.latex_to_png_dvipng(latex_string, False, 'Black')
+    assert dvipng_default == dvipng_black
+    mpl_default = latextools.latex_to_png_mpl(latex_string, False)
+    mpl_black = latextools.latex_to_png_mpl(latex_string, False, 'Black')
+    assert mpl_default == mpl_black
+    assert default_value in [dvipng_black, mpl_black]
+    assert default_hexblack in [dvipng_black, mpl_black]
+
+    # Test that dvips name colors can be used without error
+    dvipng_maroon = latextools.latex_to_png_dvipng(latex_string, False,
+                                                   'Maroon')
+    # And that it doesn't return the black one
+    assert dvipng_black != dvipng_maroon
+
+    mpl_maroon = latextools.latex_to_png_mpl(latex_string, False, 'Maroon')
+    assert mpl_black != mpl_maroon
+    mpl_white = latextools.latex_to_png_mpl(latex_string, False, 'White')
+    mpl_hexwhite = latextools.latex_to_png_mpl(latex_string, False, '#FFFFFF')
+    assert mpl_white == mpl_hexwhite
+
+    mpl_white_scale = latextools.latex_to_png_mpl(latex_string, False,
+                                                  'White', 1.2)
+    assert mpl_white != mpl_white_scale
+
+
+def test_latex_to_png_invalid_hex_colors():
+    """
+    Test that invalid hex colors provided to dvipng gives an exception.
+    """
+    latex_string = "$x^2$"
+    pytest.raises(
+        ValueError,
+        lambda: latextools.latex_to_png(
+            latex_string, backend="dvipng", color="#f00bar"
+        ),
+    )
+    pytest.raises(
+        ValueError,
+        lambda: latextools.latex_to_png(latex_string, backend="dvipng", color="#f00"),
+    )

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_pretty.py

@@ -0,0 +1,540 @@
+# coding: utf-8
+"""Tests for IPython.lib.pretty."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+from collections import Counter, defaultdict, deque, OrderedDict, UserList
+import os
+import pytest
+import types
+import string
+import sys
+import unittest
+
+import pytest
+
+from IPython.lib import pretty
+
+from io import StringIO
+
+
+class MyList(object):
+    def __init__(self, content):
+        self.content = content
+    def _repr_pretty_(self, p, cycle):
+        if cycle:
+            p.text("MyList(...)")
+        else:
+            with p.group(3, "MyList(", ")"):
+                for (i, child) in enumerate(self.content):
+                    if i:
+                        p.text(",")
+                        p.breakable()
+                    else:
+                        p.breakable("")
+                    p.pretty(child)
+
+
+class MyDict(dict):
+    def _repr_pretty_(self, p, cycle):
+        p.text("MyDict(...)")
+
+class MyObj(object):
+    def somemethod(self):
+        pass
+
+
+class Dummy1(object):
+    def _repr_pretty_(self, p, cycle):
+        p.text("Dummy1(...)")
+
+class Dummy2(Dummy1):
+    _repr_pretty_ = None
+
+class NoModule(object):
+    pass
+
+NoModule.__module__ = None
+
+class Breaking(object):
+    def _repr_pretty_(self, p, cycle):
+        with p.group(4,"TG: ",":"):
+            p.text("Breaking(")
+            p.break_()
+            p.text(")")
+
+class BreakingRepr(object):
+    def __repr__(self):
+        return "Breaking(\n)"
+
+class BadRepr(object):
+    def __repr__(self):
+        return 1/0
+
+
+def test_indentation():
+    """Test correct indentation in groups"""
+    count = 40
+    gotoutput = pretty.pretty(MyList(range(count)))
+    expectedoutput = "MyList(\n" + ",\n".join("   %d" % i for i in range(count)) + ")"
+
+    assert gotoutput == expectedoutput
+
+
+def test_dispatch():
+    """
+    Test correct dispatching: The _repr_pretty_ method for MyDict
+    must be found before the registered printer for dict.
+    """
+    gotoutput = pretty.pretty(MyDict())
+    expectedoutput = "MyDict(...)"
+
+    assert gotoutput == expectedoutput
+
+
+def test_callability_checking():
+    """
+    Test that the _repr_pretty_ method is tested for callability and skipped if
+    not.
+    """
+    gotoutput = pretty.pretty(Dummy2())
+    expectedoutput = "Dummy1(...)"
+
+    assert gotoutput == expectedoutput
+
+
+@pytest.mark.parametrize(
+    "obj,expected_output",
+    zip(
+        [
+            set(),
+            frozenset(),
+            set([1]),
+            frozenset([1]),
+            set([1, 2]),
+            frozenset([1, 2]),
+            set([-1, -2, -3]),
+        ],
+        [
+            "set()",
+            "frozenset()",
+            "{1}",
+            "frozenset({1})",
+            "{1, 2}",
+            "frozenset({1, 2})",
+            "{-3, -2, -1}",
+        ],
+    ),
+)
+def test_sets(obj, expected_output):
+    """
+    Test that set and frozenset use Python 3 formatting.
+    """
+    got_output = pretty.pretty(obj)
+    assert got_output == expected_output
+
+
+def test_pprint_heap_allocated_type():
+    """
+    Test that pprint works for heap allocated types.
+    """
+    module_name = "xxlimited_35"
+    expected_output = (
+        "xxlimited.Null" if sys.version_info < (3, 10, 6) else "xxlimited_35.Null"
+    )
+    xxlimited = pytest.importorskip(module_name)
+    output = pretty.pretty(xxlimited.Null)
+    assert output == expected_output
+
+
+def test_pprint_nomod():
+    """
+    Test that pprint works for classes with no __module__.
+    """
+    output = pretty.pretty(NoModule)
+    assert output == "NoModule"
+
+
+def test_pprint_break():
+    """
+    Test that p.break_ produces expected output
+    """
+    output = pretty.pretty(Breaking())
+    expected = "TG: Breaking(\n    ):"
+    assert output == expected
+
+def test_pprint_break_repr():
+    """
+    Test that p.break_ is used in repr
+    """
+    output = pretty.pretty([[BreakingRepr()]])
+    expected = "[[Breaking(\n  )]]"
+    assert output == expected
+
+    output = pretty.pretty([[BreakingRepr()]*2])
+    expected = "[[Breaking(\n  ),\n  Breaking(\n  )]]"
+    assert output == expected
+
+def test_bad_repr():
+    """Don't catch bad repr errors"""
+    with pytest.raises(ZeroDivisionError):
+        pretty.pretty(BadRepr())
+
+class BadException(Exception):
+    def __str__(self):
+        return -1
+
+class ReallyBadRepr(object):
+    __module__ = 1
+    @property
+    def __class__(self):
+        raise ValueError("I am horrible")
+
+    def __repr__(self):
+        raise BadException()
+
+def test_really_bad_repr():
+    with pytest.raises(BadException):
+        pretty.pretty(ReallyBadRepr())
+
+
+class SA(object):
+    pass
+
+class SB(SA):
+    pass
+
+class TestsPretty(unittest.TestCase):
+
+    def test_super_repr(self):
+        # "<super: module_name.SA, None>"
+        output = pretty.pretty(super(SA))
+        self.assertRegex(output, r"<super: \S+.SA, None>")
+
+        # "<super: module_name.SA, <module_name.SB at 0x...>>"
+        sb = SB()
+        output = pretty.pretty(super(SA, sb))
+        self.assertRegex(output, r"<super: \S+.SA,\s+<\S+.SB at 0x\S+>>")
+
+
+    def test_long_list(self):
+        lis = list(range(10000))
+        p = pretty.pretty(lis)
+        last2 = p.rsplit('\n', 2)[-2:]
+        self.assertEqual(last2, [' 999,', ' ...]'])
+
+    def test_long_set(self):
+        s = set(range(10000))
+        p = pretty.pretty(s)
+        last2 = p.rsplit('\n', 2)[-2:]
+        self.assertEqual(last2, [' 999,', ' ...}'])
+
+    def test_long_tuple(self):
+        tup = tuple(range(10000))
+        p = pretty.pretty(tup)
+        last2 = p.rsplit('\n', 2)[-2:]
+        self.assertEqual(last2, [' 999,', ' ...)'])
+
+    def test_long_dict(self):
+        d = { n:n for n in range(10000) }
+        p = pretty.pretty(d)
+        last2 = p.rsplit('\n', 2)[-2:]
+        self.assertEqual(last2, [' 999: 999,', ' ...}'])
+
+    def test_unbound_method(self):
+        output = pretty.pretty(MyObj.somemethod)
+        self.assertIn('MyObj.somemethod', output)
+
+
+class MetaClass(type):
+    def __new__(cls, name):
+        return type.__new__(cls, name, (object,), {'name': name})
+
+    def __repr__(self):
+        return "[CUSTOM REPR FOR CLASS %s]" % self.name
+
+
+ClassWithMeta = MetaClass('ClassWithMeta')
+
+
+def test_metaclass_repr():
+    output = pretty.pretty(ClassWithMeta)
+    assert output == "[CUSTOM REPR FOR CLASS ClassWithMeta]"
+
+
+def test_unicode_repr():
+    u = u"üniçodé"
+    ustr = u
+
+    class C(object):
+        def __repr__(self):
+            return ustr
+
+    c = C()
+    p = pretty.pretty(c)
+    assert p == u
+    p = pretty.pretty([c])
+    assert p == "[%s]" % u
+
+
+def test_basic_class():
+    def type_pprint_wrapper(obj, p, cycle):
+        if obj is MyObj:
+            type_pprint_wrapper.called = True
+        return pretty._type_pprint(obj, p, cycle)
+    type_pprint_wrapper.called = False
+
+    stream = StringIO()
+    printer = pretty.RepresentationPrinter(stream)
+    printer.type_pprinters[type] = type_pprint_wrapper
+    printer.pretty(MyObj)
+    printer.flush()
+    output = stream.getvalue()
+
+    assert output == "%s.MyObj" % __name__
+    assert type_pprint_wrapper.called is True
+
+
+def test_collections_userlist():
+    # Create userlist with cycle
+    a = UserList()
+    a.append(a)
+
+    cases = [
+        (UserList(), "UserList([])"),
+        (
+            UserList(i for i in range(1000, 1020)),
+            "UserList([1000,\n"
+            "          1001,\n"
+            "          1002,\n"
+            "          1003,\n"
+            "          1004,\n"
+            "          1005,\n"
+            "          1006,\n"
+            "          1007,\n"
+            "          1008,\n"
+            "          1009,\n"
+            "          1010,\n"
+            "          1011,\n"
+            "          1012,\n"
+            "          1013,\n"
+            "          1014,\n"
+            "          1015,\n"
+            "          1016,\n"
+            "          1017,\n"
+            "          1018,\n"
+            "          1019])",
+        ),
+        (a, "UserList([UserList(...)])"),
+    ]
+    for obj, expected in cases:
+        assert pretty.pretty(obj) == expected
+
+
+# TODO : pytest.mark.parametrise once nose is gone.
+def test_collections_defaultdict():
+    # Create defaultdicts with cycles
+    a = defaultdict()
+    a.default_factory = a
+    b = defaultdict(list)
+    b['key'] = b
+
+    # Dictionary order cannot be relied on, test against single keys.
+    cases = [
+        (defaultdict(list), 'defaultdict(list, {})'),
+        (defaultdict(list, {'key': '-' * 50}),
+         "defaultdict(list,\n"
+         "            {'key': '--------------------------------------------------'})"),
+        (a, 'defaultdict(defaultdict(...), {})'),
+        (b, "defaultdict(list, {'key': defaultdict(...)})"),
+    ]
+    for obj, expected in cases:
+        assert pretty.pretty(obj) == expected
+
+
+# TODO : pytest.mark.parametrise once nose is gone.
+def test_collections_ordereddict():
+    # Create OrderedDict with cycle
+    a = OrderedDict()
+    a['key'] = a
+
+    cases = [
+        (OrderedDict(), 'OrderedDict()'),
+        (OrderedDict((i, i) for i in range(1000, 1010)),
+         'OrderedDict([(1000, 1000),\n'
+         '             (1001, 1001),\n'
+         '             (1002, 1002),\n'
+         '             (1003, 1003),\n'
+         '             (1004, 1004),\n'
+         '             (1005, 1005),\n'
+         '             (1006, 1006),\n'
+         '             (1007, 1007),\n'
+         '             (1008, 1008),\n'
+         '             (1009, 1009)])'),
+        (a, "OrderedDict([('key', OrderedDict(...))])"),
+    ]
+    for obj, expected in cases:
+        assert pretty.pretty(obj) == expected
+
+
+# TODO : pytest.mark.parametrise once nose is gone.
+def test_collections_deque():
+    # Create deque with cycle
+    a = deque()
+    a.append(a)
+
+    cases = [
+        (deque(), 'deque([])'),
+        (deque(i for i in range(1000, 1020)),
+         'deque([1000,\n'
+         '       1001,\n'
+         '       1002,\n'
+         '       1003,\n'
+         '       1004,\n'
+         '       1005,\n'
+         '       1006,\n'
+         '       1007,\n'
+         '       1008,\n'
+         '       1009,\n'
+         '       1010,\n'
+         '       1011,\n'
+         '       1012,\n'
+         '       1013,\n'
+         '       1014,\n'
+         '       1015,\n'
+         '       1016,\n'
+         '       1017,\n'
+         '       1018,\n'
+         '       1019])'),
+        (a, 'deque([deque(...)])'),
+    ]
+    for obj, expected in cases:
+        assert pretty.pretty(obj) == expected
+
+
+# TODO : pytest.mark.parametrise once nose is gone.
+def test_collections_counter():
+    class MyCounter(Counter):
+        pass
+    cases = [
+        (Counter(), 'Counter()'),
+        (Counter(a=1), "Counter({'a': 1})"),
+        (MyCounter(a=1), "MyCounter({'a': 1})"),
+        (Counter(a=1, c=22), "Counter({'c': 22, 'a': 1})"),
+    ]
+    for obj, expected in cases:
+        assert pretty.pretty(obj) == expected
+
+# TODO : pytest.mark.parametrise once nose is gone.
+def test_mappingproxy():
+    MP = types.MappingProxyType
+    underlying_dict = {}
+    mp_recursive = MP(underlying_dict)
+    underlying_dict[2] = mp_recursive
+    underlying_dict[3] = underlying_dict
+
+    cases = [
+        (MP({}), "mappingproxy({})"),
+        (MP({None: MP({})}), "mappingproxy({None: mappingproxy({})})"),
+        (MP({k: k.upper() for k in string.ascii_lowercase}),
+         "mappingproxy({'a': 'A',\n"
+         "              'b': 'B',\n"
+         "              'c': 'C',\n"
+         "              'd': 'D',\n"
+         "              'e': 'E',\n"
+         "              'f': 'F',\n"
+         "              'g': 'G',\n"
+         "              'h': 'H',\n"
+         "              'i': 'I',\n"
+         "              'j': 'J',\n"
+         "              'k': 'K',\n"
+         "              'l': 'L',\n"
+         "              'm': 'M',\n"
+         "              'n': 'N',\n"
+         "              'o': 'O',\n"
+         "              'p': 'P',\n"
+         "              'q': 'Q',\n"
+         "              'r': 'R',\n"
+         "              's': 'S',\n"
+         "              't': 'T',\n"
+         "              'u': 'U',\n"
+         "              'v': 'V',\n"
+         "              'w': 'W',\n"
+         "              'x': 'X',\n"
+         "              'y': 'Y',\n"
+         "              'z': 'Z'})"),
+        (mp_recursive, "mappingproxy({2: {...}, 3: {2: {...}, 3: {...}}})"),
+        (underlying_dict,
+         "{2: mappingproxy({2: {...}, 3: {...}}), 3: {...}}"),
+    ]
+    for obj, expected in cases:
+        assert pretty.pretty(obj) == expected
+
+
+# TODO : pytest.mark.parametrise once nose is gone.
+def test_simplenamespace():
+    SN = types.SimpleNamespace
+
+    sn_recursive = SN()
+    sn_recursive.first = sn_recursive
+    sn_recursive.second = sn_recursive
+    cases = [
+        (SN(), "namespace()"),
+        (SN(x=SN()), "namespace(x=namespace())"),
+        (SN(a_long_name=[SN(s=string.ascii_lowercase)]*3, a_short_name=None),
+         "namespace(a_long_name=[namespace(s='abcdefghijklmnopqrstuvwxyz'),\n"
+         "                       namespace(s='abcdefghijklmnopqrstuvwxyz'),\n"
+         "                       namespace(s='abcdefghijklmnopqrstuvwxyz')],\n"
+         "          a_short_name=None)"),
+        (sn_recursive, "namespace(first=namespace(...), second=namespace(...))"),
+    ]
+    for obj, expected in cases:
+        assert pretty.pretty(obj) == expected
+
+
+def test_pretty_environ():
+    dict_repr = pretty.pretty(dict(os.environ))
+    # reindent to align with 'environ' prefix
+    dict_indented = dict_repr.replace('\n', '\n' + (' ' * len('environ')))
+    env_repr = pretty.pretty(os.environ)
+    assert env_repr == "environ" + dict_indented
+
+
+def test_function_pretty():
+    "Test pretty print of function"
+    # posixpath is a pure python module, its interface is consistent
+    # across Python distributions
+    import posixpath
+
+    assert pretty.pretty(posixpath.join) == "<function posixpath.join(a, *p)>"
+
+    # custom function
+    def meaning_of_life(question=None):
+        if question:
+            return 42
+        return "Don't panic"
+
+    assert "meaning_of_life(question=None)" in pretty.pretty(meaning_of_life)
+
+
+class OrderedCounter(Counter, OrderedDict):
+    'Counter that remembers the order elements are first encountered'
+
+    def __repr__(self):
+        return '%s(%r)' % (self.__class__.__name__, OrderedDict(self))
+
+    def __reduce__(self):
+        return self.__class__, (OrderedDict(self),)
+
+class MySet(set):  # Override repr of a basic type
+    def __repr__(self):
+        return 'mine'
+
+def test_custom_repr():
+    """A custom repr should override a pretty printer for a parent type"""
+    oc = OrderedCounter("abracadabra")
+    assert "OrderedCounter(OrderedDict" in pretty.pretty(oc)
+
+    assert pretty.pretty(MySet()) == "mine"

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_pygments.py

@@ -0,0 +1,26 @@
+from typing import List
+
+import pytest
+import pygments.lexers
+import pygments.lexer
+
+from IPython.lib.lexers import IPythonConsoleLexer, IPythonLexer, IPython3Lexer
+
+#: the human-readable names of the IPython lexers with ``entry_points``
+EXPECTED_LEXER_NAMES = [
+    cls.name for cls in [IPythonConsoleLexer, IPythonLexer, IPython3Lexer]
+]
+
+
+@pytest.fixture
+def all_pygments_lexer_names() -> List[str]:
+    """Get all lexer names registered in pygments."""
+    return {l[0] for l in pygments.lexers.get_all_lexers()}
+
+
+@pytest.mark.parametrize("expected_lexer", EXPECTED_LEXER_NAMES)
+def test_pygments_entry_points(
+    expected_lexer: str, all_pygments_lexer_names: List[str]
+) -> None:
+    """Check whether the ``entry_points`` for ``pygments.lexers`` are correct."""
+    assert expected_lexer in all_pygments_lexer_names

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/setters.py

@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: MIT
+
+from attr.setters import *  # noqa: F403

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/defusedxml-0.7.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/defusedxml-0.7.1.dist-info/LICENSE

@@ -0,0 +1,49 @@
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF
+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+license to reproduce, analyze, test, perform and/or display publicly,
+prepare derivative works, distribute, and otherwise use Python
+alone or in any derivative version, provided, however, that PSF's
+License Agreement and PSF's notice of copyright, i.e., "Copyright (c)
+2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Python Software Foundation; 
+All Rights Reserved" are retained in Python alone or in any derivative 
+version prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee.  This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/defusedxml-0.7.1.dist-info/METADATA

@@ -0,0 +1,978 @@
+Metadata-Version: 2.1
+Name: defusedxml
+Version: 0.7.1
+Summary: XML bomb protection for Python stdlib modules
+Home-page: https://github.com/tiran/defusedxml
+Author: Christian Heimes
+Author-email: christian@python.org
+Maintainer: Christian Heimes
+Maintainer-email: christian@python.org
+License: PSFL
+Download-URL: https://pypi.python.org/pypi/defusedxml
+Keywords: xml bomb DoS
+Platform: all
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Python Software Foundation License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Topic :: Text Processing :: Markup :: XML
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*
+
+===================================================
+defusedxml -- defusing XML bombs and other exploits
+===================================================
+
+.. image:: https://img.shields.io/pypi/v/defusedxml.svg
+    :target: https://pypi.org/project/defusedxml/
+    :alt: Latest Version
+
+.. image:: https://img.shields.io/pypi/pyversions/defusedxml.svg
+    :target: https://pypi.org/project/defusedxml/
+    :alt: Supported Python versions
+
+.. image:: https://travis-ci.org/tiran/defusedxml.svg?branch=master
+    :target: https://travis-ci.org/tiran/defusedxml
+    :alt: Travis CI
+
+.. image:: https://codecov.io/github/tiran/defusedxml/coverage.svg?branch=master
+    :target: https://codecov.io/github/tiran/defusedxml?branch=master
+    :alt: codecov
+
+.. image:: https://img.shields.io/pypi/dm/defusedxml.svg
+    :target: https://pypistats.org/packages/defusedxml
+    :alt: PyPI downloads
+
+.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
+    :target: https://github.com/psf/black
+    :alt: Code style: black
+
+..
+
+    "It's just XML, what could probably go wrong?"
+
+Christian Heimes <christian@python.org>
+
+Synopsis
+========
+
+The results of an attack on a vulnerable XML library can be fairly dramatic.
+With just a few hundred **Bytes** of XML data an attacker can occupy several
+**Gigabytes** of memory within **seconds**. An attacker can also keep
+CPUs busy for a long time with a small to medium size request. Under some
+circumstances it is even possible to access local files on your
+server, to circumvent a firewall, or to abuse services to rebound attacks to
+third parties.
+
+The attacks use and abuse less common features of XML and its parsers. The
+majority of developers are unacquainted with features such as processing
+instructions and entity expansions that XML inherited from SGML. At best
+they know about ``<!DOCTYPE>`` from experience with HTML but they are not
+aware that a document type definition (DTD) can generate an HTTP request
+or load a file from the file system.
+
+None of the issues is new. They have been known for a long time. Billion
+laughs was first reported in 2003. Nevertheless some XML libraries and
+applications are still vulnerable and even heavy users of XML are
+surprised by these features. It's hard to say whom to blame for the
+situation. It's too short sighted to shift all blame on XML parsers and
+XML libraries for using insecure default settings. After all they
+properly implement XML specifications. Application developers must not rely
+that a library is always configured for security and potential harmful data
+by default.
+
+
+.. contents:: Table of Contents
+   :depth: 2
+
+
+Attack vectors
+==============
+
+billion laughs / exponential entity expansion
+---------------------------------------------
+
+The `Billion Laughs`_ attack -- also known as exponential entity expansion --
+uses multiple levels of nested entities. The original example uses 9 levels
+of 10 expansions in each level to expand the string ``lol`` to a string of
+3 * 10 :sup:`9` bytes, hence the name "billion laughs". The resulting string
+occupies 3 GB (2.79 GiB) of memory; intermediate strings require additional
+memory. Because most parsers don't cache the intermediate step for every
+expansion it is repeated over and over again. It increases the CPU load even
+more.
+
+An XML document of just a few hundred bytes can disrupt all services on a
+machine within seconds.
+
+Example XML::
+
+    <!DOCTYPE xmlbomb [
+    <!ENTITY a "1234567890" >
+    <!ENTITY b "&a;&a;&a;&a;&a;&a;&a;&a;">
+    <!ENTITY c "&b;&b;&b;&b;&b;&b;&b;&b;">
+    <!ENTITY d "&c;&c;&c;&c;&c;&c;&c;&c;">
+    ]>
+    <bomb>&d;</bomb>
+
+
+quadratic blowup entity expansion
+---------------------------------
+
+A quadratic blowup attack is similar to a `Billion Laughs`_ attack; it abuses
+entity expansion, too. Instead of nested entities it repeats one large entity
+with a couple of thousand chars over and over again. The attack isn't as
+efficient as the exponential case but it avoids triggering countermeasures of
+parsers against heavily nested entities. Some parsers limit the depth and
+breadth of a single entity but not the total amount of expanded text
+throughout an entire XML document.
+
+A medium-sized XML document with a couple of hundred kilobytes can require a
+couple of hundred MB to several GB of memory. When the attack is combined
+with some level of nested expansion an attacker is able to achieve a higher
+ratio of success.
+
+::
+
+    <!DOCTYPE bomb [
+    <!ENTITY a "xxxxxxx... a couple of ten thousand chars">
+    ]>
+    <bomb>&a;&a;&a;... repeat</bomb>
+
+
+external entity expansion (remote)
+----------------------------------
+
+Entity declarations can contain more than just text for replacement. They can
+also point to external resources by public identifiers or system identifiers.
+System identifiers are standard URIs. When the URI is a URL (e.g. a
+``http://`` locator) some parsers download the resource from the remote
+location and embed them into the XML document verbatim.
+
+Simple example of a parsed external entity::
+
+    <!DOCTYPE external [
+    <!ENTITY ee SYSTEM "http://www.python.org/some.xml">
+    ]>
+    <root>&ee;</root>
+
+The case of parsed external entities works only for valid XML content. The
+XML standard also supports unparsed external entities with a
+``NData declaration``.
+
+External entity expansion opens the door to plenty of exploits. An attacker
+can abuse a vulnerable XML library and application to rebound and forward
+network requests with the IP address of the server. It highly depends
+on the parser and the application what kind of exploit is possible. For
+example:
+
+* An attacker can circumvent firewalls and gain access to restricted
+  resources as all the requests are made from an internal and trustworthy
+  IP address, not from the outside.
+* An attacker can abuse a service to attack, spy on or DoS your servers but
+  also third party services. The attack is disguised with the IP address of
+  the server and the attacker is able to utilize the high bandwidth of a big
+  machine.
+* An attacker can exhaust additional resources on the machine, e.g. with
+  requests to a service that doesn't respond or responds with very large
+  files.
+* An attacker may gain knowledge, when, how often and from which IP address
+  an XML document is accessed.
+* An attacker could send mail from inside your network if the URL handler
+  supports ``smtp://`` URIs.
+
+
+external entity expansion (local file)
+--------------------------------------
+
+External entities with references to local files are a sub-case of external
+entity expansion. It's listed as an extra attack because it deserves extra
+attention. Some XML libraries such as lxml disable network access by default
+but still allow entity expansion with local file access by default. Local
+files are either referenced with a ``file://`` URL or by a file path (either
+relative or absolute).
+
+An attacker may be able to access and download all files that can be read by
+the application process. This may include critical configuration files, too.
+
+::
+
+    <!DOCTYPE external [
+    <!ENTITY ee SYSTEM "file:///PATH/TO/simple.xml">
+    ]>
+    <root>&ee;</root>
+
+
+DTD retrieval
+-------------
+
+This case is similar to external entity expansion, too. Some XML libraries
+like Python's xml.dom.pulldom retrieve document type definitions from remote
+or local locations. Several attack scenarios from the external entity case
+apply to this issue as well.
+
+::
+
+    <?xml version="1.0" encoding="utf-8"?>
+    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+      "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+    <html>
+        <head/>
+        <body>text</body>
+    </html>
+
+
+Python XML Libraries
+====================
+
+.. csv-table:: vulnerabilities and features
+   :header: "kind", "sax", "etree", "minidom", "pulldom", "xmlrpc", "lxml", "genshi"
+   :widths: 24, 7, 8, 8, 7, 8, 8, 8
+   :stub-columns: 0
+
+   "billion laughs", "**True**", "**True**", "**True**", "**True**", "**True**", "False (1)", "False (5)"
+   "quadratic blowup", "**True**", "**True**", "**True**", "**True**", "**True**", "**True**", "False (5)"
+   "external entity expansion (remote)", "**True**", "False (3)", "False (4)", "**True**", "false", "False (1)", "False (5)"
+   "external entity expansion (local file)", "**True**", "False (3)", "False (4)", "**True**", "false", "**True**", "False (5)"
+   "DTD retrieval", "**True**", "False", "False", "**True**", "false", "False (1)", "False"
+   "gzip bomb", "False", "False", "False", "False", "**True**", "**partly** (2)", "False"
+   "xpath support (7)", "False", "False", "False", "False", "False", "**True**", "False"
+   "xsl(t) support (7)", "False", "False", "False", "False", "False", "**True**", "False"
+   "xinclude support (7)", "False", "**True** (6)", "False", "False", "False", "**True** (6)", "**True**"
+   "C library", "expat", "expat", "expat", "expat", "expat", "libxml2", "expat"
+
+1. Lxml is protected against billion laughs attacks and doesn't do network
+   lookups by default.
+2. libxml2 and lxml are not directly vulnerable to gzip decompression bombs
+   but they don't protect you against them either.
+3. xml.etree doesn't expand entities and raises a ParserError when an entity
+   occurs.
+4. minidom doesn't expand entities and simply returns the unexpanded entity
+   verbatim.
+5. genshi.input of genshi 0.6 doesn't support entity expansion and raises a
+   ParserError when an entity occurs.
+6. Library has (limited) XInclude support but requires an additional step to
+   process inclusion.
+7. These are features but they may introduce exploitable holes, see
+   `Other things to consider`_
+
+
+Settings in standard library
+----------------------------
+
+
+xml.sax.handler Features
+........................
+
+feature_external_ges (http://xml.org/sax/features/external-general-entities)
+  disables external entity expansion
+
+feature_external_pes (http://xml.org/sax/features/external-parameter-entities)
+  the option is ignored and doesn't modify any functionality
+
+DOM xml.dom.xmlbuilder.Options
+..............................
+
+external_parameter_entities
+  ignored
+
+external_general_entities
+  ignored
+
+external_dtd_subset
+  ignored
+
+entities
+  unsure
+
+
+defusedxml
+==========
+
+The `defusedxml package`_ (`defusedxml on PyPI`_)
+contains several Python-only workarounds and fixes
+for denial of service and other vulnerabilities in Python's XML libraries.
+In order to benefit from the protection you just have to import and use the
+listed functions / classes from the right defusedxml module instead of the
+original module. Merely `defusedxml.xmlrpc`_ is implemented as monkey patch.
+
+Instead of::
+
+   >>> from xml.etree.ElementTree import parse
+   >>> et = parse(xmlfile)
+
+alter code to::
+
+   >>> from defusedxml.ElementTree import parse
+   >>> et = parse(xmlfile)
+
+Additionally the package has an **untested** function to monkey patch
+all stdlib modules with ``defusedxml.defuse_stdlib()``.
+
+All functions and parser classes accept three additional keyword arguments.
+They return either the same objects as the original functions or compatible
+subclasses.
+
+forbid_dtd (default: False)
+  disallow XML with a ``<!DOCTYPE>`` processing instruction and raise a
+  *DTDForbidden* exception when a DTD processing instruction is found.
+
+forbid_entities (default: True)
+  disallow XML with ``<!ENTITY>`` declarations inside the DTD and raise an
+  *EntitiesForbidden* exception when an entity is declared.
+
+forbid_external (default: True)
+  disallow any access to remote or local resources in external entities
+  or DTD and raising an *ExternalReferenceForbidden* exception when a DTD
+  or entity references an external resource.
+
+
+defusedxml (package)
+--------------------
+
+DefusedXmlException, DTDForbidden, EntitiesForbidden,
+ExternalReferenceForbidden, NotSupportedError
+
+defuse_stdlib() (*experimental*)
+
+
+defusedxml.cElementTree
+-----------------------
+
+**NOTE** ``defusedxml.cElementTree`` is deprecated and will be removed in a
+future release. Import from ``defusedxml.ElementTree`` instead.
+
+parse(), iterparse(), fromstring(), XMLParser
+
+
+defusedxml.ElementTree
+-----------------------
+
+parse(), iterparse(), fromstring(), XMLParser
+
+
+defusedxml.expatreader
+----------------------
+
+create_parser(), DefusedExpatParser
+
+
+defusedxml.sax
+--------------
+
+parse(), parseString(), make_parser()
+
+
+defusedxml.expatbuilder
+-----------------------
+
+parse(), parseString(), DefusedExpatBuilder, DefusedExpatBuilderNS
+
+
+defusedxml.minidom
+------------------
+
+parse(), parseString()
+
+
+defusedxml.pulldom
+------------------
+
+parse(), parseString()
+
+
+defusedxml.xmlrpc
+-----------------
+
+The fix is implemented as monkey patch for the stdlib's xmlrpc package (3.x)
+or xmlrpclib module (2.x). The function `monkey_patch()` enables the fixes,
+`unmonkey_patch()` removes the patch and puts the code in its former state.
+
+The monkey patch protects against XML related attacks as well as
+decompression bombs and excessively large requests or responses. The default
+setting is 30 MB for requests, responses and gzip decompression. You can
+modify the default by changing the module variable `MAX_DATA`. A value of
+`-1` disables the limit.
+
+
+defusedxml.lxml
+---------------
+
+**DEPRECATED** The module is deprecated and will be removed in a future
+release.
+
+The module acts as an *example* how you could protect code that uses
+lxml.etree. It implements a custom Element class that filters out
+Entity instances, a custom parser factory and a thread local storage for
+parser instances. It also has a check_docinfo() function which inspects
+a tree for internal or external DTDs and entity declarations. In order to
+check for entities lxml > 3.0 is required.
+
+parse(), fromstring()
+RestrictedElement, GlobalParserTLS, getDefaultParser(), check_docinfo()
+
+
+defusedexpat
+============
+
+The `defusedexpat package`_ (`defusedexpat on PyPI`_)
+comes with binary extensions and a
+`modified expat`_ library instead of the standard `expat parser`_. It's
+basically a stand-alone version of the patches for Python's standard
+library C extensions.
+
+Modifications in expat
+----------------------
+
+new definitions::
+
+  XML_BOMB_PROTECTION
+  XML_DEFAULT_MAX_ENTITY_INDIRECTIONS
+  XML_DEFAULT_MAX_ENTITY_EXPANSIONS
+  XML_DEFAULT_RESET_DTD
+
+new XML_FeatureEnum members::
+
+  XML_FEATURE_MAX_ENTITY_INDIRECTIONS
+  XML_FEATURE_MAX_ENTITY_EXPANSIONS
+  XML_FEATURE_IGNORE_DTD
+
+new XML_Error members::
+
+  XML_ERROR_ENTITY_INDIRECTIONS
+  XML_ERROR_ENTITY_EXPANSION
+
+new API functions::
+
+  int XML_GetFeature(XML_Parser parser,
+                     enum XML_FeatureEnum feature,
+                     long *value);
+  int XML_SetFeature(XML_Parser parser,
+                     enum XML_FeatureEnum feature,
+                     long value);
+  int XML_GetFeatureDefault(enum XML_FeatureEnum feature,
+                            long *value);
+  int XML_SetFeatureDefault(enum XML_FeatureEnum feature,
+                            long value);
+
+XML_FEATURE_MAX_ENTITY_INDIRECTIONS
+   Limit the amount of indirections that are allowed to occur during the
+   expansion of a nested entity. A counter starts when an entity reference
+   is encountered. It resets after the entity is fully expanded. The limit
+   protects the parser against exponential entity expansion attacks (aka
+   billion laughs attack). When the limit is exceeded the parser stops and
+   fails with `XML_ERROR_ENTITY_INDIRECTIONS`.
+   A value of 0 disables the protection.
+
+   Supported range
+     0 .. UINT_MAX
+   Default
+     40
+
+XML_FEATURE_MAX_ENTITY_EXPANSIONS
+   Limit the total length of all entity expansions throughout the entire
+   document. The lengths of all entities are accumulated in a parser variable.
+   The setting protects against quadratic blowup attacks (lots of expansions
+   of a large entity declaration). When the sum of all entities exceeds
+   the limit, the parser stops and fails with `XML_ERROR_ENTITY_EXPANSION`.
+   A value of 0 disables the protection.
+
+   Supported range
+     0 .. UINT_MAX
+   Default
+     8 MiB
+
+XML_FEATURE_RESET_DTD
+   Reset all DTD information after the <!DOCTYPE> block has been parsed. When
+   the flag is set (default: false) all DTD information after the
+   endDoctypeDeclHandler has been called. The flag can be set inside the
+   endDoctypeDeclHandler. Without DTD information any entity reference in
+   the document body leads to `XML_ERROR_UNDEFINED_ENTITY`.
+
+   Supported range
+     0, 1
+   Default
+     0
+
+
+How to avoid XML vulnerabilities
+================================
+
+Best practices
+--------------
+
+* Don't allow DTDs
+* Don't expand entities
+* Don't resolve externals
+* Limit parse depth
+* Limit total input size
+* Limit parse time
+* Favor a SAX or iterparse-like parser for potential large data
+* Validate and properly quote arguments to XSL transformations and
+  XPath queries
+* Don't use XPath expression from untrusted sources
+* Don't apply XSL transformations that come untrusted sources
+
+(based on Brad Hill's `Attacking XML Security`_)
+
+
+Other things to consider
+========================
+
+XML, XML parsers and processing libraries have more features and possible
+issue that could lead to DoS vulnerabilities or security exploits in
+applications. I have compiled an incomplete list of theoretical issues that
+need further research and more attention. The list is deliberately pessimistic
+and a bit paranoid, too. It contains things that might go wrong under daffy
+circumstances.
+
+
+attribute blowup / hash collision attack
+----------------------------------------
+
+XML parsers may use an algorithm with quadratic runtime O(n :sup:`2`) to
+handle attributes and namespaces. If it uses hash tables (dictionaries) to
+store attributes and namespaces the implementation may be vulnerable to
+hash collision attacks, thus reducing the performance to O(n :sup:`2`) again.
+In either case an attacker is able to forge a denial of service attack with
+an XML document that contains thousands upon thousands of attributes in
+a single node.
+
+I haven't researched yet if expat, pyexpat or libxml2 are vulnerable.
+
+
+decompression bomb
+------------------
+
+The issue of decompression bombs (aka `ZIP bomb`_) apply to all XML libraries
+that can parse compressed XML stream like gzipped HTTP streams or LZMA-ed
+files. For an attacker it can reduce the amount of transmitted data by three
+magnitudes or more. Gzip is able to compress 1 GiB zeros to roughly 1 MB,
+lzma is even better::
+
+    $ dd if=/dev/zero bs=1M count=1024 | gzip > zeros.gz
+    $ dd if=/dev/zero bs=1M count=1024 | lzma -z > zeros.xy
+    $ ls -sh zeros.*
+    1020K zeros.gz
+     148K zeros.xy
+
+None of Python's standard XML libraries decompress streams except for
+``xmlrpclib``. The module is vulnerable <https://bugs.python.org/issue16043>
+to decompression bombs.
+
+lxml can load and process compressed data through libxml2 transparently.
+libxml2 can handle even very large blobs of compressed data efficiently
+without using too much memory. But it doesn't protect applications from
+decompression bombs. A carefully written SAX or iterparse-like approach can
+be safe.
+
+
+Processing Instruction
+----------------------
+
+`PI`_'s like::
+
+  <?xml-stylesheet type="text/xsl" href="style.xsl"?>
+
+may impose more threats for XML processing. It depends if and how a
+processor handles processing instructions. The issue of URL retrieval with
+network or local file access apply to processing instructions, too.
+
+
+Other DTD features
+------------------
+
+`DTD`_ has more features like ``<!NOTATION>``. I haven't researched how
+these features may be a security threat.
+
+
+XPath
+-----
+
+XPath statements may introduce DoS vulnerabilities. Code should never execute
+queries from untrusted sources. An attacker may also be able to create an XML
+document that makes certain XPath queries costly or resource hungry.
+
+
+XPath injection attacks
+-----------------------
+
+XPath injeciton attacks pretty much work like SQL injection attacks.
+Arguments to XPath queries must be quoted and validated properly, especially
+when they are taken from the user. The page `Avoid the dangers of XPath injection`_
+list some ramifications of XPath injections.
+
+Python's standard library doesn't have XPath support. Lxml supports
+parameterized XPath queries which does proper quoting. You just have to use
+its xpath() method correctly::
+
+   # DON'T
+   >>> tree.xpath("/tag[@id='%s']" % value)
+
+   # instead do
+   >>> tree.xpath("/tag[@id=$tagid]", tagid=name)
+
+
+XInclude
+--------
+
+`XML Inclusion`_ is another way to load and include external files::
+
+   <root xmlns:xi="http://www.w3.org/2001/XInclude">
+     <xi:include href="filename.txt" parse="text" />
+   </root>
+
+This feature should be disabled when XML files from an untrusted source are
+processed. Some Python XML libraries and libxml2 support XInclude but don't
+have an option to sandbox inclusion and limit it to allowed directories.
+
+
+XMLSchema location
+------------------
+
+A validating XML parser may download schema files from the information in a
+``xsi:schemaLocation`` attribute.
+
+::
+
+  <ead xmlns="urn:isbn:1-931666-22-9"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:schemaLocation="urn:isbn:1-931666-22-9 http://www.loc.gov/ead/ead.xsd">
+  </ead>
+
+
+XSL Transformation
+------------------
+
+You should keep in mind that XSLT is a Turing complete language. Never
+process XSLT code from unknown or untrusted source! XSLT processors may
+allow you to interact with external resources in ways you can't even imagine.
+Some processors even support extensions that allow read/write access to file
+system, access to JRE objects or scripting with Jython.
+
+Example from `Attacking XML Security`_ for Xalan-J::
+
+    <xsl:stylesheet version="1.0"
+     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+     xmlns:rt="http://xml.apache.org/xalan/java/java.lang.Runtime"
+     xmlns:ob="http://xml.apache.org/xalan/java/java.lang.Object"
+     exclude-result-prefixes= "rt ob">
+     <xsl:template match="/">
+       <xsl:variable name="runtimeObject" select="rt:getRuntime()"/>
+       <xsl:variable name="command"
+         select="rt:exec($runtimeObject, &apos;c:\Windows\system32\cmd.exe&apos;)"/>
+       <xsl:variable name="commandAsString" select="ob:toString($command)"/>
+       <xsl:value-of select="$commandAsString"/>
+     </xsl:template>
+    </xsl:stylesheet>
+
+
+Related CVEs
+============
+
+CVE-2013-1664
+  Unrestricted entity expansion induces DoS vulnerabilities in Python XML
+  libraries (XML bomb)
+
+CVE-2013-1665
+  External entity expansion in Python XML libraries inflicts potential
+  security flaws and DoS vulnerabilities
+
+
+Other languages / frameworks
+=============================
+
+Several other programming languages and frameworks are vulnerable as well. A
+couple of them are affected by the fact that libxml2 up to 2.9.0 has no
+protection against quadratic blowup attacks. Most of them have potential
+dangerous default settings for entity expansion and external entities, too.
+
+Perl
+----
+
+Perl's XML::Simple is vulnerable to quadratic entity expansion and external
+entity expansion (both local and remote).
+
+
+Ruby
+----
+
+Ruby's REXML document parser is vulnerable to entity expansion attacks
+(both quadratic and exponential) but it doesn't do external entity
+expansion by default. In order to counteract entity expansion you have to
+disable the feature::
+
+  REXML::Document.entity_expansion_limit = 0
+
+libxml-ruby and hpricot don't expand entities in their default configuration.
+
+
+PHP
+---
+
+PHP's SimpleXML API is vulnerable to quadratic entity expansion and loads
+entities from local and remote resources. The option ``LIBXML_NONET`` disables
+network access but still allows local file access. ``LIBXML_NOENT`` seems to
+have no effect on entity expansion in PHP 5.4.6.
+
+
+C# / .NET / Mono
+----------------
+
+Information in `XML DoS and Defenses (MSDN)`_ suggest that .NET is
+vulnerable with its default settings. The article contains code snippets
+how to create a secure XML reader::
+
+  XmlReaderSettings settings = new XmlReaderSettings();
+  settings.ProhibitDtd = false;
+  settings.MaxCharactersFromEntities = 1024;
+  settings.XmlResolver = null;
+  XmlReader reader = XmlReader.Create(stream, settings);
+
+
+Java
+----
+
+Untested. The documentation of Xerces and its `Xerces SecurityMananger`_
+sounds like Xerces is also vulnerable to billion laugh attacks with its
+default settings. It also does entity resolving when an
+``org.xml.sax.EntityResolver`` is configured. I'm not yet sure about the
+default setting here.
+
+Java specialists suggest to have a custom builder factory::
+
+  DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
+  builderFactory.setXIncludeAware(False);
+  builderFactory.setExpandEntityReferences(False);
+  builderFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, True);
+  # either
+  builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", True);
+  # or if you need DTDs
+  builderFactory.setFeature("http://xml.org/sax/features/external-general-entities", False);
+  builderFactory.setFeature("http://xml.org/sax/features/external-parameter-entities", False);
+  builderFactory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", False);
+  builderFactory.setFeature("http://apache.org/xml/features/nonvalidating/load-dtd-grammar", False);
+
+
+TODO
+====
+
+* DOM: Use xml.dom.xmlbuilder options for entity handling
+* SAX: take feature_external_ges and feature_external_pes (?) into account
+* test experimental monkey patching of stdlib modules
+* improve documentation
+
+
+License
+=======
+
+Copyright (c) 2013-2017 by Christian Heimes <christian@python.org>
+
+Licensed to PSF under a Contributor Agreement.
+
+See https://www.python.org/psf/license for licensing details.
+
+
+Acknowledgements
+================
+
+Brett Cannon (Python Core developer)
+  review and code cleanup
+
+Antoine Pitrou (Python Core developer)
+  code review
+
+Aaron Patterson, Ben Murphy and Michael Koziarski (Ruby community)
+  Many thanks to Aaron, Ben and Michael from the Ruby community for their
+  report and assistance.
+
+Thierry Carrez (OpenStack)
+  Many thanks to Thierry for his report to the Python Security Response
+  Team on behalf of the OpenStack security team.
+
+Carl Meyer (Django)
+  Many thanks to Carl for his report to PSRT on behalf of the Django security
+  team.
+
+Daniel Veillard (libxml2)
+  Many thanks to Daniel for his insight and assistance with libxml2.
+
+semantics GmbH (https://www.semantics.de/)
+  Many thanks to my employer semantics for letting me work on the issue
+  during working hours as part of semantics's open source initiative.
+
+
+References
+==========
+
+* `XML DoS and Defenses (MSDN)`_
+* `Billion Laughs`_ on Wikipedia
+* `ZIP bomb`_ on Wikipedia
+* `Configure SAX parsers for secure processing`_
+* `Testing for XML Injection`_
+
+.. _defusedxml package: https://github.com/tiran/defusedxml
+.. _defusedxml on PyPI: https://pypi.python.org/pypi/defusedxml
+.. _defusedexpat package: https://github.com/tiran/defusedexpat
+.. _defusedexpat on PyPI: https://pypi.python.org/pypi/defusedexpat
+.. _modified expat: https://github.com/tiran/expat
+.. _expat parser: http://expat.sourceforge.net/
+.. _Attacking XML Security: https://www.isecpartners.com/media/12976/iSEC-HILL-Attacking-XML-Security-bh07.pdf
+.. _Billion Laughs: https://en.wikipedia.org/wiki/Billion_laughs
+.. _XML DoS and Defenses (MSDN): https://msdn.microsoft.com/en-us/magazine/ee335713.aspx
+.. _ZIP bomb: https://en.wikipedia.org/wiki/Zip_bomb
+.. _DTD: https://en.wikipedia.org/wiki/Document_Type_Definition
+.. _PI: https://en.wikipedia.org/wiki/Processing_Instruction
+.. _Avoid the dangers of XPath injection: http://www.ibm.com/developerworks/xml/library/x-xpathinjection/index.html
+.. _Configure SAX parsers for secure processing: http://www.ibm.com/developerworks/xml/library/x-tipcfsx/index.html
+.. _Testing for XML Injection: https://www.owasp.org/index.php/Testing_for_XML_Injection_(OWASP-DV-008)
+.. _Xerces SecurityMananger: https://xerces.apache.org/xerces2-j/javadocs/xerces2/org/apache/xerces/util/SecurityManager.html
+.. _XML Inclusion: https://www.w3.org/TR/xinclude/#include_element
+
+Changelog
+=========
+
+defusedxml 0.7.1
+---------------------
+
+*Release date: 08-Mar-2021*
+
+- Fix regression ``defusedxml.ElementTree.ParseError`` (#63)
+  The ``ParseError`` exception is now the same class object as
+  ``xml.etree.ElementTree.ParseError`` again.
+
+
+defusedxml 0.7.0
+----------------
+
+*Release date: 4-Mar-2021*
+
+- No changes
+
+
+defusedxml 0.7.0rc2
+-------------------
+
+*Release date: 12-Jan-2021*
+
+- Re-add and deprecate ``defusedxml.cElementTree``
+- Use GitHub Actions instead of TravisCI
+- Restore ``ElementTree`` attribute of ``xml.etree`` module after patching
+
+defusedxml 0.7.0rc1
+-------------------
+
+*Release date: 04-May-2020*
+
+- Add support for Python 3.9
+- ``defusedxml.cElementTree`` is not available with Python 3.9.
+- Python 2 is deprecate. Support for Python 2 will be removed in 0.8.0.
+
+
+defusedxml 0.6.0
+----------------
+
+*Release date: 17-Apr-2019*
+
+- Increase test coverage.
+- Add badges to README.
+
+
+defusedxml 0.6.0rc1
+-------------------
+
+*Release date: 14-Apr-2019*
+
+- Test on Python 3.7 stable and 3.8-dev
+- Drop support for Python 3.4
+- No longer pass *html* argument to XMLParse. It has been deprecated and
+  ignored for a long time. The DefusedXMLParser still takes a html argument.
+  A deprecation warning is issued when the argument is False and a TypeError
+  when it's True.
+- defusedxml now fails early when pyexpat stdlib module is not available or
+  broken.
+- defusedxml.ElementTree.__all__ now lists ParseError as public attribute.
+- The defusedxml.ElementTree and defusedxml.cElementTree modules had a typo
+  and used XMLParse instead of XMLParser as an alias for DefusedXMLParser.
+  Both the old and fixed name are now available.
+
+
+defusedxml 0.5.0
+----------------
+
+*Release date: 07-Feb-2017*
+
+- No changes
+
+
+defusedxml 0.5.0.rc1
+--------------------
+
+*Release date: 28-Jan-2017*
+
+- Add compatibility with Python 3.6
+- Drop support for Python 2.6, 3.1, 3.2, 3.3
+- Fix lxml tests (XMLSyntaxError: Detected an entity reference loop)
+
+
+defusedxml 0.4.1
+----------------
+
+*Release date: 28-Mar-2013*
+
+- Add more demo exploits, e.g. python_external.py and Xalan XSLT demos.
+- Improved documentation.
+
+
+defusedxml 0.4
+--------------
+
+*Release date: 25-Feb-2013*
+
+- As per http://seclists.org/oss-sec/2013/q1/340 please REJECT
+  CVE-2013-0278, CVE-2013-0279 and CVE-2013-0280 and use CVE-2013-1664,
+  CVE-2013-1665 for OpenStack/etc.
+- Add missing parser_list argument to sax.make_parser(). The argument is
+  ignored, though. (thanks to Florian Apolloner)
+- Add demo exploit for external entity attack on Python's SAX parser, XML-RPC
+  and WebDAV.
+
+
+defusedxml 0.3
+--------------
+
+*Release date: 19-Feb-2013*
+
+- Improve documentation
+
+
+defusedxml 0.2
+--------------
+
+*Release date: 15-Feb-2013*
+
+- Rename ExternalEntitiesForbidden to ExternalReferenceForbidden
+- Rename defusedxml.lxml.check_dtd() to check_docinfo()
+- Unify argument names in callbacks
+- Add arguments and formatted representation to exceptions
+- Add forbid_external argument to all functions and classes
+- More tests
+- LOTS of documentation
+- Add example code for other languages (Ruby, Perl, PHP) and parsers (Genshi)
+- Add protection against XML and gzip attacks to xmlrpclib
+
+defusedxml 0.1
+--------------
+
+*Release date: 08-Feb-2013*
+
+- Initial and internal release for PSRT review
+
+

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/defusedxml-0.7.1.dist-info/RECORD

@@ -0,0 +1,28 @@
+defusedxml-0.7.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+defusedxml-0.7.1.dist-info/LICENSE,sha256=uAzp2oxCofkQeWJ_u-K_JyEK4Qig_-Xwd9WwjgdsJMg,2409
+defusedxml-0.7.1.dist-info/METADATA,sha256=Np0872SHDa-En7pxHLjQWn7-PI2asPdjrcNAef43i7E,32518
+defusedxml-0.7.1.dist-info/RECORD,,
+defusedxml-0.7.1.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
+defusedxml-0.7.1.dist-info/top_level.txt,sha256=QGHa90F50pVKhWSFlERI0jtSKtqDiGyfeZX7dQNZAAw,11
+defusedxml/ElementTree.py,sha256=GLSqpCz58oXGPGyzf_HylsPS9_dcGVP5SN4dK7yvyPw,4640
+defusedxml/__init__.py,sha256=RczeaVJG64p2Fgy1jlCzbuRdchEPnEaCBrxgk8JJ_pM,1444
+defusedxml/__pycache__/ElementTree.cpython-310.pyc,,
+defusedxml/__pycache__/__init__.cpython-310.pyc,,
+defusedxml/__pycache__/cElementTree.cpython-310.pyc,,
+defusedxml/__pycache__/common.cpython-310.pyc,,
+defusedxml/__pycache__/expatbuilder.cpython-310.pyc,,
+defusedxml/__pycache__/expatreader.cpython-310.pyc,,
+defusedxml/__pycache__/lxml.cpython-310.pyc,,
+defusedxml/__pycache__/minidom.cpython-310.pyc,,
+defusedxml/__pycache__/pulldom.cpython-310.pyc,,
+defusedxml/__pycache__/sax.cpython-310.pyc,,
+defusedxml/__pycache__/xmlrpc.cpython-310.pyc,,
+defusedxml/cElementTree.py,sha256=PpaKMh3rU29sY8amAK4fzHQKl8gcAYD0h1LCoW62Rtk,1449
+defusedxml/common.py,sha256=3d26jNW4fNXzgjWhvUfs83Afiz5EVxFDupQbugkSMZc,4036
+defusedxml/expatbuilder.py,sha256=b4Q05vsBMJ5StkiTFf4my2rGGo1gZyEl_hC5MeFTOAA,3732
+defusedxml/expatreader.py,sha256=KOpSrwkSvj5SGOY9pTXOM26Dnz00rsJt33WueVvzpvc,2196
+defusedxml/lxml.py,sha256=HW-LFKdrfMRzHdi0Vcucq4-n8yz7v_OQwEQWFg1JQYA,4940
+defusedxml/minidom.py,sha256=3QcgygVwJqcWDQ3IZ2iol8zsH4cx3BRX70SPcd0bG2g,1884
+defusedxml/pulldom.py,sha256=DYj2D2lc7xoxZ38gfzujXmdznd8ovzDqGFXqyXbtxjk,1170
+defusedxml/sax.py,sha256=-SF08Msc2mWEYAMw62pJ5FMwWccOctFSnQwDLYLLlVE,1477
+defusedxml/xmlrpc.py,sha256=7rZQey3tqXcc1hrrM3RprOICU6fiFny9B9l4nmTioxA,5364

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/defusedxml-0.7.1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.34.2)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/defusedxml-0.7.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+defusedxml

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/distutils-precedence.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ea7ffef3fe2a117ee12c68ed6553617f0d7fd2f0590257c25c484959a3b7373
+size 152

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/docs/conf.py

@@ -0,0 +1,384 @@
+# -*- coding: utf-8 -*-
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# google-auth-oauthlib documentation build configuration file
+#
+# This file is execfile()d with the current directory set to its
+# containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+import sys
+import os
+import shlex
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+sys.path.insert(0, os.path.abspath(".."))
+
+# For plugins that can not read conf.py.
+# See also: https://github.com/docascode/sphinx-docfx-yaml/issues/85
+sys.path.insert(0, os.path.abspath("."))
+
+__version__ = ""
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+needs_sphinx = "1.5.5"
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.autosummary",
+    "sphinx.ext.intersphinx",
+    "sphinx.ext.coverage",
+    "sphinx.ext.doctest",
+    "sphinx.ext.napoleon",
+    "sphinx.ext.todo",
+    "sphinx.ext.viewcode",
+    "recommonmark",
+]
+
+# autodoc/autosummary flags
+autoclass_content = "both"
+autodoc_default_options = {"members": True}
+autosummary_generate = True
+
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ["_templates"]
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+# source_suffix = ['.rst', '.md']
+source_suffix = [".rst", ".md"]
+
+# The encoding of source files.
+# source_encoding = 'utf-8-sig'
+
+# The root toctree document.
+root_doc = "index"
+
+# General information about the project.
+project = "google-auth-oauthlib"
+copyright = "2019, Google"
+author = "Google APIs"
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The full version, including alpha/beta/rc tags.
+release = __version__
+# The short X.Y version.
+version = ".".join(release.split(".")[0:2])
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+language = None
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+# today = ''
+# Else, today_fmt is used as the format for a strftime call.
+# today_fmt = '%B %d, %Y'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+exclude_patterns = [
+    "_build",
+    "**/.nox/**/*",
+    "samples/AUTHORING_GUIDE.md",
+    "samples/CONTRIBUTING.md",
+    "samples/snippets/README.rst",
+]
+
+# The reST default role (used for this markup: `text`) to use for all
+# documents.
+# default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+# add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+# add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+# show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = "sphinx"
+
+# A list of ignored prefixes for module index sorting.
+# modindex_common_prefix = []
+
+# If true, keep warnings as "system message" paragraphs in the built documents.
+# keep_warnings = False
+
+# If true, `todo` and `todoList` produce output, else they produce nothing.
+todo_include_todos = True
+
+
+# -- Options for HTML output ----------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+html_theme = "alabaster"
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+html_theme_options = {
+    "description": "Google Cloud Client Libraries for google-auth-oauthlib",
+    "github_user": "googleapis",
+    "github_repo": "google-auth-library-python-oauthlib",
+    "github_banner": True,
+    "font_family": "'Roboto', Georgia, sans",
+    "head_font_family": "'Roboto', Georgia, serif",
+    "code_font_family": "'Roboto Mono', 'Consolas', monospace",
+}
+
+# Add any paths that contain custom themes here, relative to this directory.
+# html_theme_path = []
+
+# The name for this set of Sphinx documents.  If None, it defaults to
+# "<project> v<release> documentation".
+# html_title = None
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+# html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+# html_logo = None
+
+# The name of an image file (within the static path) to use as favicon of the
+# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+# html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ["_static"]
+
+# Add any extra paths that contain custom files (such as robots.txt or
+# .htaccess) here, relative to this directory. These files are copied
+# directly to the root of the documentation.
+# html_extra_path = []
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+# html_last_updated_fmt = '%b %d, %Y'
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+# html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+# html_sidebars = {}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+# html_additional_pages = {}
+
+# If false, no module index is generated.
+# html_domain_indices = True
+
+# If false, no index is generated.
+# html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+# html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+# html_show_sourcelink = True
+
+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
+# html_show_sphinx = True
+
+# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
+# html_show_copyright = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+# html_use_opensearch = ''
+
+# This is the file name suffix for HTML files (e.g. ".xhtml").
+# html_file_suffix = None
+
+# Language to be used for generating the HTML full-text search index.
+# Sphinx supports the following languages:
+#   'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
+#   'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr'
+# html_search_language = 'en'
+
+# A dictionary with options for the search language support, empty by default.
+# Now only 'ja' uses this config value
+# html_search_options = {'type': 'default'}
+
+# The name of a javascript file (relative to the configuration directory) that
+# implements a search results scorer. If empty, the default will be used.
+# html_search_scorer = 'scorer.js'
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = "google-auth-oauthlib-doc"
+
+# -- Options for warnings ------------------------------------------------------
+
+
+suppress_warnings = [
+    # Temporarily suppress this to avoid "more than one target found for
+    # cross-reference" warning, which are intractable for us to avoid while in
+    # a mono-repo.
+    # See https://github.com/sphinx-doc/sphinx/blob
+    # /2a65ffeef5c107c19084fabdd706cdff3f52d93c/sphinx/domains/python.py#L843
+    "ref.python"
+]
+
+# -- Options for LaTeX output ---------------------------------------------
+
+latex_elements = {
+    # The paper size ('letterpaper' or 'a4paper').
+    #'papersize': 'letterpaper',
+    # The font size ('10pt', '11pt' or '12pt').
+    #'pointsize': '10pt',
+    # Additional stuff for the LaTeX preamble.
+    #'preamble': '',
+    # Latex figure (float) alignment
+    #'figure_align': 'htbp',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [
+    (
+        root_doc,
+        "google-auth-oauthlib.tex",
+        "google-auth-oauthlib Documentation",
+        author,
+        "manual",
+    )
+]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+# latex_logo = None
+
+# For "manual" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+# latex_use_parts = False
+
+# If true, show page references after internal links.
+# latex_show_pagerefs = False
+
+# If true, show URL addresses after external links.
+# latex_show_urls = False
+
+# Documents to append as an appendix to all manuals.
+# latex_appendices = []
+
+# If false, no module index is generated.
+# latex_domain_indices = True
+
+
+# -- Options for manual page output ---------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    (
+        root_doc,
+        "google-auth-oauthlib",
+        "google-auth-oauthlib Documentation",
+        [author],
+        1,
+    )
+]
+
+# If true, show URL addresses after external links.
+# man_show_urls = False
+
+
+# -- Options for Texinfo output -------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+    (
+        root_doc,
+        "google-auth-oauthlib",
+        "google-auth-oauthlib Documentation",
+        author,
+        "google-auth-oauthlib",
+        "google-auth-oauthlib Library",
+        "APIs",
+    )
+]
+
+# Documents to append as an appendix to all manuals.
+# texinfo_appendices = []
+
+# If false, no module index is generated.
+# texinfo_domain_indices = True
+
+# How to display URL addresses: 'footnote', 'no', or 'inline'.
+# texinfo_show_urls = 'footnote'
+
+# If true, do not generate a @detailmenu in the "Top" node's menu.
+# texinfo_no_detailmenu = False
+
+
+# Example configuration for intersphinx: refer to the Python standard library.
+intersphinx_mapping = {
+    "python": ("https://python.readthedocs.org/en/latest/", None),
+    "google-auth": ("https://googleapis.dev/python/google-auth/latest/", None),
+    "google.api_core": (
+        "https://googleapis.dev/python/google-api-core/latest/",
+        None,
+    ),
+    "grpc": ("https://grpc.github.io/grpc/python/", None),
+    "proto-plus": ("https://proto-plus-python.readthedocs.io/en/latest/", None),
+    "protobuf": ("https://googleapis.dev/python/protobuf/latest/", None),
+}
+
+
+# Napoleon settings
+napoleon_google_docstring = True
+napoleon_numpy_docstring = True
+napoleon_include_private_with_doc = False
+napoleon_include_special_with_doc = True
+napoleon_use_admonition_for_examples = False
+napoleon_use_admonition_for_notes = False
+napoleon_use_admonition_for_references = False
+napoleon_use_ivar = False
+napoleon_use_param = True
+napoleon_use_rtype = True

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/keras-2.15.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/keras-2.15.0.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.1
+Name: keras
+Version: 2.15.0
+Summary: Deep learning for humans.
+Home-page: https://keras.io/
+Download-URL: https://github.com/keras-team/keras/tags
+Author: Keras team
+Author-email: keras-users@googlegroups.com
+License: Apache 2.0
+Keywords: keras,tensorflow,machine learning,deep learning
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+
+Keras is a deep learning API written in Python,
+running on top of the machine learning platform TensorFlow.
+
+It was developed with a focus on enabling fast experimentation and
+providing a delightful developer experience.
+The purpose of Keras is to give an *unfair advantage* to any developer
+looking to ship ML-powered apps.
+
+Keras is:
+
+-   **Simple** -- but not simplistic. Keras reduces developer *cognitive load*
+    to free you to focus on the parts of the problem that really matter.
+    Keras focuses on ease of use, debugging speed, code elegance & conciseness,
+    maintainability, and deployability (via TFServing, TFLite, TF.js).
+-   **Flexible** -- Keras adopts the principle of *progressive disclosure of
+    complexity*: simple workflows should be quick and easy, while arbitrarily
+    advanced workflows should be *possible* via a clear path that builds upon
+    what you've already learned.
+-   **Powerful** -- Keras provides industry-strength performance and
+    scalability: it is used by organizations and companies including NASA,
+    YouTube, and Waymo. That's right -- your YouTube recommendations are
+    powered by Keras, and so is the world's most advanced driverless vehicle.

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/kiwisolver/__init__.py

@@ -0,0 +1,42 @@
+# --------------------------------------------------------------------------------------
+# Copyright (c) 2013-2024, Nucleic Development Team.
+#
+# Distributed under the terms of the Modified BSD License.
+#
+# The full license is in the file LICENSE, distributed with this software.
+# --------------------------------------------------------------------------------------
+from ._cext import (
+    Constraint,
+    Expression,
+    Solver,
+    Term,
+    Variable,
+    __kiwi_version__,
+    __version__,
+    strength,
+)
+from .exceptions import (
+    BadRequiredStrength,
+    DuplicateConstraint,
+    DuplicateEditVariable,
+    UnknownConstraint,
+    UnknownEditVariable,
+    UnsatisfiableConstraint,
+)
+
+__all__ = [
+    "BadRequiredStrength",
+    "Constraint",
+    "DuplicateConstraint",
+    "DuplicateEditVariable",
+    "Expression",
+    "Solver",
+    "Term",
+    "UnknownConstraint",
+    "UnknownEditVariable",
+    "UnsatisfiableConstraint",
+    "Variable",
+    "__kiwi_version__",
+    "__version__",
+    "strength",
+]

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/kiwisolver/_cext.pyi

@@ -0,0 +1,228 @@
+# --------------------------------------------------------------------------------------
+# Copyright (c) 2021-2024, Nucleic Development Team.
+#
+# Distributed under the terms of the Modified BSD License.
+#
+# The full license is in the file LICENSE, distributed with this software.
+# --------------------------------------------------------------------------------------
+
+from typing import Any, Iterable, NoReturn, Tuple, type_check_only
+
+try:
+    from typing import Literal
+except ImportError:
+    from typing_extensions import Literal  # type: ignore
+
+__version__: str
+__kiwi_version__: str
+
+# Types
+@type_check_only
+class Strength:
+    @property
+    def weak(self) -> float: ...
+    @property
+    def medium(self) -> float: ...
+    @property
+    def strong(self) -> float: ...
+    @property
+    def required(self) -> float: ...
+    def create(
+        self,
+        a: int | float,
+        b: int | float,
+        c: int | float,
+        weight: int | float = 1.0,
+        /,
+    ) -> float: ...
+
+# This is meant as a singleton and users should not access the Strength type.
+strength: Strength
+
+class Variable:
+    """Variable to express a constraint in a solver."""
+
+    __hash__: None  # type: ignore
+    def __init__(self, name: str = "", context: Any = None, /) -> None: ...
+    def name(self) -> str:
+        """Get the name of the variable."""
+        ...
+    def setName(self, name: str, /) -> Any:
+        """Set the name of the variable."""
+        ...
+    def value(self) -> float:
+        """Get the current value of the variable."""
+        ...
+    def context(self) -> Any:
+        """Get the context object associated with the variable."""
+        ...
+    def setContext(self, context: Any, /) -> Any:
+        """Set the context object associated with the variable."""
+        ...
+    def __neg__(self) -> Term: ...
+    def __add__(self, other: float | Variable | Term | Expression) -> Expression: ...
+    def __radd__(self, other: float | Variable | Term | Expression) -> Expression: ...
+    def __sub__(self, other: float | Variable | Term | Expression) -> Expression: ...
+    def __rsub__(self, other: float | Variable | Term | Expression) -> Expression: ...
+    def __mul__(self, other: float) -> Term: ...
+    def __rmul__(self, other: float) -> Term: ...
+    def __truediv__(self, other: float) -> Term: ...
+    def __rtruediv__(self, other: float) -> Term: ...
+    def __eq__(self, other: float | Variable | Term | Expression) -> Constraint: ...  # type: ignore
+    def __ge__(self, other: float | Variable | Term | Expression) -> Constraint: ...
+    def __le__(self, other: float | Variable | Term | Expression) -> Constraint: ...
+    def __ne__(self, other: Any) -> NoReturn: ...
+    def __gt__(self, other: Any) -> NoReturn: ...
+    def __lt__(self, other: Any) -> NoReturn: ...
+
+class Term:
+    """Product of a variable by a constant pre-factor."""
+
+    __hash__: None  # type: ignore
+    def __init__(
+        self, variable: Variable, coefficient: int | float = 1.0, /
+    ) -> None: ...
+    def coefficient(self) -> float:
+        """Get the coefficient for the term."""
+        ...
+    def variable(self) -> Variable:
+        """Get the variable for the term."""
+        ...
+    def value(self) -> float:
+        """Get the value for the term."""
+        ...
+    def __neg__(self) -> Term: ...
+    def __add__(self, other: float | Variable | Term | Expression) -> Expression: ...
+    def __radd__(self, other: float | Variable | Term | Expression) -> Expression: ...
+    def __sub__(self, other: float | Variable | Term | Expression) -> Expression: ...
+    def __rsub__(self, other: float | Variable | Term | Expression) -> Expression: ...
+    def __mul__(self, other: float) -> Term: ...
+    def __rmul__(self, other: float) -> Term: ...
+    def __truediv__(self, other: float) -> Term: ...
+    def __rtruediv__(self, other: float) -> Term: ...
+    def __eq__(self, other: float | Variable | Term | Expression) -> Constraint: ...  # type: ignore
+    def __ge__(self, other: float | Variable | Term | Expression) -> Constraint: ...
+    def __le__(self, other: float | Variable | Term | Expression) -> Constraint: ...
+    def __ne__(self, other: Any) -> NoReturn: ...
+    def __gt__(self, other: Any) -> NoReturn: ...
+    def __lt__(self, other: Any) -> NoReturn: ...
+
+class Expression:
+    """Sum of terms and an additional constant."""
+
+    __hash__: None  # type: ignore
+    def __init__(
+        self, terms: Iterable[Term], constant: int | float = 0.0, /
+    ) -> None: ...
+    def constant(self) -> float:
+        "" "Get the constant for the expression." ""
+        ...
+    def terms(self) -> Tuple[Term, ...]:
+        """Get the tuple of terms for the expression."""
+        ...
+    def value(self) -> float:
+        """Get the value for the expression."""
+        ...
+    def __neg__(self) -> Expression: ...
+    def __add__(self, other: float | Variable | Term | Expression) -> Expression: ...
+    def __radd__(self, other: float | Variable | Term | Expression) -> Expression: ...
+    def __sub__(self, other: float | Variable | Term | Expression) -> Expression: ...
+    def __rsub__(self, other: float | Variable | Term | Expression) -> Expression: ...
+    def __mul__(self, other: float) -> Expression: ...
+    def __rmul__(self, other: float) -> Expression: ...
+    def __truediv__(self, other: float) -> Expression: ...
+    def __rtruediv__(self, other: float) -> Expression: ...
+    def __eq__(self, other: float | Variable | Term | Expression) -> Constraint: ...  # type: ignore
+    def __ge__(self, other: float | Variable | Term | Expression) -> Constraint: ...
+    def __le__(self, other: float | Variable | Term | Expression) -> Constraint: ...
+    def __ne__(self, other: Any) -> NoReturn: ...
+    def __gt__(self, other: Any) -> NoReturn: ...
+    def __lt__(self, other: Any) -> NoReturn: ...
+
+class Constraint:
+    def __init__(
+        self,
+        expression: Expression,
+        op: Literal["=="] | Literal["<="] | Literal[">="],
+        strength: float
+        | Literal["weak"]
+        | Literal["medium"]
+        | Literal["strong"]
+        | Literal["required"] = "required",
+        /,
+    ) -> None: ...
+    def expression(self) -> Expression:
+        """Get the expression object for the constraint."""
+        ...
+    def op(self) -> Literal["=="] | Literal["<="] | Literal[">="]:
+        """Get the relational operator for the constraint."""
+        ...
+    def strength(self) -> float:
+        """Get the strength for the constraint."""
+        ...
+    def violated(self) -> bool:
+        """Indicate if the constraint is violated in teh current state of the solver."""
+        ...
+    def __or__(
+        self,
+        other: float
+        | Literal["weak"]
+        | Literal["medium"]
+        | Literal["strong"]
+        | Literal["required"],
+    ) -> Constraint: ...
+    def __ror__(
+        self,
+        other: float
+        | Literal["weak"]
+        | Literal["medium"]
+        | Literal["strong"]
+        | Literal["required"],
+    ) -> Constraint: ...
+
+class Solver:
+    """Kiwi solver class."""
+
+    def __init__(self) -> None: ...
+    def addConstraint(self, constraint: Constraint, /) -> None:
+        """Add a constraint to the solver."""
+        ...
+    def removeConstraint(self, constraint: Constraint, /) -> None:
+        """Remove a constraint from the solver."""
+        ...
+    def hasConstraint(self, constraint: Constraint, /) -> bool:
+        """Check whether the solver contains a constraint."""
+        ...
+    def addEditVariable(
+        self,
+        variable: Variable,
+        strength: float
+        | Literal["weak"]
+        | Literal["medium"]
+        | Literal["strong"]
+        | Literal["required"],
+        /,
+    ) -> None:
+        """Add an edit variable to the solver."""
+        ...
+    def removeEditVariable(self, variable: Variable, /) -> None:
+        """Remove an edit variable from the solver."""
+        ...
+    def hasEditVariable(self, variable: Variable, /) -> bool:
+        """Check whether the solver contains an edit variable."""
+        ...
+    def suggestValue(self, variable: Variable, value: int | float, /) -> None:
+        """Suggest a desired value for an edit variable."""
+        ...
+    def updateVariables(self) -> None:
+        """Update the values of the solver variables."""
+        ...
+    def reset(self) -> None:
+        """Reset the solver to the initial empty starting condition."""
+        ...
+    def dump(self) -> None:
+        """Dump a representation of the solver internals to stdout."""
+        ...
+    def dumps(self) -> str:
+        """Dump a representation of the solver internals to a string."""
+        ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/kiwisolver/exceptions.py

@@ -0,0 +1,51 @@
+# --------------------------------------------------------------------------------------
+# Copyright (c) 2023-2024, Nucleic Development Team.
+#
+# Distributed under the terms of the Modified BSD License.
+#
+# The full license is in the file LICENSE, distributed with this software.
+# --------------------------------------------------------------------------------------
+"""Kiwi exceptions.
+
+Imported by the kiwisolver C extension.
+
+"""
+
+
+class BadRequiredStrength(Exception):
+    pass
+
+
+class DuplicateConstraint(Exception):
+    __slots__ = ("constraint",)
+
+    def __init__(self, constraint):
+        self.constraint = constraint
+
+
+class DuplicateEditVariable(Exception):
+    __slots__ = ("edit_variable",)
+
+    def __init__(self, edit_variable):
+        self.edit_variable = edit_variable
+
+
+class UnknownConstraint(Exception):
+    __slots__ = ("constraint",)
+
+    def __init__(self, constraint):
+        self.constraint = constraint
+
+
+class UnknownEditVariable(Exception):
+    __slots__ = ("edit_variable",)
+
+    def __init__(self, edit_variable):
+        self.edit_variable = edit_variable
+
+
+class UnsatisfiableConstraint(Exception):
+    __slots__ = ("constraint",)
+
+    def __init__(self, constraint):
+        self.constraint = constraint