diff --git a/.gitattributes b/.gitattributes
index f98bf80ed3142d1caeb54978590c3ba395133ae7..f9f596ccef3dfdb5ba4a251e7c9e9b0db5e8f73e 100644
--- a/.gitattributes
+++ b/.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
diff --git a/material/dataset/Datasets/Electron Microscopy Image Masks/TiO2_Masks_TSEM/Image_Registration/Input/1908324/1908324.tif b/material/dataset/Datasets/Electron Microscopy Image Masks/TiO2_Masks_TSEM/Image_Registration/Input/1908324/1908324.tif
new file mode 100644
index 0000000000000000000000000000000000000000..68bb1a22a7eb94e5598ced327c66ba075371b5cd
--- /dev/null
+++ b/material/dataset/Datasets/Electron Microscopy Image Masks/TiO2_Masks_TSEM/Image_Registration/Input/1908324/1908324.tif	
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a450ad560a5fd5352b1114a257cd034c36538432f3fe5d442bcbca539a8e9af0
+size 729295
diff --git a/material/dataset/Datasets/Electron Microscopy Image Masks/TiO2_Masks_TSEM/Image_Registration/Output/1908308/1908309.tif b/material/dataset/Datasets/Electron Microscopy Image Masks/TiO2_Masks_TSEM/Image_Registration/Output/1908308/1908309.tif
new file mode 100644
index 0000000000000000000000000000000000000000..b0ce7f223a4d61114b1610a44e63f46dcbbab9ea
--- /dev/null
+++ b/material/dataset/Datasets/Electron Microscopy Image Masks/TiO2_Masks_TSEM/Image_Registration/Output/1908308/1908309.tif	
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eaef6653c52e327764552d87dd5ecbd5a35497e18c2287dac167f9666ad033ff
+size 732796
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__init__.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/__init__.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d5eadfd5835a444df33804664d6237ea43397c27
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/__init__.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_backgroundjobs.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_backgroundjobs.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5e678976de435a88f431c0af46e30b7a67218aa7
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_backgroundjobs.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_clipboard.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_clipboard.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4f3313fc5eccdaf09a5e49cbdbe86dbeab77bc52
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_clipboard.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_deepreload.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_deepreload.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..99b307d14721f06f65f3c3384c3da1473c138fc6
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_deepreload.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_display.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_display.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9969d4339f47186337acc4950c857fb28ab7bab7
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_display.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_editorhooks.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_editorhooks.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2a26d88cc0c6fa7cd0d732d187ec6de4bc80c800
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_editorhooks.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_imports.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_imports.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..30e072948ec629e37d5c49260375c43e1ada25dc
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_imports.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_latextools.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_latextools.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eaed69e18f4181d5842870ad0dfc121912b820ab
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_latextools.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_lexers.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_lexers.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..63887e84ef1655146e7ea2875c1a40bad910e46b
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_lexers.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_pretty.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_pretty.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cf93419ab70546756d8ca6fb43fdf5dab1a19db0
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_pretty.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_pygments.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_pygments.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7b2de8757258257333bdbf2c990726b92305925a
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/__pycache__/test_pygments.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_deepreload.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_deepreload.py
new file mode 100644
index 0000000000000000000000000000000000000000..5da606cb8b7a4f7887ce0a45de2e227eeda05a24
--- /dev/null
+++ b/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)
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_display.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_display.py
new file mode 100644
index 0000000000000000000000000000000000000000..f5ed34c912b396703931362f1f6de5e9b12f4e91
--- /dev/null
+++ b/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>')
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_editorhooks.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_editorhooks.py
new file mode 100644
index 0000000000000000000000000000000000000000..6e3354786a22a11b37a7ce7635167f8a298ffba7
--- /dev/null
+++ b/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
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_imports.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_imports.py
new file mode 100644
index 0000000000000000000000000000000000000000..515cd4a8a58ec1116897bfd19eee72f4e6a75756
--- /dev/null
+++ b/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
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_latextools.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_latextools.py
new file mode 100644
index 0000000000000000000000000000000000000000..d035752b4fe607113c98d97249da9540a3bdce9d
--- /dev/null
+++ b/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"),
+    )
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_pretty.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_pretty.py
new file mode 100644
index 0000000000000000000000000000000000000000..57e258b9c8855bb49c1b8afa153fe068c5739a88
--- /dev/null
+++ b/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"
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_pygments.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/lib/tests/test_pygments.py
new file mode 100644
index 0000000000000000000000000000000000000000..877b4221ffe5a46f22e38305cb845818578918c4
--- /dev/null
+++ b/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
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/__pycache__/__init__.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..750f82a1f606a370c065ca7083cba86a1fa4e970
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/__pycache__/__init__.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/__pycache__/converters.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/__pycache__/converters.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b68cffbe2a717cdef26ced2129e23fce075cb591
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/__pycache__/converters.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/__pycache__/exceptions.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/__pycache__/exceptions.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4161a1c26adc26cb7c7e51b9fd62ad78c1bd498c
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/__pycache__/exceptions.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/__pycache__/filters.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/__pycache__/filters.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..61ada24629d304abf776a91b61afffb6a516d323
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/__pycache__/filters.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/__pycache__/setters.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/__pycache__/setters.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..672265a0dfb79fe2ff7eb19e7b18522b9824e6dd
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/__pycache__/setters.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/__pycache__/validators.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/__pycache__/validators.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dedc5c49848f3b5d4b78fdf7984b5703409835e1
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/__pycache__/validators.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/setters.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/attrs/setters.py
new file mode 100644
index 0000000000000000000000000000000000000000..f3d73bb793dd49c138950961f41943bb26c57fde
--- /dev/null
+++ b/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
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/defusedxml-0.7.1.dist-info/INSTALLER b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/defusedxml-0.7.1.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/defusedxml-0.7.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/defusedxml-0.7.1.dist-info/LICENSE b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/defusedxml-0.7.1.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..311690c68fe4af37f8136cc05e62e9d51942b46a
--- /dev/null
+++ b/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.
+
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/defusedxml-0.7.1.dist-info/METADATA b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/defusedxml-0.7.1.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..f916e891d0d4cfc97cb9c86817635800e381a682
--- /dev/null
+++ b/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
+
+
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/defusedxml-0.7.1.dist-info/RECORD b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/defusedxml-0.7.1.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..adcf39921e8c4f2b387c19990b8ed8eb5babcb35
--- /dev/null
+++ b/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
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/defusedxml-0.7.1.dist-info/WHEEL b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/defusedxml-0.7.1.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..ef99c6cf3283b50a273ac4c6d009a0aa85597070
--- /dev/null
+++ b/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
+
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/defusedxml-0.7.1.dist-info/top_level.txt b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/defusedxml-0.7.1.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..36969f2c4b81b8d563bf352a569328e8c5a75a74
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/defusedxml-0.7.1.dist-info/top_level.txt
@@ -0,0 +1 @@
+defusedxml
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/distutils-precedence.pth b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/distutils-precedence.pth
new file mode 100644
index 0000000000000000000000000000000000000000..10c404f6ad452c148c46a39e11ddd4bc58530d16
--- /dev/null
+++ b/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
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/docs/__pycache__/conf.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/docs/__pycache__/conf.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ca9c0e65d107cdc9596b724fc5d4e32a2cdb65c6
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/docs/__pycache__/conf.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/docs/conf.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/docs/conf.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d9ca3b4b403620c072b29a9bdc752429f202ca7
--- /dev/null
+++ b/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
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/keras-2.15.0.dist-info/INSTALLER b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/keras-2.15.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/keras-2.15.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/keras-2.15.0.dist-info/METADATA b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/keras-2.15.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..dc5ccea41fd7231e1d9dfc87deafb2960474bb08
--- /dev/null
+++ b/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.
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/keras-2.15.0.dist-info/RECORD b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/keras-2.15.0.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..b02da60f31984c032c49cf14b1620e6a52775efe
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/keras-2.15.0.dist-info/RECORD
@@ -0,0 +1,1215 @@
+keras-2.15.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+keras-2.15.0.dist-info/METADATA,sha256=jlhvy86Pt3unGCORKenoDJYPK9nK7dT7WEjtRgCA18M,2440
+keras-2.15.0.dist-info/RECORD,,
+keras-2.15.0.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
+keras-2.15.0.dist-info/top_level.txt,sha256=ptcw_-QuGZ4ZDjMdwi_Z0clZm8QAqFdvzzFnDEOTs9o,6
+keras/__init__.py,sha256=IdJ4Zwjsi_NhTno4KmNFiMuz7EVWclYDD_xtDt8DoEs,822
+keras/__internal__/__init__.py,sha256=XxEX5weXCzMkvtwgvD4cNXA-sEFrSNsA5zyX9nNgu84,638
+keras/__internal__/__pycache__/__init__.cpython-310.pyc,,
+keras/__internal__/backend/__init__.py,sha256=VFvP0Y574aC0mmz5epqarXlyqjr_DgiLBPa8FFxpWV0,156
+keras/__internal__/backend/__pycache__/__init__.cpython-310.pyc,,
+keras/__internal__/layers/__init__.py,sha256=qXx1q_xvx2F7IF4wbIagGyBpz02UZaAwQL0tWC6numc,170
+keras/__internal__/layers/__pycache__/__init__.cpython-310.pyc,,
+keras/__internal__/losses/__init__.py,sha256=iOIno_ImXUPoegK4v_qLFoF_o7P_NdGiY_h0_UsmnFs,147
+keras/__internal__/losses/__pycache__/__init__.cpython-310.pyc,,
+keras/__internal__/models/__init__.py,sha256=JKxCFkxYWYGCji6-bDmVrA1DTfVXUxgxnEc1TGdnwXs,175
+keras/__internal__/models/__pycache__/__init__.cpython-310.pyc,,
+keras/__internal__/optimizers/__init__.py,sha256=i66NFRcWXLNaLrqTOGGm00YuklvoDxrcQFTfYD6J0v8,96
+keras/__internal__/optimizers/__pycache__/__init__.cpython-310.pyc,,
+keras/__internal__/utils/__init__.py,sha256=2AkmYw0oIx86V33OWEDkqVBizMjdZQMeKTrs6vrAXiw,161
+keras/__internal__/utils/__pycache__/__init__.cpython-310.pyc,,
+keras/__pycache__/__init__.cpython-310.pyc,,
+keras/activations/__init__.py,sha256=Zpgg3_shsG7NEkSGQE0pzVohY6C_TLRtLkqDh2VNYUw,740
+keras/activations/__pycache__/__init__.cpython-310.pyc,,
+keras/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+keras/api/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+keras/api/_v1/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/__init__.py,sha256=LNzJdfGGUaxCd8TOf0wqKFLFbXLfBaFjN6iBmWe-wbE,1065
+keras/api/_v1/keras/__internal__/__init__.py,sha256=ssGA7xabR1QMiM78ySVpuqAyXY9ZXBBdLY80PaYIGuE,216
+keras/api/_v1/keras/__internal__/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/__internal__/layers/__init__.py,sha256=fpk5nMjFur5Grw4i10G-L06BqdmrV2kKrnOD_5E_qJo,91
+keras/api/_v1/keras/__internal__/layers/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/__internal__/legacy/__init__.py,sha256=KDexZBp-A44K_celwMTMPDLyE1oeLpzN6xqB9Gxokt8,155
+keras/api/_v1/keras/__internal__/legacy/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/__internal__/legacy/layers/__init__.py,sha256=1DgD1yyieJkPq1Ft9FZzgLQ7wLu09ONR4fknA9qn8cw,2326
+keras/api/_v1/keras/__internal__/legacy/layers/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/__internal__/legacy/layers/experimental/__init__.py,sha256=7lLI02vyN1-TVakZT5FPr-bj-4Yj5JdIBny2NyIEWis,157
+keras/api/_v1/keras/__internal__/legacy/layers/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/__internal__/legacy/rnn_cell/__init__.py,sha256=H5P4m6L8FhBxtVaquhzn7rgg0L4ycbOxoUemAcPdX1g,644
+keras/api/_v1/keras/__internal__/legacy/rnn_cell/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/activations/__init__.py,sha256=Z4_9xlOTqBxt1SE4bZZO96FvVuZ0pZ-HkElD1CxkCIM,701
+keras/api/_v1/keras/activations/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/applications/__init__.py,sha256=Iv-Ho9ZcnafBqQOx0aGtAvgG7n68TMx182T5Fgw3y2k,5155
+keras/api/_v1/keras/applications/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/applications/convnext/__init__.py,sha256=KzhqImrxJgn7kEuDCZQ2-eYFvQ8vYEwp8QxQq4lKLCs,448
+keras/api/_v1/keras/applications/convnext/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/applications/densenet/__init__.py,sha256=0JnnZbdHm5GfRsRR9DTpSX9a5UiPVOJ1DACbb_07kWA,327
+keras/api/_v1/keras/applications/densenet/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/applications/efficientnet/__init__.py,sha256=4dpr1g6gcEA1e9_FVA0-ORvffpyWKkPyQIaXi9th2lI,671
+keras/api/_v1/keras/applications/efficientnet/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/applications/efficientnet_v2/__init__.py,sha256=37ldnNCTZDdNLMGiJNv9tEjQ6bx-kgXKmLtWu-Bo8Do,646
+keras/api/_v1/keras/applications/efficientnet_v2/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/applications/imagenet_utils/__init__.py,sha256=mGWB1iCNIVRAanLjIBQrMiZyC-v3eSelG4KKx4nas1c,171
+keras/api/_v1/keras/applications/imagenet_utils/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/applications/inception_resnet_v2/__init__.py,sha256=Bc7qxCFU-o2sEQHbbm3FpDn8JK1pYfDCDO3mwG9mmV0,254
+keras/api/_v1/keras/applications/inception_resnet_v2/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/applications/inception_v3/__init__.py,sha256=3a82lFSMNqdEHXDrle2dmFe0Q5aZozxb5Vy8B3Vjijo,227
+keras/api/_v1/keras/applications/inception_v3/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/applications/mobilenet/__init__.py,sha256=3tTybQ02gfFIuO4TcVzovpb8VEuh2gb4jLt_MGCSwG8,216
+keras/api/_v1/keras/applications/mobilenet/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/applications/mobilenet_v2/__init__.py,sha256=4ia3UkhtrAgDd9tTrHp9J3ICMgyo1wBDajap6fS0oLA,227
+keras/api/_v1/keras/applications/mobilenet_v2/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/applications/mobilenet_v3/__init__.py,sha256=GqZStongf1KXK-Z6gUvVFCYVMnF5PvH7K9jepXDSpq8,167
+keras/api/_v1/keras/applications/mobilenet_v3/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/applications/nasnet/__init__.py,sha256=Nh50Xh4mhMWTnP4wbx-RgSX0HC84kTjH-ZaHtu6UhNM,264
+keras/api/_v1/keras/applications/nasnet/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/applications/regnet/__init__.py,sha256=Os1Dl5Lu9sOlbWis-MOmWZ1NHyCQ0DACfjyhxpavo6k,1427
+keras/api/_v1/keras/applications/regnet/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/applications/resnet/__init__.py,sha256=Ut9tpajz7RtTkIgy-OcqH114cuVVJ-p1OlcdyYglyX4,310
+keras/api/_v1/keras/applications/resnet/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/applications/resnet50/__init__.py,sha256=lkUdSmfQhcYhF1dO539O73TYy-gdcAcDWLchVUSYneg,206
+keras/api/_v1/keras/applications/resnet50/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/applications/resnet_rs/__init__.py,sha256=7z7USlNNSM1jHl7R3gQwDjOFWkpgvCsS5weqCp9Siaw,559
+keras/api/_v1/keras/applications/resnet_rs/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/applications/resnet_v2/__init__.py,sha256=flKlNsYwL9gvocgN46E8pE8v7nUPdYIqjU1eByYm5FY,331
+keras/api/_v1/keras/applications/resnet_v2/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/applications/vgg16/__init__.py,sha256=pkYJI5AOKzZjIWiq8tpiwOrL0pag9T0Gu12Y1WE0Q8I,200
+keras/api/_v1/keras/applications/vgg16/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/applications/vgg19/__init__.py,sha256=q45TVPhtXTZIPN6VR31odCjqY2U_lO1dA3nFuLaoeBg,200
+keras/api/_v1/keras/applications/vgg19/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/applications/xception/__init__.py,sha256=ZjRwSLAC9gQ56EVehYinvdPQevFtdVwIhetrYUqRtzw,212
+keras/api/_v1/keras/applications/xception/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/backend/__init__.py,sha256=jnv-p_YeOCYTeXOY2rfCwvvpQlNtfhIms3JI4HWXLS0,6206
+keras/api/_v1/keras/backend/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/callbacks/__init__.py,sha256=MywPKlae90mOkgARnPEH0YKTDnvfgakcLQtPHOxGD0Y,751
+keras/api/_v1/keras/callbacks/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/constraints/__init__.py,sha256=M0kwfvbwI2zgQqmS-jrULNwHkt92HCuFQxycwc2fYyw,725
+keras/api/_v1/keras/constraints/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/datasets/__init__.py,sha256=4JX4RhT2BZj5t24MFfbWnsHdgrFa6s1a-iMInixvrVQ,387
+keras/api/_v1/keras/datasets/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/datasets/boston_housing/__init__.py,sha256=rXcH1veaB_0_HdpGbgqJ-fi3Sbmah6zoDyGIbJclXF4,91
+keras/api/_v1/keras/datasets/boston_housing/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/datasets/cifar10/__init__.py,sha256=2lWdBr8S1ScNARYA3QTZdH8Sf4gy7hLkYLIlut7Ar8M,84
+keras/api/_v1/keras/datasets/cifar10/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/datasets/cifar100/__init__.py,sha256=KoJc29lj25yACUMgli200LSs3D4VaW6D6LXZuWv6Iv0,85
+keras/api/_v1/keras/datasets/cifar100/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/datasets/fashion_mnist/__init__.py,sha256=22Z8KFQ0KTY6kdrPdrpdB53B_amvcQ7_0oSzXw9JPd4,90
+keras/api/_v1/keras/datasets/fashion_mnist/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/datasets/imdb/__init__.py,sha256=dc_dzqG_C-hcdfoLuByQif-1b29NSubQNAIA2PVR6Aw,132
+keras/api/_v1/keras/datasets/imdb/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/datasets/mnist/__init__.py,sha256=xn0zhrFLUt9O9aSGxWbsutehnlOVHNn8erp80ooxIbc,82
+keras/api/_v1/keras/datasets/mnist/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/datasets/reuters/__init__.py,sha256=_YXB_u3o_sykUzLCr0KZbKJQmVBaBaCDflxjbaoptsQ,193
+keras/api/_v1/keras/datasets/reuters/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/estimator/__init__.py,sha256=IEobv9Ozh4p_8eGBTOEnCWGtsLMQuoIaodyhqjOk5QU,86
+keras/api/_v1/keras/estimator/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/experimental/__init__.py,sha256=NqrCEXulMb6baLpUatpgdiIqSuTbgAMHTxMSECCOgzg,394
+keras/api/_v1/keras/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/export/__init__.py,sha256=04wTB07rfbKoKleE7NSWoIbY3ccAt1vKP4SL1rp_7Nw,89
+keras/api/_v1/keras/export/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/initializers/__init__.py,sha256=SregHt5G9Rj3zL8UkjZeYpBkef9pP89-xfzGc8v-H-c,1903
+keras/api/_v1/keras/initializers/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/layers/__init__.py,sha256=bAvhEUplMY8f4SYEqrw0Vk90TPU_NdXQ4lShePTa8vI,8978
+keras/api/_v1/keras/layers/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/layers/experimental/__init__.py,sha256=XsKCmzWByNxS1VpHVb8GsQrrTOTRgAQr8ITaCAYxMCc,222
+keras/api/_v1/keras/layers/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/layers/experimental/preprocessing/__init__.py,sha256=V56QKQa6fkLw8Afy-w8lBCOPM4T8QVnYH8Mdt6r4Uvs,608
+keras/api/_v1/keras/layers/experimental/preprocessing/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/losses/__init__.py,sha256=po_74B6qCAkhiTY6sibIVnuca-fB6dY-4kQmhonANcw,2607
+keras/api/_v1/keras/losses/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/metrics/__init__.py,sha256=jdOnbAH4v-CM5pWesGnBW442t555EP8zitolMocMqfk,4897
+keras/api/_v1/keras/metrics/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/mixed_precision/__init__.py,sha256=8tQvPyYT9OR0NevzsAvFb8zLHN4nrRt1j3WCiEQS-lQ,139
+keras/api/_v1/keras/mixed_precision/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/models/__init__.py,sha256=7Fo7wVQKPtTzFV5PGk3VHvQk6rIVDol4X1FLj53X3Lc,595
+keras/api/_v1/keras/models/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/optimizers/__init__.py,sha256=YNK6l8kbTcRzsq-1owi-63BHkQU0d342_9cJNwUKWaU,778
+keras/api/_v1/keras/optimizers/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/optimizers/legacy/__init__.py,sha256=dCvdb-haPTtsVe3aVZ6mA_Lj9QNMsf7v2j2i1YuCijs,550
+keras/api/_v1/keras/optimizers/legacy/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/optimizers/schedules/__init__.py,sha256=7dW7L_4x1HMH5st13am6eaXibaoG0n_9WnqyZqv4mfs,777
+keras/api/_v1/keras/optimizers/schedules/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/preprocessing/__init__.py,sha256=1PBX9LHOBgk6CNt3gEtmoj4xuwm3ee1dIHVcmt9l8q0,193
+keras/api/_v1/keras/preprocessing/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/preprocessing/image/__init__.py,sha256=KJHZvqstXM302wiRN4_8AALEXuOzZ8iXzG9jzmGh9Mw,1009
+keras/api/_v1/keras/preprocessing/image/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/preprocessing/sequence/__init__.py,sha256=0yTj4-NMEyZFE98f3H8ULozdxLHCXF8LIP23pr2KZUQ,273
+keras/api/_v1/keras/preprocessing/sequence/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/preprocessing/text/__init__.py,sha256=PRzMpqWvu1Zk9P5eCzuqlB4y4nAkNPP5L78wxWK24uA,314
+keras/api/_v1/keras/preprocessing/text/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/regularizers/__init__.py,sha256=Ul82NoHl2F1-1laQ-yc6OpuGu7t6Gf_kBcWJTAzktIg,458
+keras/api/_v1/keras/regularizers/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/saving/__init__.py,sha256=5WPjhNGUIMklABWkCufo-8kHRvL1V-uJng3PgBzJrEM,654
+keras/api/_v1/keras/saving/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/utils/__init__.py,sha256=bUSUKE-apf1OTHztAMa7kwBjVnmwiOj5vsgZvqX_rNw,2129
+keras/api/_v1/keras/utils/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v1/keras/utils/legacy/__init__.py,sha256=Dh85b96gSEHf9pLzzI04XRcscIsKNfgAa1tXqSozUa8,183
+keras/api/_v1/keras/utils/legacy/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+keras/api/_v2/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/__init__.py,sha256=FAO_dAL_aMdOr0F0ulXJSgF1hIaUeg-KUoXCqTkv-oE,1105
+keras/api/_v2/keras/__internal__/__init__.py,sha256=npFAe38l5-fW5TxUrJyLd35jxi2WlB_QTP9EONMHC_E,722
+keras/api/_v2/keras/__internal__/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/__internal__/backend/__init__.py,sha256=VFvP0Y574aC0mmz5epqarXlyqjr_DgiLBPa8FFxpWV0,156
+keras/api/_v2/keras/__internal__/backend/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/__internal__/layers/__init__.py,sha256=qXx1q_xvx2F7IF4wbIagGyBpz02UZaAwQL0tWC6numc,170
+keras/api/_v2/keras/__internal__/layers/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/__internal__/losses/__init__.py,sha256=iOIno_ImXUPoegK4v_qLFoF_o7P_NdGiY_h0_UsmnFs,147
+keras/api/_v2/keras/__internal__/losses/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/__internal__/models/__init__.py,sha256=JKxCFkxYWYGCji6-bDmVrA1DTfVXUxgxnEc1TGdnwXs,175
+keras/api/_v2/keras/__internal__/models/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/__internal__/optimizers/__init__.py,sha256=i66NFRcWXLNaLrqTOGGm00YuklvoDxrcQFTfYD6J0v8,96
+keras/api/_v2/keras/__internal__/optimizers/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/__internal__/utils/__init__.py,sha256=2AkmYw0oIx86V33OWEDkqVBizMjdZQMeKTrs6vrAXiw,161
+keras/api/_v2/keras/__internal__/utils/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/activations/__init__.py,sha256=Zpgg3_shsG7NEkSGQE0pzVohY6C_TLRtLkqDh2VNYUw,740
+keras/api/_v2/keras/activations/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/applications/__init__.py,sha256=o7OqfaTn3RE8c4pNoy5a-Xlp6gI5TAw_f-MqMmFysVI,5155
+keras/api/_v2/keras/applications/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/applications/convnext/__init__.py,sha256=KzhqImrxJgn7kEuDCZQ2-eYFvQ8vYEwp8QxQq4lKLCs,448
+keras/api/_v2/keras/applications/convnext/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/applications/densenet/__init__.py,sha256=0JnnZbdHm5GfRsRR9DTpSX9a5UiPVOJ1DACbb_07kWA,327
+keras/api/_v2/keras/applications/densenet/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/applications/efficientnet/__init__.py,sha256=4dpr1g6gcEA1e9_FVA0-ORvffpyWKkPyQIaXi9th2lI,671
+keras/api/_v2/keras/applications/efficientnet/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/applications/efficientnet_v2/__init__.py,sha256=37ldnNCTZDdNLMGiJNv9tEjQ6bx-kgXKmLtWu-Bo8Do,646
+keras/api/_v2/keras/applications/efficientnet_v2/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/applications/imagenet_utils/__init__.py,sha256=mGWB1iCNIVRAanLjIBQrMiZyC-v3eSelG4KKx4nas1c,171
+keras/api/_v2/keras/applications/imagenet_utils/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/applications/inception_resnet_v2/__init__.py,sha256=Bc7qxCFU-o2sEQHbbm3FpDn8JK1pYfDCDO3mwG9mmV0,254
+keras/api/_v2/keras/applications/inception_resnet_v2/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/applications/inception_v3/__init__.py,sha256=3a82lFSMNqdEHXDrle2dmFe0Q5aZozxb5Vy8B3Vjijo,227
+keras/api/_v2/keras/applications/inception_v3/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/applications/mobilenet/__init__.py,sha256=3tTybQ02gfFIuO4TcVzovpb8VEuh2gb4jLt_MGCSwG8,216
+keras/api/_v2/keras/applications/mobilenet/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/applications/mobilenet_v2/__init__.py,sha256=4ia3UkhtrAgDd9tTrHp9J3ICMgyo1wBDajap6fS0oLA,227
+keras/api/_v2/keras/applications/mobilenet_v2/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/applications/mobilenet_v3/__init__.py,sha256=GqZStongf1KXK-Z6gUvVFCYVMnF5PvH7K9jepXDSpq8,167
+keras/api/_v2/keras/applications/mobilenet_v3/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/applications/nasnet/__init__.py,sha256=Nh50Xh4mhMWTnP4wbx-RgSX0HC84kTjH-ZaHtu6UhNM,264
+keras/api/_v2/keras/applications/nasnet/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/applications/regnet/__init__.py,sha256=Os1Dl5Lu9sOlbWis-MOmWZ1NHyCQ0DACfjyhxpavo6k,1427
+keras/api/_v2/keras/applications/regnet/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/applications/resnet/__init__.py,sha256=Ut9tpajz7RtTkIgy-OcqH114cuVVJ-p1OlcdyYglyX4,310
+keras/api/_v2/keras/applications/resnet/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/applications/resnet50/__init__.py,sha256=lkUdSmfQhcYhF1dO539O73TYy-gdcAcDWLchVUSYneg,206
+keras/api/_v2/keras/applications/resnet50/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/applications/resnet_rs/__init__.py,sha256=7z7USlNNSM1jHl7R3gQwDjOFWkpgvCsS5weqCp9Siaw,559
+keras/api/_v2/keras/applications/resnet_rs/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/applications/resnet_v2/__init__.py,sha256=flKlNsYwL9gvocgN46E8pE8v7nUPdYIqjU1eByYm5FY,331
+keras/api/_v2/keras/applications/resnet_v2/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/applications/vgg16/__init__.py,sha256=pkYJI5AOKzZjIWiq8tpiwOrL0pag9T0Gu12Y1WE0Q8I,200
+keras/api/_v2/keras/applications/vgg16/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/applications/vgg19/__init__.py,sha256=q45TVPhtXTZIPN6VR31odCjqY2U_lO1dA3nFuLaoeBg,200
+keras/api/_v2/keras/applications/vgg19/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/applications/xception/__init__.py,sha256=ZjRwSLAC9gQ56EVehYinvdPQevFtdVwIhetrYUqRtzw,212
+keras/api/_v2/keras/applications/xception/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/backend/__init__.py,sha256=jyB8BTVkD_RgEJOikqyvNuQjgLaIza8F3aYMmkwpJZY,6144
+keras/api/_v2/keras/backend/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/backend/experimental/__init__.py,sha256=SDuI0PivvHKLXE6AayPaLpqM_MJw7CvbTYU4TSYPems,211
+keras/api/_v2/keras/backend/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/callbacks/__init__.py,sha256=VLrDjw3mDIjXSD3XHC2ZQQT54cDoAUtVYX6JNrulh4w,852
+keras/api/_v2/keras/callbacks/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/callbacks/experimental/__init__.py,sha256=m0EWhcjroyb1UUoyVhkcWa92ZjKfFkQNhGke6qT5OAE,116
+keras/api/_v2/keras/callbacks/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/constraints/__init__.py,sha256=M0kwfvbwI2zgQqmS-jrULNwHkt92HCuFQxycwc2fYyw,725
+keras/api/_v2/keras/constraints/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/datasets/__init__.py,sha256=ZZolpbeXUBGMfeXXFrXX_PYpWS3lObcebyxyGPQvEn0,387
+keras/api/_v2/keras/datasets/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/datasets/boston_housing/__init__.py,sha256=rXcH1veaB_0_HdpGbgqJ-fi3Sbmah6zoDyGIbJclXF4,91
+keras/api/_v2/keras/datasets/boston_housing/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/datasets/cifar10/__init__.py,sha256=2lWdBr8S1ScNARYA3QTZdH8Sf4gy7hLkYLIlut7Ar8M,84
+keras/api/_v2/keras/datasets/cifar10/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/datasets/cifar100/__init__.py,sha256=KoJc29lj25yACUMgli200LSs3D4VaW6D6LXZuWv6Iv0,85
+keras/api/_v2/keras/datasets/cifar100/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/datasets/fashion_mnist/__init__.py,sha256=22Z8KFQ0KTY6kdrPdrpdB53B_amvcQ7_0oSzXw9JPd4,90
+keras/api/_v2/keras/datasets/fashion_mnist/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/datasets/imdb/__init__.py,sha256=dc_dzqG_C-hcdfoLuByQif-1b29NSubQNAIA2PVR6Aw,132
+keras/api/_v2/keras/datasets/imdb/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/datasets/mnist/__init__.py,sha256=xn0zhrFLUt9O9aSGxWbsutehnlOVHNn8erp80ooxIbc,82
+keras/api/_v2/keras/datasets/mnist/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/datasets/reuters/__init__.py,sha256=_YXB_u3o_sykUzLCr0KZbKJQmVBaBaCDflxjbaoptsQ,193
+keras/api/_v2/keras/datasets/reuters/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/dtensor/__init__.py,sha256=nmlLbJRWuobamweV7O95dhanEX793_eLDKDWv3ipfys,88
+keras/api/_v2/keras/dtensor/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/dtensor/experimental/__init__.py,sha256=LBa9q8SQYNbqJCCetObRMQnQvVrRuzTmd9Umcx0ZV6k,150
+keras/api/_v2/keras/dtensor/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/dtensor/experimental/optimizers/__init__.py,sha256=WH8jIZv8IPjOuz7jTGm5Mh1IwW0oKx5eQC0MuIvEmu0,313
+keras/api/_v2/keras/dtensor/experimental/optimizers/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/estimator/__init__.py,sha256=BnGi5ykYU3KA0f75iyiXjd5adgeJkfBmxwmJAt8-qkg,111
+keras/api/_v2/keras/estimator/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/experimental/__init__.py,sha256=ThjB_prvy1Ql53a6yb5ZbY0zBPXZN_-ReEhOAJS_isc,489
+keras/api/_v2/keras/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/export/__init__.py,sha256=04wTB07rfbKoKleE7NSWoIbY3ccAt1vKP4SL1rp_7Nw,89
+keras/api/_v2/keras/export/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/initializers/__init__.py,sha256=M60nePNekuVB8E1yxgit9_E5tw0ShNzjGlSoz_M_7II,2231
+keras/api/_v2/keras/initializers/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/layers/__init__.py,sha256=gIHgkZR2VTnr5wt_V_7oUWLdn7ynMqipxfx0vNG--uw,9953
+keras/api/_v2/keras/layers/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/layers/experimental/__init__.py,sha256=AzpQSFBU4MC5cuVlB0ipe10tXkw6oiM_9VJrQqBdzbU,308
+keras/api/_v2/keras/layers/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/layers/experimental/preprocessing/__init__.py,sha256=YxHmFDcmXSw6KaBTslhcqxYo1XPnU5pHWmlJ9le6eqo,1514
+keras/api/_v2/keras/layers/experimental/preprocessing/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/losses/__init__.py,sha256=pQk_NLblOND1gMdGw6agj_UIuR1r9sgHXalGD3tio3k,2584
+keras/api/_v2/keras/losses/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/metrics/__init__.py,sha256=aKA84TDYaWwxauSp05ZA72KantGx_fCHzMglZqFoX6c,4826
+keras/api/_v2/keras/metrics/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/metrics/experimental/__init__.py,sha256=DicB16TRW7vpS1BvZ-cfTRNLMQUy8LJ1A_xxC-SzFLI,84
+keras/api/_v2/keras/metrics/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/mixed_precision/__init__.py,sha256=cSkDGo1cOxIQhXKdEW_cd1c7qRZgloc2ro0RlQ2U2Fg,313
+keras/api/_v2/keras/mixed_precision/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/models/__init__.py,sha256=DP5U7hmiHuKbKAycYdmGmk35VvnlAU8xkq5_yrXn3Fo,530
+keras/api/_v2/keras/models/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/models/experimental/__init__.py,sha256=37OjKKBRWpvAMglh8Eg28JFjlN95sM0VCeSAF2a-EEw,120
+keras/api/_v2/keras/models/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/optimizers/__init__.py,sha256=XHCoSooAdXcB1RPv9sSERPg_Wt8mrh7-OHw4SpxB8V0,881
+keras/api/_v2/keras/optimizers/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/optimizers/experimental/__init__.py,sha256=w05szJpm7YE_L0G73-U7hNpNR39y1bqhuaQe9qnOd6w,554
+keras/api/_v2/keras/optimizers/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/optimizers/legacy/__init__.py,sha256=dCvdb-haPTtsVe3aVZ6mA_Lj9QNMsf7v2j2i1YuCijs,550
+keras/api/_v2/keras/optimizers/legacy/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/optimizers/schedules/__init__.py,sha256=7dW7L_4x1HMH5st13am6eaXibaoG0n_9WnqyZqv4mfs,777
+keras/api/_v2/keras/optimizers/schedules/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/preprocessing/__init__.py,sha256=5ZCg2STEObx83f9hH-q5h0pcp_7NUD-L6GYRicmMzw8,410
+keras/api/_v2/keras/preprocessing/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/preprocessing/image/__init__.py,sha256=A4aKMlEY7V-suuoL9VlttmnIwfs8wuRNQMZhcxgyJlk,1062
+keras/api/_v2/keras/preprocessing/image/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/preprocessing/sequence/__init__.py,sha256=0yTj4-NMEyZFE98f3H8ULozdxLHCXF8LIP23pr2KZUQ,273
+keras/api/_v2/keras/preprocessing/sequence/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/preprocessing/text/__init__.py,sha256=PRzMpqWvu1Zk9P5eCzuqlB4y4nAkNPP5L78wxWK24uA,314
+keras/api/_v2/keras/preprocessing/text/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/regularizers/__init__.py,sha256=sWcPZlc2A9xUSP80sMAYkx2Sch_R0RuM48Ep6xqucmw,598
+keras/api/_v2/keras/regularizers/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/saving/__init__.py,sha256=5WPjhNGUIMklABWkCufo-8kHRvL1V-uJng3PgBzJrEM,654
+keras/api/_v2/keras/saving/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/utils/__init__.py,sha256=V0gpJcIewryo-FvQTr5gPoDFnawea3UkSG_4T5PpNPs,2634
+keras/api/_v2/keras/utils/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/utils/experimental/__init__.py,sha256=JasEFRg4TAriH7JXRBGmbeKUybZTpmBCYC0QQjBpJ2g,94
+keras/api/_v2/keras/utils/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/api/_v2/keras/utils/legacy/__init__.py,sha256=Dh85b96gSEHf9pLzzI04XRcscIsKNfgAa1tXqSozUa8,183
+keras/api/_v2/keras/utils/legacy/__pycache__/__init__.cpython-310.pyc,,
+keras/applications/__init__.py,sha256=Y7Q5GvbJ77sOC9DqJ00xEEWbpcmWOaY27hbag9rl7Fk,4889
+keras/applications/__pycache__/__init__.cpython-310.pyc,,
+keras/applications/convnext/__init__.py,sha256=KzhqImrxJgn7kEuDCZQ2-eYFvQ8vYEwp8QxQq4lKLCs,448
+keras/applications/convnext/__pycache__/__init__.cpython-310.pyc,,
+keras/applications/densenet/__init__.py,sha256=0JnnZbdHm5GfRsRR9DTpSX9a5UiPVOJ1DACbb_07kWA,327
+keras/applications/densenet/__pycache__/__init__.cpython-310.pyc,,
+keras/applications/efficientnet/__init__.py,sha256=4dpr1g6gcEA1e9_FVA0-ORvffpyWKkPyQIaXi9th2lI,671
+keras/applications/efficientnet/__pycache__/__init__.cpython-310.pyc,,
+keras/applications/efficientnet_v2/__init__.py,sha256=37ldnNCTZDdNLMGiJNv9tEjQ6bx-kgXKmLtWu-Bo8Do,646
+keras/applications/efficientnet_v2/__pycache__/__init__.cpython-310.pyc,,
+keras/applications/imagenet_utils/__init__.py,sha256=mGWB1iCNIVRAanLjIBQrMiZyC-v3eSelG4KKx4nas1c,171
+keras/applications/imagenet_utils/__pycache__/__init__.cpython-310.pyc,,
+keras/applications/inception_resnet_v2/__init__.py,sha256=Bc7qxCFU-o2sEQHbbm3FpDn8JK1pYfDCDO3mwG9mmV0,254
+keras/applications/inception_resnet_v2/__pycache__/__init__.cpython-310.pyc,,
+keras/applications/inception_v3/__init__.py,sha256=3a82lFSMNqdEHXDrle2dmFe0Q5aZozxb5Vy8B3Vjijo,227
+keras/applications/inception_v3/__pycache__/__init__.cpython-310.pyc,,
+keras/applications/mobilenet/__init__.py,sha256=3tTybQ02gfFIuO4TcVzovpb8VEuh2gb4jLt_MGCSwG8,216
+keras/applications/mobilenet/__pycache__/__init__.cpython-310.pyc,,
+keras/applications/mobilenet_v2/__init__.py,sha256=4ia3UkhtrAgDd9tTrHp9J3ICMgyo1wBDajap6fS0oLA,227
+keras/applications/mobilenet_v2/__pycache__/__init__.cpython-310.pyc,,
+keras/applications/mobilenet_v3/__init__.py,sha256=GqZStongf1KXK-Z6gUvVFCYVMnF5PvH7K9jepXDSpq8,167
+keras/applications/mobilenet_v3/__pycache__/__init__.cpython-310.pyc,,
+keras/applications/nasnet/__init__.py,sha256=Nh50Xh4mhMWTnP4wbx-RgSX0HC84kTjH-ZaHtu6UhNM,264
+keras/applications/nasnet/__pycache__/__init__.cpython-310.pyc,,
+keras/applications/regnet/__init__.py,sha256=Os1Dl5Lu9sOlbWis-MOmWZ1NHyCQ0DACfjyhxpavo6k,1427
+keras/applications/regnet/__pycache__/__init__.cpython-310.pyc,,
+keras/applications/resnet/__init__.py,sha256=Ut9tpajz7RtTkIgy-OcqH114cuVVJ-p1OlcdyYglyX4,310
+keras/applications/resnet/__pycache__/__init__.cpython-310.pyc,,
+keras/applications/resnet50/__init__.py,sha256=lkUdSmfQhcYhF1dO539O73TYy-gdcAcDWLchVUSYneg,206
+keras/applications/resnet50/__pycache__/__init__.cpython-310.pyc,,
+keras/applications/resnet_rs/__init__.py,sha256=7z7USlNNSM1jHl7R3gQwDjOFWkpgvCsS5weqCp9Siaw,559
+keras/applications/resnet_rs/__pycache__/__init__.cpython-310.pyc,,
+keras/applications/resnet_v2/__init__.py,sha256=flKlNsYwL9gvocgN46E8pE8v7nUPdYIqjU1eByYm5FY,331
+keras/applications/resnet_v2/__pycache__/__init__.cpython-310.pyc,,
+keras/applications/vgg16/__init__.py,sha256=pkYJI5AOKzZjIWiq8tpiwOrL0pag9T0Gu12Y1WE0Q8I,200
+keras/applications/vgg16/__pycache__/__init__.cpython-310.pyc,,
+keras/applications/vgg19/__init__.py,sha256=q45TVPhtXTZIPN6VR31odCjqY2U_lO1dA3nFuLaoeBg,200
+keras/applications/vgg19/__pycache__/__init__.cpython-310.pyc,,
+keras/applications/xception/__init__.py,sha256=ZjRwSLAC9gQ56EVehYinvdPQevFtdVwIhetrYUqRtzw,212
+keras/applications/xception/__pycache__/__init__.cpython-310.pyc,,
+keras/backend/__init__.py,sha256=V2TyJwcZTvMh8C_reXgkR3lAh4JyblhUiVY5wgRIV2k,6130
+keras/backend/__pycache__/__init__.cpython-310.pyc,,
+keras/backend/experimental/__init__.py,sha256=SDuI0PivvHKLXE6AayPaLpqM_MJw7CvbTYU4TSYPems,211
+keras/backend/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/callbacks/__init__.py,sha256=r5yd6N526s7ibMn-toaYo_DPqoDqEzVAiv4FMqdKVxI,838
+keras/callbacks/__pycache__/__init__.cpython-310.pyc,,
+keras/callbacks/experimental/__init__.py,sha256=m0EWhcjroyb1UUoyVhkcWa92ZjKfFkQNhGke6qT5OAE,116
+keras/callbacks/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/constraints/__init__.py,sha256=M0kwfvbwI2zgQqmS-jrULNwHkt92HCuFQxycwc2fYyw,725
+keras/constraints/__pycache__/__init__.cpython-310.pyc,,
+keras/datasets/__init__.py,sha256=DhEoR6Hd7FTSNoJ8wcTQEG9dr0dYl6skMOknMnaCu0Q,289
+keras/datasets/__pycache__/__init__.cpython-310.pyc,,
+keras/datasets/boston_housing/__init__.py,sha256=rXcH1veaB_0_HdpGbgqJ-fi3Sbmah6zoDyGIbJclXF4,91
+keras/datasets/boston_housing/__pycache__/__init__.cpython-310.pyc,,
+keras/datasets/cifar10/__init__.py,sha256=2lWdBr8S1ScNARYA3QTZdH8Sf4gy7hLkYLIlut7Ar8M,84
+keras/datasets/cifar10/__pycache__/__init__.cpython-310.pyc,,
+keras/datasets/cifar100/__init__.py,sha256=KoJc29lj25yACUMgli200LSs3D4VaW6D6LXZuWv6Iv0,85
+keras/datasets/cifar100/__pycache__/__init__.cpython-310.pyc,,
+keras/datasets/fashion_mnist/__init__.py,sha256=22Z8KFQ0KTY6kdrPdrpdB53B_amvcQ7_0oSzXw9JPd4,90
+keras/datasets/fashion_mnist/__pycache__/__init__.cpython-310.pyc,,
+keras/datasets/imdb/__init__.py,sha256=dc_dzqG_C-hcdfoLuByQif-1b29NSubQNAIA2PVR6Aw,132
+keras/datasets/imdb/__pycache__/__init__.cpython-310.pyc,,
+keras/datasets/mnist/__init__.py,sha256=xn0zhrFLUt9O9aSGxWbsutehnlOVHNn8erp80ooxIbc,82
+keras/datasets/mnist/__pycache__/__init__.cpython-310.pyc,,
+keras/datasets/reuters/__init__.py,sha256=_YXB_u3o_sykUzLCr0KZbKJQmVBaBaCDflxjbaoptsQ,193
+keras/datasets/reuters/__pycache__/__init__.cpython-310.pyc,,
+keras/dtensor/__init__.py,sha256=sag3G9YSVie0SOCetgcnq9OMo_qHrYp5RfFfECemZN0,74
+keras/dtensor/__pycache__/__init__.cpython-310.pyc,,
+keras/dtensor/experimental/__init__.py,sha256=i7HXxJ6AAg40aIEXOIwfZGW2UL4jJIyzyhCBoEo9BwM,136
+keras/dtensor/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/dtensor/experimental/optimizers/__init__.py,sha256=WH8jIZv8IPjOuz7jTGm5Mh1IwW0oKx5eQC0MuIvEmu0,313
+keras/dtensor/experimental/optimizers/__pycache__/__init__.cpython-310.pyc,,
+keras/estimator/__init__.py,sha256=BnGi5ykYU3KA0f75iyiXjd5adgeJkfBmxwmJAt8-qkg,111
+keras/estimator/__pycache__/__init__.cpython-310.pyc,,
+keras/experimental/__init__.py,sha256=ThjB_prvy1Ql53a6yb5ZbY0zBPXZN_-ReEhOAJS_isc,489
+keras/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/export/__init__.py,sha256=04wTB07rfbKoKleE7NSWoIbY3ccAt1vKP4SL1rp_7Nw,89
+keras/export/__pycache__/__init__.cpython-310.pyc,,
+keras/initializers/__init__.py,sha256=M60nePNekuVB8E1yxgit9_E5tw0ShNzjGlSoz_M_7II,2231
+keras/initializers/__pycache__/__init__.cpython-310.pyc,,
+keras/layers/__init__.py,sha256=fnUvMPT-fhzJcZgyHrcZpXul3M3Uzk5vN-1M-lA_BSc,9939
+keras/layers/__pycache__/__init__.cpython-310.pyc,,
+keras/layers/experimental/__init__.py,sha256=8yUii6wyVTvj5-hVOrW73l3hBqONkZM9fBAW41yPa88,294
+keras/layers/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/layers/experimental/preprocessing/__init__.py,sha256=YxHmFDcmXSw6KaBTslhcqxYo1XPnU5pHWmlJ9le6eqo,1514
+keras/layers/experimental/preprocessing/__pycache__/__init__.cpython-310.pyc,,
+keras/losses/__init__.py,sha256=pQk_NLblOND1gMdGw6agj_UIuR1r9sgHXalGD3tio3k,2584
+keras/losses/__pycache__/__init__.cpython-310.pyc,,
+keras/metrics/__init__.py,sha256=31PDPelxQvPlSrcFBXTPfmYZFMY5cluWxOJseBOIS-o,4812
+keras/metrics/__pycache__/__init__.cpython-310.pyc,,
+keras/metrics/experimental/__init__.py,sha256=DicB16TRW7vpS1BvZ-cfTRNLMQUy8LJ1A_xxC-SzFLI,84
+keras/metrics/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/mixed_precision/__init__.py,sha256=cSkDGo1cOxIQhXKdEW_cd1c7qRZgloc2ro0RlQ2U2Fg,313
+keras/mixed_precision/__pycache__/__init__.cpython-310.pyc,,
+keras/models/__init__.py,sha256=K5f7IOI2PyA3rITCtsBkbCrMRqVn0Egaj_HTUihSEhM,516
+keras/models/__pycache__/__init__.cpython-310.pyc,,
+keras/models/experimental/__init__.py,sha256=37OjKKBRWpvAMglh8Eg28JFjlN95sM0VCeSAF2a-EEw,120
+keras/models/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/optimizers/__init__.py,sha256=JNDkxL11yCE8LbEDfewIgjNR48kgwmqDHlRIBffOJII,839
+keras/optimizers/__pycache__/__init__.cpython-310.pyc,,
+keras/optimizers/experimental/__init__.py,sha256=w05szJpm7YE_L0G73-U7hNpNR39y1bqhuaQe9qnOd6w,554
+keras/optimizers/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/optimizers/legacy/__init__.py,sha256=dCvdb-haPTtsVe3aVZ6mA_Lj9QNMsf7v2j2i1YuCijs,550
+keras/optimizers/legacy/__pycache__/__init__.cpython-310.pyc,,
+keras/optimizers/schedules/__init__.py,sha256=7dW7L_4x1HMH5st13am6eaXibaoG0n_9WnqyZqv4mfs,777
+keras/optimizers/schedules/__pycache__/__init__.cpython-310.pyc,,
+keras/preprocessing/__init__.py,sha256=L4kwRmGWMPJCwXCN9LUfXQjuG9GD0iDKXEC9gsClaHk,368
+keras/preprocessing/__pycache__/__init__.cpython-310.pyc,,
+keras/preprocessing/image/__init__.py,sha256=A4aKMlEY7V-suuoL9VlttmnIwfs8wuRNQMZhcxgyJlk,1062
+keras/preprocessing/image/__pycache__/__init__.cpython-310.pyc,,
+keras/preprocessing/sequence/__init__.py,sha256=0yTj4-NMEyZFE98f3H8ULozdxLHCXF8LIP23pr2KZUQ,273
+keras/preprocessing/sequence/__pycache__/__init__.cpython-310.pyc,,
+keras/preprocessing/text/__init__.py,sha256=PRzMpqWvu1Zk9P5eCzuqlB4y4nAkNPP5L78wxWK24uA,314
+keras/preprocessing/text/__pycache__/__init__.cpython-310.pyc,,
+keras/protobuf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+keras/protobuf/__pycache__/__init__.cpython-310.pyc,,
+keras/protobuf/__pycache__/projector_config_pb2.cpython-310.pyc,,
+keras/protobuf/__pycache__/saved_metadata_pb2.cpython-310.pyc,,
+keras/protobuf/__pycache__/versions_pb2.cpython-310.pyc,,
+keras/protobuf/projector_config_pb2.py,sha256=FCmY0g4Blqw74gOvtx692PO5kk4rpSggWRcvWvHWOEg,1800
+keras/protobuf/saved_metadata_pb2.py,sha256=mc4zmR07yNPuCSO1inPz6upyLBS0TFa9n8ghWm3azVo,1566
+keras/protobuf/versions_pb2.py,sha256=6_cdMek7L3uCTnkixBhnDcNXgQFFj7_WJLJJuVg9IPA,1113
+keras/regularizers/__init__.py,sha256=sWcPZlc2A9xUSP80sMAYkx2Sch_R0RuM48Ep6xqucmw,598
+keras/regularizers/__pycache__/__init__.cpython-310.pyc,,
+keras/saving/__init__.py,sha256=5WPjhNGUIMklABWkCufo-8kHRvL1V-uJng3PgBzJrEM,654
+keras/saving/__pycache__/__init__.cpython-310.pyc,,
+keras/src/__init__.py,sha256=fKMjQ9Orkdf8HqGBub6c9HoqbH6zl3XH-3o46-fecXE,1345
+keras/src/__pycache__/__init__.cpython-310.pyc,,
+keras/src/__pycache__/activations.cpython-310.pyc,,
+keras/src/__pycache__/backend.cpython-310.pyc,,
+keras/src/__pycache__/backend_config.cpython-310.pyc,,
+keras/src/__pycache__/callbacks.cpython-310.pyc,,
+keras/src/__pycache__/callbacks_v1.cpython-310.pyc,,
+keras/src/__pycache__/constraints.cpython-310.pyc,,
+keras/src/__pycache__/losses.cpython-310.pyc,,
+keras/src/__pycache__/regularizers.cpython-310.pyc,,
+keras/src/activations.py,sha256=pQzVjxZBYuPVcUmHUQFE6ruDOAZWv5-VFcjQp-V0E8M,22606
+keras/src/applications/__init__.py,sha256=GKvI9-O_jfl7gAps7mKlxxYUMEsDenrgu83VxI-nLdw,3560
+keras/src/applications/__pycache__/__init__.cpython-310.pyc,,
+keras/src/applications/__pycache__/convnext.cpython-310.pyc,,
+keras/src/applications/__pycache__/densenet.cpython-310.pyc,,
+keras/src/applications/__pycache__/efficientnet.cpython-310.pyc,,
+keras/src/applications/__pycache__/efficientnet_v2.cpython-310.pyc,,
+keras/src/applications/__pycache__/imagenet_utils.cpython-310.pyc,,
+keras/src/applications/__pycache__/inception_resnet_v2.cpython-310.pyc,,
+keras/src/applications/__pycache__/inception_v3.cpython-310.pyc,,
+keras/src/applications/__pycache__/mobilenet.cpython-310.pyc,,
+keras/src/applications/__pycache__/mobilenet_v2.cpython-310.pyc,,
+keras/src/applications/__pycache__/mobilenet_v3.cpython-310.pyc,,
+keras/src/applications/__pycache__/nasnet.cpython-310.pyc,,
+keras/src/applications/__pycache__/regnet.cpython-310.pyc,,
+keras/src/applications/__pycache__/resnet.cpython-310.pyc,,
+keras/src/applications/__pycache__/resnet_rs.cpython-310.pyc,,
+keras/src/applications/__pycache__/resnet_v2.cpython-310.pyc,,
+keras/src/applications/__pycache__/vgg16.cpython-310.pyc,,
+keras/src/applications/__pycache__/vgg19.cpython-310.pyc,,
+keras/src/applications/__pycache__/xception.cpython-310.pyc,,
+keras/src/applications/convnext.py,sha256=lpM04-O2nAdtf7GlwgghMDRAfBR8ukEjwtC7zPBVwsI,25575
+keras/src/applications/densenet.py,sha256=TNUpHgrst0akyxe7YJ-HhwuwwG3XIH4RhNOuL4Gl44k,17353
+keras/src/applications/efficientnet.py,sha256=M93c9DSxuX8N-M0lREix603TxW_zSjGPIMTgYfFWdWo,26363
+keras/src/applications/efficientnet_v2.py,sha256=Tq0bVc6e04vIBlVUATv93lk1HVnQmmziBudYCMvzhcw,41342
+keras/src/applications/imagenet_utils.py,sha256=lvmsGyKtYRAgNtw-hri0tXedh_-a_rDxnT4GL49syY8,16669
+keras/src/applications/inception_resnet_v2.py,sha256=GqLff6RcrzrCoWJUsKkPofUM5y6rWu8ss1SPallgykY,16178
+keras/src/applications/inception_v3.py,sha256=oJwFAUdQwKvS5a-11KRzjzgv-KxxjWxSfHYd0RUBNZs,16300
+keras/src/applications/mobilenet.py,sha256=kgZor6mElhoytC0LtG-vITvum3ulNmbvzAqkg6nCXkw,20100
+keras/src/applications/mobilenet_v2.py,sha256=ySPySXeNjp40W3aLcLr6BxqjvQ1shmnmJFFJGeEmFbQ,22054
+keras/src/applications/mobilenet_v3.py,sha256=x8feuuM9r0v0m7rVgt8xYq2v4zdCNsAOLNlkvqRDCMI,24454
+keras/src/applications/nasnet.py,sha256=fGAVrjYBdc8CtAMsz3xzoBD9vyOtNIx6F0u46CtZMeU,32658
+keras/src/applications/regnet.py,sha256=8c0_KGPUF6LpQK5xx_7aaaP_7sF4by8dDyy2zGxxIHk,55746
+keras/src/applications/resnet.py,sha256=9E3tKrY0fyebNbsb7sUkHh9sCCtB1RdJdDP_o6NhTME,22275
+keras/src/applications/resnet_rs.py,sha256=ez6LRfyqolQ535qykJ4jbJchui0Cyp7EyjqXjz2hHB4,33428
+keras/src/applications/resnet_v2.py,sha256=xfjwQ21wqLD30NlViF8vDYYXVZbPlGTEgvIjuEyVCKw,6886
+keras/src/applications/vgg16.py,sha256=2rxenXg44Z9u127mHskUUDzNGryhTgi1DJjNbxUzs-U,10086
+keras/src/applications/vgg19.py,sha256=vUP6F0l2m02kgoYT47qeE8w0fCrUP5E35Nf6iIMxi8w,10301
+keras/src/applications/xception.py,sha256=tb82RrWGSlJJeHC57Z4klmPMa7qQZp7F8-OqePUH5e8,13617
+keras/src/backend.py,sha256=GhPnzerSxM_c51I-atj94QQytaiukYRaxvs304kmwXM,248194
+keras/src/backend_config.py,sha256=DaKkQg6jLmzR2GtgjNxwFoHuTXwVcAzx_Hx8XgAKPNs,4516
+keras/src/benchmarks/__init__.py,sha256=45BVy4NxrQKTguP4U1e77BIC4E6E0Pc-rbrTgztA3Bg,714
+keras/src/benchmarks/__pycache__/__init__.cpython-310.pyc,,
+keras/src/benchmarks/__pycache__/benchmark_util.cpython-310.pyc,,
+keras/src/benchmarks/__pycache__/distribution_util.cpython-310.pyc,,
+keras/src/benchmarks/__pycache__/model_memory_profile.cpython-310.pyc,,
+keras/src/benchmarks/benchmark_util.py,sha256=Vk3EMUh2mKpwY-ohH0eRS8AleRADUPWmJdZyQi3e-9o,7672
+keras/src/benchmarks/distribution_util.py,sha256=mbnbRlgDGzJTqhdQw4fRIPhT2JztDviJgXT86MfQEEc,6567
+keras/src/benchmarks/model_memory_profile.py,sha256=6nHJVZa2y02GPJniacDbw3ACkPVodmnZltCeqlhOwx0,2242
+keras/src/callbacks.py,sha256=7Efo-NoT8TQZZ9dvAoIrvJMm9ZXs-jbmayaBscxb1c4,128969
+keras/src/callbacks_v1.py,sha256=k5dd79TpFJiQieZqZeTawDqOrd1hAd88Zp3nbFCQWyE,22144
+keras/src/constraints.py,sha256=w3D62K_VZIk5ikltVCWYWuPfeSo89bRqmvZIRUFYWsI,13934
+keras/src/datasets/__init__.py,sha256=YSVzC5NDV0KgkQwLZqJgWHuVZRkXkAdEVKlRs73RFXo,51
+keras/src/datasets/__pycache__/__init__.cpython-310.pyc,,
+keras/src/datasets/__pycache__/boston_housing.cpython-310.pyc,,
+keras/src/datasets/__pycache__/cifar.cpython-310.pyc,,
+keras/src/datasets/__pycache__/cifar10.cpython-310.pyc,,
+keras/src/datasets/__pycache__/cifar100.cpython-310.pyc,,
+keras/src/datasets/__pycache__/fashion_mnist.cpython-310.pyc,,
+keras/src/datasets/__pycache__/imdb.cpython-310.pyc,,
+keras/src/datasets/__pycache__/mnist.cpython-310.pyc,,
+keras/src/datasets/__pycache__/reuters.cpython-310.pyc,,
+keras/src/datasets/boston_housing.py,sha256=wvo6GhZZYQhz6EpG3q7nVLX0LMyoniP_Ol6B3JVm2Ng,3388
+keras/src/datasets/cifar.py,sha256=mMMwDOf7IYGeVlLemhiA_RSXzSF3CuwFllGpokh-pKs,1394
+keras/src/datasets/cifar10.py,sha256=_voUraF74kOeqwT66QKe_5ih_4e991USQ5uj7eYJnsE,3758
+keras/src/datasets/cifar100.py,sha256=ntQfP043otMshSPHMEcjT2tFjW2RrVB95L3isvntaI0,3550
+keras/src/datasets/fashion_mnist.py,sha256=iRhEgo6-uVSauLaogaesE_ScEehxX8sTXKBSs7EekEM,3632
+keras/src/datasets/imdb.py,sha256=1b7hW2rF9E4mGY3yvODGJwvZIxN_IEVgSczxuz9PmNc,8284
+keras/src/datasets/mnist.py,sha256=wheDXndSnC6Z_1XRZhWLhgJvWbqbxn7s3JoFB_vgGE4,3082
+keras/src/datasets/reuters.py,sha256=c8A2ZylPc_cDmtLVe0-7dK7UrL2uSJoj3Z9F0jo9IJ4,8297
+keras/src/distribute/__init__.py,sha256=DbbsbJOIWEtjQiv6Stq1KEVvnoAK-E5-Zdkd2FhBZiI,734
+keras/src/distribute/__pycache__/__init__.cpython-310.pyc,,
+keras/src/distribute/__pycache__/dataset_creator_model_fit_test_base.cpython-310.pyc,,
+keras/src/distribute/__pycache__/distribute_coordinator_utils.cpython-310.pyc,,
+keras/src/distribute/__pycache__/distributed_file_utils.cpython-310.pyc,,
+keras/src/distribute/__pycache__/distributed_training_utils.cpython-310.pyc,,
+keras/src/distribute/__pycache__/distributed_training_utils_v1.cpython-310.pyc,,
+keras/src/distribute/__pycache__/keras_correctness_test_base.cpython-310.pyc,,
+keras/src/distribute/__pycache__/model_collection_base.cpython-310.pyc,,
+keras/src/distribute/__pycache__/model_combinations.cpython-310.pyc,,
+keras/src/distribute/__pycache__/multi_worker_testing_utils.cpython-310.pyc,,
+keras/src/distribute/__pycache__/optimizer_combinations.cpython-310.pyc,,
+keras/src/distribute/__pycache__/saved_model_test_base.cpython-310.pyc,,
+keras/src/distribute/__pycache__/simple_models.cpython-310.pyc,,
+keras/src/distribute/__pycache__/strategy_combinations.cpython-310.pyc,,
+keras/src/distribute/__pycache__/test_example.cpython-310.pyc,,
+keras/src/distribute/__pycache__/tpu_strategy_test_utils.cpython-310.pyc,,
+keras/src/distribute/__pycache__/worker_training_state.cpython-310.pyc,,
+keras/src/distribute/dataset_creator_model_fit_test_base.py,sha256=YqaEuJCts6ap_r1Da0IDIv4SGTYj2BTqqq9oRb19Dqw,8528
+keras/src/distribute/distribute_coordinator_utils.py,sha256=RewsBtyV0fPnAxF326ZH8RM40nXJoWshg06Usc-Ndgk,29246
+keras/src/distribute/distributed_file_utils.py,sha256=lC5T2DwZyJbleDU40G4DZY_xNnyA2fcimRj-bXirUAw,6449
+keras/src/distribute/distributed_training_utils.py,sha256=Hb0uv1gwAxYlvqBwmRqv4q3NTClHA7L2G8NhR3alWRo,4724
+keras/src/distribute/distributed_training_utils_v1.py,sha256=CPTZ8cr1R03oEsv_BIOeW6Zo7XmuuqZuhQReQX81DyY,48975
+keras/src/distribute/keras_correctness_test_base.py,sha256=NfoDe1YN_tjVgbsITK2by3dUPtXba44nFkWPzga4H5w,24049
+keras/src/distribute/model_collection_base.py,sha256=QxaW9ERCaW6DQh8syKrV4nn4mCj0MsgEVUU5t6AOEnc,1639
+keras/src/distribute/model_combinations.py,sha256=a9uikV8yEzo-y1SFx9FHJReUItCkfWKrzQalpnwjXr8,1403
+keras/src/distribute/multi_worker_testing_utils.py,sha256=L7hRfOsCVGdB6PYPH6UgJ_QPtxTG3-akj3W93h8iuRo,8893
+keras/src/distribute/optimizer_combinations.py,sha256=Q85V96K3YcnxUpWjMkPKa9cNz3l380uyeQdfGoWa4IY,5856
+keras/src/distribute/saved_model_test_base.py,sha256=0po3aCq_AKXAiDPOjWoJRSgzLWtjujZV_7X3YKI1eCE,10321
+keras/src/distribute/simple_models.py,sha256=eKJwpZ6wH7x_c1tDgsQg_XEK5NhdK8ruJIhceeNHg4A,3764
+keras/src/distribute/strategy_combinations.py,sha256=CWwk6ow6Z7FhIqJCUtywlx1g06ZPHNPf_sjpD2e92C0,3101
+keras/src/distribute/test_example.py,sha256=H-68HV_VvvG9ik_mKvdPl9ihfeMlD5_MhhwsygrmktE,3633
+keras/src/distribute/tpu_strategy_test_utils.py,sha256=MuGST-i0UceU_P8sNfU8M3g0WbnYBvZXxI0SA5H07ig,1462
+keras/src/distribute/worker_training_state.py,sha256=z0v43k03usRyFjHnh7mvyNvsLJ_J3arl2poRbqgojX0,9190
+keras/src/dtensor/__init__.py,sha256=ijd8PQgyL1YLyJ-T_ilw9Ja1u1DmVaHv2qmK_K6QLF8,791
+keras/src/dtensor/__pycache__/__init__.cpython-310.pyc,,
+keras/src/dtensor/__pycache__/integration_test_utils.cpython-310.pyc,,
+keras/src/dtensor/__pycache__/layout_map.cpython-310.pyc,,
+keras/src/dtensor/__pycache__/lazy_variable.cpython-310.pyc,,
+keras/src/dtensor/__pycache__/test_util.cpython-310.pyc,,
+keras/src/dtensor/__pycache__/utils.cpython-310.pyc,,
+keras/src/dtensor/integration_test_utils.py,sha256=HEvyMV_QSg29NtaC1W38mwyXSmZnP4CmaM-odtJQoOc,5522
+keras/src/dtensor/layout_map.py,sha256=IO8hWWZLe7QRAmmpKTUj8zf-hsP-aiZsrlC24uF4WD8,22600
+keras/src/dtensor/lazy_variable.py,sha256=FPD9_JjEioUdNe1nJ-IsRfENavuK8vUrVdbCMWIGKJg,9901
+keras/src/dtensor/test_util.py,sha256=9QAbt44mlirdqwG2ertTsoXNKG2V4Z0bqJFxGdxy5BY,4572
+keras/src/dtensor/utils.py,sha256=HTb9WPBg7dXJhr_6Bu9vRUaseQtt93G4UgoT36j4MDw,6429
+keras/src/engine/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+keras/src/engine/__pycache__/__init__.cpython-310.pyc,,
+keras/src/engine/__pycache__/base_layer.cpython-310.pyc,,
+keras/src/engine/__pycache__/base_layer_utils.cpython-310.pyc,,
+keras/src/engine/__pycache__/base_layer_v1.cpython-310.pyc,,
+keras/src/engine/__pycache__/base_preprocessing_layer.cpython-310.pyc,,
+keras/src/engine/__pycache__/compile_utils.cpython-310.pyc,,
+keras/src/engine/__pycache__/data_adapter.cpython-310.pyc,,
+keras/src/engine/__pycache__/functional.cpython-310.pyc,,
+keras/src/engine/__pycache__/functional_utils.cpython-310.pyc,,
+keras/src/engine/__pycache__/input_layer.cpython-310.pyc,,
+keras/src/engine/__pycache__/input_spec.cpython-310.pyc,,
+keras/src/engine/__pycache__/keras_tensor.cpython-310.pyc,,
+keras/src/engine/__pycache__/node.cpython-310.pyc,,
+keras/src/engine/__pycache__/partial_batch_padding_handler.cpython-310.pyc,,
+keras/src/engine/__pycache__/saving.cpython-310.pyc,,
+keras/src/engine/__pycache__/sequential.cpython-310.pyc,,
+keras/src/engine/__pycache__/training.cpython-310.pyc,,
+keras/src/engine/__pycache__/training_arrays_v1.cpython-310.pyc,,
+keras/src/engine/__pycache__/training_distributed_v1.cpython-310.pyc,,
+keras/src/engine/__pycache__/training_eager_v1.cpython-310.pyc,,
+keras/src/engine/__pycache__/training_generator_v1.cpython-310.pyc,,
+keras/src/engine/__pycache__/training_utils.cpython-310.pyc,,
+keras/src/engine/__pycache__/training_utils_v1.cpython-310.pyc,,
+keras/src/engine/__pycache__/training_v1.cpython-310.pyc,,
+keras/src/engine/base_layer.py,sha256=wbnOzWn82mfoSUMRv6u95GugYCr0ybwEq_r1wosb9SE,157129
+keras/src/engine/base_layer_utils.py,sha256=eV4nvUStpfOGkROZJNrvL42E13vMOH9yRr030VbfJ1o,35639
+keras/src/engine/base_layer_v1.py,sha256=ptBF3oZPtDvfdUaMYVEKahI8Q2lHQ3yUC-XNKA-J6ZI,102384
+keras/src/engine/base_preprocessing_layer.py,sha256=jZCEIucGxw1_5v1iDTO9gcDaslBVoKiDS8hV--RRfKw,12804
+keras/src/engine/compile_utils.py,sha256=8O_bPdGi9SIOxh3TlzkrF51-Rgqrxv_5avNKCnqDlxo,31739
+keras/src/engine/data_adapter.py,sha256=y2V3mM7ZDQZGoErgCNFRWBUP9KSAsU9h9ky_PEBY89A,71275
+keras/src/engine/functional.py,sha256=v5XX4wmNsB-p6HfPQ8wXbFLE4EJdLJ0XX0KBbykHIwg,70169
+keras/src/engine/functional_utils.py,sha256=jB7PWhBO8aXqBjLWdnipDt-25pmCnIXHI2-4THUMqp8,11036
+keras/src/engine/input_layer.py,sha256=4i7dzC-uMkNZH4jAoe51j8_-UhWwOcxkdrUhCfhBFK4,18198
+keras/src/engine/input_spec.py,sha256=zw0k4jgiyEXLZPjQN3Qhupl4NE_eLoBu_d-tRvcVCMU,12070
+keras/src/engine/keras_tensor.py,sha256=SBjvJmE8g21FjnhYka02pQ96mitCMiY74WoFu8fN2IY,28748
+keras/src/engine/node.py,sha256=0DHVQrMXcPaUSyfyfEmZuVtZZH7AIfwqG8v56Ebzi50,13833
+keras/src/engine/partial_batch_padding_handler.py,sha256=mtrLuuWCN8qmdzW7GKfv9vTJamGNH8ZoFHEGuNU5WhQ,4322
+keras/src/engine/saving.py,sha256=kq_ziIVysUt7KQj5LQ6g6nJIplW077APLvknyZl6Adc,850
+keras/src/engine/sequential.py,sha256=PYcMj_e9BSr_LCuXBy0szK1O-Q3xRuPvxt0MhgLC4iQ,22996
+keras/src/engine/training.py,sha256=062Xn16Nu4iNWSPIz0rJ_9lH-3pW_ujVo6KZkkl7FK4,193565
+keras/src/engine/training_arrays_v1.py,sha256=HngooWxX87LX5zgYOD_75bkr9UABVJNyqK5fpQUy3ac,30874
+keras/src/engine/training_distributed_v1.py,sha256=bbXnY_OeB1sIvWbbgychdc1J0bTGce5tidwu7PqHz1w,32042
+keras/src/engine/training_eager_v1.py,sha256=g7j24WlclXBDLywm1aJSNbpkJSxfejz1tcudtpmUUYk,15362
+keras/src/engine/training_generator_v1.py,sha256=GDuDbEUwwCp2kBeoU1FZdyTjjdqQl-kp8p75eMg4lEo,32750
+keras/src/engine/training_utils.py,sha256=bc8s01jtJRGwj7XgVrCHfQ6xpUSnGEPFdOn9xCm_IGE,8730
+keras/src/engine/training_utils_v1.py,sha256=6lxLVNsMBm2fMu_upzzzl95ejy18-fm5ulCrvHiq6GQ,82671
+keras/src/engine/training_v1.py,sha256=c5O7xLheqgqqSkLQXFOnR7DzUQPAVaFCyy5fssrANSc,153202
+keras/src/estimator/__init__.py,sha256=W08307-EzY3YS69ZegoKFZFXpvtWlgY8cnWLhLoc1e8,17290
+keras/src/estimator/__pycache__/__init__.cpython-310.pyc,,
+keras/src/export/__init__.py,sha256=wIyCb8_fNwn61HDG_Q884cpnf7EcOuMbM3O2wptekaA,745
+keras/src/export/__pycache__/__init__.cpython-310.pyc,,
+keras/src/export/__pycache__/export_lib.cpython-310.pyc,,
+keras/src/export/export_lib.py,sha256=9peitD_PfnFUUYscIeDktoQX-uzkSCGjxQd7c7Fu0cE,23344
+keras/src/feature_column/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+keras/src/feature_column/__pycache__/__init__.cpython-310.pyc,,
+keras/src/feature_column/__pycache__/base_feature_layer.cpython-310.pyc,,
+keras/src/feature_column/__pycache__/dense_features.cpython-310.pyc,,
+keras/src/feature_column/__pycache__/dense_features_v2.cpython-310.pyc,,
+keras/src/feature_column/__pycache__/sequence_feature_column.cpython-310.pyc,,
+keras/src/feature_column/base_feature_layer.py,sha256=CM8REptnN7_95e3TSyz4l8c4kj-O1x-9qBPZFm3SbRY,8912
+keras/src/feature_column/dense_features.py,sha256=CcjWSwgYDZTIJ09BzHtMs7oQ25IKASMr9EBqQ55v4T0,7996
+keras/src/feature_column/dense_features_v2.py,sha256=ZUfgNs8FuEFK0imjRDvuRM4LZxOfbmvpHypqHrEbtKk,6207
+keras/src/feature_column/sequence_feature_column.py,sha256=FGj-HUAGTfEL76YWRPBo51v1c7A4mT22HrrhiQZkQu0,7675
+keras/src/initializers/__init__.py,sha256=ZnD-SkfJV5hnBJh1W8aW-gWXvjKNz7OJeoIuztjmuvo,9028
+keras/src/initializers/__pycache__/__init__.cpython-310.pyc,,
+keras/src/initializers/__pycache__/initializers.cpython-310.pyc,,
+keras/src/initializers/__pycache__/initializers_v1.cpython-310.pyc,,
+keras/src/initializers/initializers.py,sha256=QqHBSxuBmFd4cKDtTz2jgVbTEOv-XHWmgBWDIJOmNIk,42671
+keras/src/initializers/initializers_v1.py,sha256=5eAWDLLl9QcqQ3K8AtqFh9nYvwbAil-IZLwEXI8gbe8,18591
+keras/src/layers/__init__.py,sha256=QNnP7FS63FiXKCcdRpBTaiEucsaggKNAX-ku90Q9lMM,14016
+keras/src/layers/__pycache__/__init__.cpython-310.pyc,,
+keras/src/layers/__pycache__/kernelized.cpython-310.pyc,,
+keras/src/layers/__pycache__/noise.cpython-310.pyc,,
+keras/src/layers/__pycache__/serialization.cpython-310.pyc,,
+keras/src/layers/activation/__init__.py,sha256=zBfjdI-L0XusavfuC_btqHpkpGiyRfPx64ZmYBBQJdg,1079
+keras/src/layers/activation/__pycache__/__init__.cpython-310.pyc,,
+keras/src/layers/activation/__pycache__/elu.cpython-310.pyc,,
+keras/src/layers/activation/__pycache__/leaky_relu.cpython-310.pyc,,
+keras/src/layers/activation/__pycache__/prelu.cpython-310.pyc,,
+keras/src/layers/activation/__pycache__/relu.cpython-310.pyc,,
+keras/src/layers/activation/__pycache__/softmax.cpython-310.pyc,,
+keras/src/layers/activation/__pycache__/thresholded_relu.cpython-310.pyc,,
+keras/src/layers/activation/elu.py,sha256=1Yhpem8CnXOILxiKo-okHbUdm6MDsK76BuEVUvCdKgU,2165
+keras/src/layers/activation/leaky_relu.py,sha256=z75rb6RaN6zYYVea4wMvYT2nseO2C5NEdGDbzAI2-fc,2609
+keras/src/layers/activation/prelu.py,sha256=8otGxhuU2yxch134k5eTvXQaNq0eKmRFaX9U_zapAwM,4410
+keras/src/layers/activation/relu.py,sha256=zJ6C6DWv6Hy2OTRT23r79Bs-lc0Ir5CZwq7GdT50hsU,4272
+keras/src/layers/activation/softmax.py,sha256=Yq51Ufa_JWbX1EHtIDF2lhiLJDkDafWzLDntUW09A3M,4096
+keras/src/layers/activation/thresholded_relu.py,sha256=0n1N93nmbZuRha5_TzIuNyRGnEex1ES4xhEK3El7HC8,2494
+keras/src/layers/attention/__init__.py,sha256=Fru6VyoDtI5zgxFuX3MsA5P5-s0-Jqp_kwkTtVcnYlE,936
+keras/src/layers/attention/__pycache__/__init__.cpython-310.pyc,,
+keras/src/layers/attention/__pycache__/additive_attention.cpython-310.pyc,,
+keras/src/layers/attention/__pycache__/attention.cpython-310.pyc,,
+keras/src/layers/attention/__pycache__/base_dense_attention.cpython-310.pyc,,
+keras/src/layers/attention/__pycache__/multi_head_attention.cpython-310.pyc,,
+keras/src/layers/attention/additive_attention.py,sha256=kXwlHunGdK-JW2-Yf3mU2_vS1FOw7DZjXa0dCY0HiD4,7482
+keras/src/layers/attention/attention.py,sha256=_YBEnjLaw0oWsvcCiQhe3IX9_D7bpwUsHxF2wLODwPQ,8679
+keras/src/layers/attention/base_dense_attention.py,sha256=Z0lqUjIbHh2JFN_167tTY2-iMEkyymMM0SX8qXIhZUY,10805
+keras/src/layers/attention/multi_head_attention.py,sha256=W-yX1Ztpq8AeUnmZ5e19igc7LtJZr5LOvz92jD0HhE4,30246
+keras/src/layers/convolutional/__init__.py,sha256=z3bVYU4Ry972ELej6g073ZxOryOeWvEB5V5SeYTJQY0,3211
+keras/src/layers/convolutional/__pycache__/__init__.cpython-310.pyc,,
+keras/src/layers/convolutional/__pycache__/base_conv.cpython-310.pyc,,
+keras/src/layers/convolutional/__pycache__/base_depthwise_conv.cpython-310.pyc,,
+keras/src/layers/convolutional/__pycache__/base_separable_conv.cpython-310.pyc,,
+keras/src/layers/convolutional/__pycache__/conv1d.cpython-310.pyc,,
+keras/src/layers/convolutional/__pycache__/conv1d_transpose.cpython-310.pyc,,
+keras/src/layers/convolutional/__pycache__/conv2d.cpython-310.pyc,,
+keras/src/layers/convolutional/__pycache__/conv2d_transpose.cpython-310.pyc,,
+keras/src/layers/convolutional/__pycache__/conv3d.cpython-310.pyc,,
+keras/src/layers/convolutional/__pycache__/conv3d_transpose.cpython-310.pyc,,
+keras/src/layers/convolutional/__pycache__/depthwise_conv1d.cpython-310.pyc,,
+keras/src/layers/convolutional/__pycache__/depthwise_conv2d.cpython-310.pyc,,
+keras/src/layers/convolutional/__pycache__/separable_conv1d.cpython-310.pyc,,
+keras/src/layers/convolutional/__pycache__/separable_conv2d.cpython-310.pyc,,
+keras/src/layers/convolutional/base_conv.py,sha256=sQgACeQTEI0Zq7bP3Xf5PAzEDxcGYt1IOicX75bhtSI,17539
+keras/src/layers/convolutional/base_depthwise_conv.py,sha256=Y75HeEOK-Fmz1u1V_jXYIdFXUxAIkmYEGPz3kuQR7Fw,9507
+keras/src/layers/convolutional/base_separable_conv.py,sha256=XdIMAH46qqWGoN3-wF9qkXEE8IxrDXkodRSbRom0d-M,10905
+keras/src/layers/convolutional/conv1d.py,sha256=wCpS82ISVFs5DawC9OZvS4I8bn_c6vjLoF8zgX4ykFA,7605
+keras/src/layers/convolutional/conv1d_transpose.py,sha256=K-IEVJN_5b_8PqDtdV_0HmHHwpE73dduTWlmpY8KP-A,11861
+keras/src/layers/convolutional/conv2d.py,sha256=UQmBlVrogsOgJqH_cPdcbVfSqLvZAilt5tLo09phJ-U,8592
+keras/src/layers/convolutional/conv2d_transpose.py,sha256=ccLeJYzQdrQ3PJc2ThfoarBj_SOjeMHHJEqbd2B70qI,14469
+keras/src/layers/convolutional/conv3d.py,sha256=ZGB3ZpOW0tAivYgO1gWN0hnH5ubnsDY8FKaIqXlDexo,8249
+keras/src/layers/convolutional/conv3d_transpose.py,sha256=qc4RtdabvSmRjj1xhwMVXdRHxeH0Q5lPaMVvfa7AlY8,14978
+keras/src/layers/convolutional/depthwise_conv1d.py,sha256=ozFbCZ1xbPCSUuOHInU_PzwxmlbZ_N91frv8wdi44Lk,8918
+keras/src/layers/convolutional/depthwise_conv2d.py,sha256=briTBaSDD0gmFGyNwB4SzcrWvdgoYK-RMPbCX7N1_cA,8744
+keras/src/layers/convolutional/separable_conv1d.py,sha256=PO6DT4ECl4Wng2vMq96zCuIxplGURV5YZa3nBT5iW14,9375
+keras/src/layers/convolutional/separable_conv2d.py,sha256=Xp8i7yzgb8j50m075RyBNkem_veLyqEb-GmiZC-xeg0,8910
+keras/src/layers/core/__init__.py,sha256=V9xh6ImuBhBGCV-qvvvLPa2TVMJkThnV_BMzjaMOyl4,2351
+keras/src/layers/core/__pycache__/__init__.cpython-310.pyc,,
+keras/src/layers/core/__pycache__/activation.cpython-310.pyc,,
+keras/src/layers/core/__pycache__/dense.cpython-310.pyc,,
+keras/src/layers/core/__pycache__/einsum_dense.cpython-310.pyc,,
+keras/src/layers/core/__pycache__/embedding.cpython-310.pyc,,
+keras/src/layers/core/__pycache__/identity.cpython-310.pyc,,
+keras/src/layers/core/__pycache__/lambda_layer.cpython-310.pyc,,
+keras/src/layers/core/__pycache__/masking.cpython-310.pyc,,
+keras/src/layers/core/__pycache__/tf_op_layer.cpython-310.pyc,,
+keras/src/layers/core/activation.py,sha256=dRujuGqzgU0gSNAJKViGwgZk_qrUkJvZSr48OToC65I,2242
+keras/src/layers/core/dense.py,sha256=HnlS8Bs_aumidJ-rQ74-FhUqINcLJ9tW8NEFPuzvCFo,12912
+keras/src/layers/core/einsum_dense.py,sha256=EmZVpUKqvwovXzW3dpoJexZi7WwqM32vClbroVv18O4,13989
+keras/src/layers/core/embedding.py,sha256=XKHpHJnkzWHWqof3G____45SrrW3qi8u4EtKJaWqvcg,12977
+keras/src/layers/core/identity.py,sha256=8GlaIh1EXvmw-SzT6tryEqFdaC4PtXHjXStO07_b6X4,1298
+keras/src/layers/core/lambda_layer.py,sha256=cFgnKgg-q-jpt0zbLes8pi7anfjUlk8yt9wJ2YNW8rk,16466
+keras/src/layers/core/masking.py,sha256=ToC-Sb2b1xBB0WWhieHaXbeyJFJQ-b71_yxibIbnFcU,3337
+keras/src/layers/core/tf_op_layer.py,sha256=ds7t5BGQ--Zk8qqTEZ9JqgC5eKRxyq2o-9H1EiMvM70,21036
+keras/src/layers/kernelized.py,sha256=5zJ7PVRK3pn7_thnJ8dJiwwDxV7AboB-Mf0EEa-BAfg,11309
+keras/src/layers/locally_connected/__init__.py,sha256=zBW6eL4LJgkvmjFLpnbdQtiRbvnPk_9IUoXSmrhZ-qg,919
+keras/src/layers/locally_connected/__pycache__/__init__.cpython-310.pyc,,
+keras/src/layers/locally_connected/__pycache__/locally_connected1d.cpython-310.pyc,,
+keras/src/layers/locally_connected/__pycache__/locally_connected2d.cpython-310.pyc,,
+keras/src/layers/locally_connected/__pycache__/locally_connected_utils.cpython-310.pyc,,
+keras/src/layers/locally_connected/locally_connected1d.py,sha256=JzhdU2_2tWDJ4KfGo8Og4bGmSGY9VZ12NF9_Nku3PUE,15006
+keras/src/layers/locally_connected/locally_connected2d.py,sha256=w6PApLbUrteZv0WxNy91Dp2OL2irhbUze3EkCe9m9zA,16627
+keras/src/layers/locally_connected/locally_connected_utils.py,sha256=IEcVqdhsAYGI45xBNS4cIV23ys7HX64xOv4ogXP0Hq4,8483
+keras/src/layers/merging/__init__.py,sha256=gYZSQUAlVZ5uzBwtwdGqHo8CHfSdQUB6_V5i_UXj3q8,1599
+keras/src/layers/merging/__pycache__/__init__.cpython-310.pyc,,
+keras/src/layers/merging/__pycache__/add.cpython-310.pyc,,
+keras/src/layers/merging/__pycache__/average.cpython-310.pyc,,
+keras/src/layers/merging/__pycache__/base_merge.cpython-310.pyc,,
+keras/src/layers/merging/__pycache__/concatenate.cpython-310.pyc,,
+keras/src/layers/merging/__pycache__/dot.cpython-310.pyc,,
+keras/src/layers/merging/__pycache__/maximum.cpython-310.pyc,,
+keras/src/layers/merging/__pycache__/minimum.cpython-310.pyc,,
+keras/src/layers/merging/__pycache__/multiply.cpython-310.pyc,,
+keras/src/layers/merging/__pycache__/subtract.cpython-310.pyc,,
+keras/src/layers/merging/add.py,sha256=KqAFdR69RnrGzg0hhbLbRRmhVNaDIJYtCPSw80KNp14,3003
+keras/src/layers/merging/average.py,sha256=CNk0rp0gndADwjG14yoIYWdtT2KE7FE_kfDYr2f7qZY,3137
+keras/src/layers/merging/base_merge.py,sha256=JEAtJOBMzwhY51-ni_8hTOhRkeBUJl0M9RSqpHsJgB8,9797
+keras/src/layers/merging/concatenate.py,sha256=KmqXaKD8fJPPai1f1aeTKdFpsdlxDYajaTRfqJgT6fA,8600
+keras/src/layers/merging/dot.py,sha256=09Q1bGZCSAKr2JX3An2ZblC2LS_ZgC1VaKn6shbqmsI,8313
+keras/src/layers/merging/maximum.py,sha256=Aphr5hkNEeSX2ygjF_AKY3-aZu-jGgHfx1LjLheVd_I,2902
+keras/src/layers/merging/minimum.py,sha256=PmXo5IBbvdMCbYKTRnLf8GrHVnFpxBptqW61vM68FEc,2209
+keras/src/layers/merging/multiply.py,sha256=wpLTGiMe0mvjXHZYrMy19QE8J5i-scoDYAYkfTXDvtY,2865
+keras/src/layers/merging/subtract.py,sha256=0ti8REI-tNWkas3yG15eXq0Q-Dhe-fVYvS4p_TKLLOY,3113
+keras/src/layers/noise.py,sha256=IX_pIQaxgECUaJYfxbtCCYNAQfy1VLWBZdVX3J9MD-U,1123
+keras/src/layers/normalization/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+keras/src/layers/normalization/__pycache__/__init__.cpython-310.pyc,,
+keras/src/layers/normalization/__pycache__/batch_normalization.cpython-310.pyc,,
+keras/src/layers/normalization/__pycache__/batch_normalization_v1.cpython-310.pyc,,
+keras/src/layers/normalization/__pycache__/group_normalization.cpython-310.pyc,,
+keras/src/layers/normalization/__pycache__/layer_normalization.cpython-310.pyc,,
+keras/src/layers/normalization/__pycache__/spectral_normalization.cpython-310.pyc,,
+keras/src/layers/normalization/__pycache__/unit_normalization.cpython-310.pyc,,
+keras/src/layers/normalization/batch_normalization.py,sha256=db-y0XCLYr316tZA70XbXqZexNd1HkP5N6U50GYv_w0,68288
+keras/src/layers/normalization/batch_normalization_v1.py,sha256=2SnIbMm47O3Nhb3jgXZ-DVBOQjifFfBPj1j-ArnMne8,1188
+keras/src/layers/normalization/group_normalization.py,sha256=qYN-lAdIowIwJDYuRGH19eifJCBnejMUL4rMoKD5bRE,10004
+keras/src/layers/normalization/layer_normalization.py,sha256=HJ07KNTWCl2ASiIYp-I3RaXB2tZcefJvgUU1gKmneuk,13995
+keras/src/layers/normalization/spectral_normalization.py,sha256=6Ob_q5a4FxnPOXvsL7vkoOyXkt0mg6kJVwsytmP5US0,4975
+keras/src/layers/normalization/unit_normalization.py,sha256=-TseAIEDFzqqOcb1RL-hWGQm7-DYZY4DrkCaev-XWFY,2605
+keras/src/layers/pooling/__init__.py,sha256=AUoPVRNiKm_3Pwd2pYP3dCwFMhlW4USiUCsYt9EryzA,2491
+keras/src/layers/pooling/__pycache__/__init__.cpython-310.pyc,,
+keras/src/layers/pooling/__pycache__/average_pooling1d.cpython-310.pyc,,
+keras/src/layers/pooling/__pycache__/average_pooling2d.cpython-310.pyc,,
+keras/src/layers/pooling/__pycache__/average_pooling3d.cpython-310.pyc,,
+keras/src/layers/pooling/__pycache__/base_global_pooling1d.cpython-310.pyc,,
+keras/src/layers/pooling/__pycache__/base_global_pooling2d.cpython-310.pyc,,
+keras/src/layers/pooling/__pycache__/base_global_pooling3d.cpython-310.pyc,,
+keras/src/layers/pooling/__pycache__/base_pooling1d.cpython-310.pyc,,
+keras/src/layers/pooling/__pycache__/base_pooling2d.cpython-310.pyc,,
+keras/src/layers/pooling/__pycache__/base_pooling3d.cpython-310.pyc,,
+keras/src/layers/pooling/__pycache__/global_average_pooling1d.cpython-310.pyc,,
+keras/src/layers/pooling/__pycache__/global_average_pooling2d.cpython-310.pyc,,
+keras/src/layers/pooling/__pycache__/global_average_pooling3d.cpython-310.pyc,,
+keras/src/layers/pooling/__pycache__/global_max_pooling1d.cpython-310.pyc,,
+keras/src/layers/pooling/__pycache__/global_max_pooling2d.cpython-310.pyc,,
+keras/src/layers/pooling/__pycache__/global_max_pooling3d.cpython-310.pyc,,
+keras/src/layers/pooling/__pycache__/max_pooling1d.cpython-310.pyc,,
+keras/src/layers/pooling/__pycache__/max_pooling2d.cpython-310.pyc,,
+keras/src/layers/pooling/__pycache__/max_pooling3d.cpython-310.pyc,,
+keras/src/layers/pooling/average_pooling1d.py,sha256=UFpBdYxSJzgA4sHZxPF7ypN1KkEvyuowlRXN7upeSYM,4992
+keras/src/layers/pooling/average_pooling2d.py,sha256=QADMQtm0vPfT_2hFPD-975tnYF-kRKYH_crb-jEYgoM,5478
+keras/src/layers/pooling/average_pooling3d.py,sha256=DQYo3NRA1lXP0XlpRlW9W_F5hsmn1GSW-cOBmXAaIBw,3803
+keras/src/layers/pooling/base_global_pooling1d.py,sha256=6k4vO8UoA68RfdGGQaMDsUj-p4w0n1lRdm88R_jV0D8,2703
+keras/src/layers/pooling/base_global_pooling2d.py,sha256=KfocdFF1qD9cHPisGVqA_Yca9sTdol1Mfhv-beb37zM,2703
+keras/src/layers/pooling/base_global_pooling3d.py,sha256=pwhFZUTvu4QNYzG8IiR3mOb2BsRl767un7dxpXXEiJ4,2715
+keras/src/layers/pooling/base_pooling1d.py,sha256=3ecT9Ercah55awiOERWlWS-atVR_wg_1I4wczanRV00,4110
+keras/src/layers/pooling/base_pooling2d.py,sha256=6RQ-6WOt0IDgtH8fQexu9zHE3oRFx7tBvtQ1wRcYxBI,4602
+keras/src/layers/pooling/base_pooling3d.py,sha256=beQr_hXx-67VSwk29TmsvPWelA0kcSgNkbMmTZjzYo4,5161
+keras/src/layers/pooling/global_average_pooling1d.py,sha256=gx3zMaWM2HU8mGa67mZs0j3vrhvQN5MQ15jXpTjRtcQ,3680
+keras/src/layers/pooling/global_average_pooling2d.py,sha256=SO3g2sQLKHVCwaaUjfM0GBEj3EiHmuIC4Ey-bPV59i8,3111
+keras/src/layers/pooling/global_average_pooling3d.py,sha256=q0z8itu0aHlBzp3YY_EKCWTLkFCCCv6_uiOvB1_Zbjw,3042
+keras/src/layers/pooling/global_max_pooling1d.py,sha256=fa2Rj8aqBHPv5_Tt9S6N0-65qUYhJMmtr1J2xWz_YGM,3191
+keras/src/layers/pooling/global_max_pooling2d.py,sha256=3F8BAZLd8iaKriuo6GDCKt1ESW_tQQuap8L_Hbh9Fj8,3054
+keras/src/layers/pooling/global_max_pooling3d.py,sha256=FxCEBQvJUYGXqsVAr9KQbdk_qDGUUoPT2Cn1Prwmuwk,3012
+keras/src/layers/pooling/max_pooling1d.py,sha256=EgORIyFp0stf0UR8m9PlS_XMYkVqGSR2-9Dsm2FgCdI,4446
+keras/src/layers/pooling/max_pooling2d.py,sha256=iFhRTM_NdEL4hyBeXzboC4UgwSYJPXZTF5krg3oX958,6332
+keras/src/layers/pooling/max_pooling3d.py,sha256=frUJTomOZ0ovLVvoylWiNfP0LY-IaZu7JKhDVJ6eMmw,3780
+keras/src/layers/preprocessing/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+keras/src/layers/preprocessing/__pycache__/__init__.cpython-310.pyc,,
+keras/src/layers/preprocessing/__pycache__/category_encoding.cpython-310.pyc,,
+keras/src/layers/preprocessing/__pycache__/discretization.cpython-310.pyc,,
+keras/src/layers/preprocessing/__pycache__/hashed_crossing.cpython-310.pyc,,
+keras/src/layers/preprocessing/__pycache__/hashing.cpython-310.pyc,,
+keras/src/layers/preprocessing/__pycache__/image_preprocessing.cpython-310.pyc,,
+keras/src/layers/preprocessing/__pycache__/index_lookup.cpython-310.pyc,,
+keras/src/layers/preprocessing/__pycache__/integer_lookup.cpython-310.pyc,,
+keras/src/layers/preprocessing/__pycache__/normalization.cpython-310.pyc,,
+keras/src/layers/preprocessing/__pycache__/preprocessing_stage.cpython-310.pyc,,
+keras/src/layers/preprocessing/__pycache__/preprocessing_test_utils.cpython-310.pyc,,
+keras/src/layers/preprocessing/__pycache__/preprocessing_utils.cpython-310.pyc,,
+keras/src/layers/preprocessing/__pycache__/string_lookup.cpython-310.pyc,,
+keras/src/layers/preprocessing/__pycache__/text_vectorization.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+keras/src/layers/preprocessing/benchmarks/__pycache__/__init__.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/bucketized_column_dense_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/category_encoding_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/category_hash_dense_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/category_hash_varlen_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/category_vocab_file_dense_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/category_vocab_file_varlen_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/category_vocab_list_dense_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/category_vocab_list_indicator_dense_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/category_vocab_list_indicator_varlen_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/category_vocab_list_varlen_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/discretization_adapt_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/embedding_dense_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/embedding_varlen_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/feature_column_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/hashed_crossing_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/hashing_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/image_preproc_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/index_lookup_adapt_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/index_lookup_forward_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/normalization_adapt_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/__pycache__/weighted_embedding_varlen_benchmark.cpython-310.pyc,,
+keras/src/layers/preprocessing/benchmarks/bucketized_column_dense_benchmark.py,sha256=KTI2iH4BGg2vXpD8Zy8DY02No4e0nGqfpJt09pm6yDE,2833
+keras/src/layers/preprocessing/benchmarks/category_encoding_benchmark.py,sha256=Hh6ZG20gCQAWdUdRauIuZUAgNwo37mDkWAHQ426ooEo,2940
+keras/src/layers/preprocessing/benchmarks/category_hash_dense_benchmark.py,sha256=k8U_Ok4IpKBsw0STQdk674IBs1KyUTQpjqrWZyg6onQ,2797
+keras/src/layers/preprocessing/benchmarks/category_hash_varlen_benchmark.py,sha256=O1OJuUKppSH2oe-pSoYoyEt7iw3bIFK-oSmJp5RyUg8,2711
+keras/src/layers/preprocessing/benchmarks/category_vocab_file_dense_benchmark.py,sha256=fCvnkO4YqGfroFSbYnUkXOcgLZ8TYU-TmMhQT-Ubhbk,3576
+keras/src/layers/preprocessing/benchmarks/category_vocab_file_varlen_benchmark.py,sha256=NdRjuVZCtUmS_0uckcIcvLDWT6JUvzLFukIM96bGEj4,3425
+keras/src/layers/preprocessing/benchmarks/category_vocab_list_dense_benchmark.py,sha256=sBzBBRH0uyRTUJZJ11vF7eiPoG1FS2KdHHfF9xP2fvI,2851
+keras/src/layers/preprocessing/benchmarks/category_vocab_list_indicator_dense_benchmark.py,sha256=NCJQf599vD4lupVwJR6IUdaKYC_vsgiLwMF3ZpcJfbw,3154
+keras/src/layers/preprocessing/benchmarks/category_vocab_list_indicator_varlen_benchmark.py,sha256=_rpWA1c0iOwRKBX3kidEMOjiO0HjPViZtrJ4htylC_M,3086
+keras/src/layers/preprocessing/benchmarks/category_vocab_list_varlen_benchmark.py,sha256=_hHKG4ptVmbm6z20NBkXjqfJYpOLlbQfJXjCeidfklo,2783
+keras/src/layers/preprocessing/benchmarks/discretization_adapt_benchmark.py,sha256=KOuSz_bazwPCGhmlcHh_fpnV19EPvWdc7HjxETPjBoc,3767
+keras/src/layers/preprocessing/benchmarks/embedding_dense_benchmark.py,sha256=Gh5x8ryp3uZl7zrkigSluIwlDAOwRdwzNzgINb3hPyk,2827
+keras/src/layers/preprocessing/benchmarks/embedding_varlen_benchmark.py,sha256=cwFp_511VPMEq3Dfg88Svvi5IGsXXT0eeEd0aHPxuoI,2822
+keras/src/layers/preprocessing/benchmarks/feature_column_benchmark.py,sha256=ZgOGMLDnjCPhHNZP0LNcidY-F3hJuWmHGZh3ynpI-dk,4805
+keras/src/layers/preprocessing/benchmarks/hashed_crossing_benchmark.py,sha256=PAhgNbbJsA75FYPAbperH9LuK_KxucvVKHCbivxgDZk,2823
+keras/src/layers/preprocessing/benchmarks/hashing_benchmark.py,sha256=1a5vHVl9Q4stUoCJHamnYkGbwrgdnD0GU_1LbZkWWJg,3615
+keras/src/layers/preprocessing/benchmarks/image_preproc_benchmark.py,sha256=ZfySXTJNUv6sJ45KeVmC0wzEic-PU6CkBEUTgruQ4xU,5458
+keras/src/layers/preprocessing/benchmarks/index_lookup_adapt_benchmark.py,sha256=kGVDAzeD7BReWzyvHFLGLQ96A0Uitf9KNpumcpFOsR0,4465
+keras/src/layers/preprocessing/benchmarks/index_lookup_forward_benchmark.py,sha256=zjDiPMMCRwFYxrPeO63XpiGnTNW6K3leN47WHk5l3zY,4931
+keras/src/layers/preprocessing/benchmarks/normalization_adapt_benchmark.py,sha256=fWVU9Kxdj8NaQcTRaUP0zDiDRcksQO2VW47lx3qTJNA,4410
+keras/src/layers/preprocessing/benchmarks/weighted_embedding_varlen_benchmark.py,sha256=irpCGaeWgLcLFbpxdOnp3cO9Iv5Ojgm8hr8_nf8ht4Q,3315
+keras/src/layers/preprocessing/category_encoding.py,sha256=gFO4PgvqaqW5eF54AOk_P9BYeygbbgoFzTHybzK98eY,9256
+keras/src/layers/preprocessing/discretization.py,sha256=2pgapRKDOwKob5wgSg47w-J53QVIMN37cY_AzuzwnPw,17891
+keras/src/layers/preprocessing/hashed_crossing.py,sha256=AagERShhksZDBoV6Rp01k9Hz4svqbQ33CPxQdVjz35M,8767
+keras/src/layers/preprocessing/hashing.py,sha256=v9eS6-B81vhMl72Wo708RK36UQsma3U7djXzWoISrAM,11522
+keras/src/layers/preprocessing/image_preprocessing.py,sha256=84jyQ6P_dzd7sGuiSN26agcooYZUdhgj8AIJbfN2swY,68978
+keras/src/layers/preprocessing/index_lookup.py,sha256=0YNCxRI8_SGei1Ymf1mVnB20dVhdk7H5fWFVS8xVOs0,42556
+keras/src/layers/preprocessing/integer_lookup.py,sha256=-_wIlPdG2BdeEKx5_vUiyr_V8Xf4RQ6zDoE39qUHgkM,21163
+keras/src/layers/preprocessing/normalization.py,sha256=7h0uLcwKsGGfqLplIst7ZAWZV3pNUlE3r0ZQ_NwA2GA,16782
+keras/src/layers/preprocessing/preprocessing_stage.py,sha256=X8Cseu1jDqU_kVCs6FZobaaYnc61IdcHmkLVODclbyo,11351
+keras/src/layers/preprocessing/preprocessing_test_utils.py,sha256=a7ejjaVZ339A9BNttqD9pu6j91blfu1o0a48MwbSztE,7185
+keras/src/layers/preprocessing/preprocessing_utils.py,sha256=WaZYO_XgjwI0Em7W8T5SDQ4IMMydSFdHHVeqBilHKMM,5307
+keras/src/layers/preprocessing/string_lookup.py,sha256=DxZFdK0W8Ub5gwmpNjMscRccoc1lp6wvdcuRTBL9mus,19336
+keras/src/layers/preprocessing/text_vectorization.py,sha256=WCn4DCmjzMsLTi5199Mh1h9XG-VJ0B3VlAeJw6IubWQ,30552
+keras/src/layers/regularization/__init__.py,sha256=5xqoxh8Th9chpj_5gs_8IM6y_veMP20nxOCCkb72qpo,1345
+keras/src/layers/regularization/__pycache__/__init__.cpython-310.pyc,,
+keras/src/layers/regularization/__pycache__/activity_regularization.cpython-310.pyc,,
+keras/src/layers/regularization/__pycache__/alpha_dropout.cpython-310.pyc,,
+keras/src/layers/regularization/__pycache__/dropout.cpython-310.pyc,,
+keras/src/layers/regularization/__pycache__/gaussian_dropout.cpython-310.pyc,,
+keras/src/layers/regularization/__pycache__/gaussian_noise.cpython-310.pyc,,
+keras/src/layers/regularization/__pycache__/spatial_dropout1d.cpython-310.pyc,,
+keras/src/layers/regularization/__pycache__/spatial_dropout2d.cpython-310.pyc,,
+keras/src/layers/regularization/__pycache__/spatial_dropout3d.cpython-310.pyc,,
+keras/src/layers/regularization/activity_regularization.py,sha256=YbxEIFRFHp-Ovfznme-2sFCd-kY-1hwtIoi-FjoV4hg,1936
+keras/src/layers/regularization/alpha_dropout.py,sha256=AWEnQOkUyuHgZg1_rwLpWJMhjUVID51RtIxYLhJy3-s,3791
+keras/src/layers/regularization/dropout.py,sha256=IdeyCJ5C0bseNQAVHPbutEuA-fdKoRpPXq8NfPzpooc,5010
+keras/src/layers/regularization/gaussian_dropout.py,sha256=WSO9Y7mipy8-6q6rx8J9hzEea7IfP4ZK82qX5k5TTGM,2897
+keras/src/layers/regularization/gaussian_noise.py,sha256=HVmxOzwwUgDh7A7eLTrSTuj79DbpYF7ds11h-eUvkeI,2846
+keras/src/layers/regularization/spatial_dropout1d.py,sha256=yFDmfsXO5HzhBJ4-sUCGlwAztvGmjH0IEA3egJhBX7M,2396
+keras/src/layers/regularization/spatial_dropout2d.py,sha256=Kusj9MHxgNFuGqpmp3gXTE3MUdLsU0fy7G7IedqdMjM,3473
+keras/src/layers/regularization/spatial_dropout3d.py,sha256=jYsWIZUTw5CpsvYCm6SKJ1t-CHPHdAd8PaofBATfVI0,3491
+keras/src/layers/reshaping/__init__.py,sha256=20Qy0mmGY6qMmzagf-IlXWgT3l_ozscCJju0f9LFqes,1544
+keras/src/layers/reshaping/__pycache__/__init__.cpython-310.pyc,,
+keras/src/layers/reshaping/__pycache__/cropping1d.cpython-310.pyc,,
+keras/src/layers/reshaping/__pycache__/cropping2d.cpython-310.pyc,,
+keras/src/layers/reshaping/__pycache__/cropping3d.cpython-310.pyc,,
+keras/src/layers/reshaping/__pycache__/flatten.cpython-310.pyc,,
+keras/src/layers/reshaping/__pycache__/permute.cpython-310.pyc,,
+keras/src/layers/reshaping/__pycache__/repeat_vector.cpython-310.pyc,,
+keras/src/layers/reshaping/__pycache__/reshape.cpython-310.pyc,,
+keras/src/layers/reshaping/__pycache__/up_sampling1d.cpython-310.pyc,,
+keras/src/layers/reshaping/__pycache__/up_sampling2d.cpython-310.pyc,,
+keras/src/layers/reshaping/__pycache__/up_sampling3d.cpython-310.pyc,,
+keras/src/layers/reshaping/__pycache__/zero_padding1d.cpython-310.pyc,,
+keras/src/layers/reshaping/__pycache__/zero_padding2d.cpython-310.pyc,,
+keras/src/layers/reshaping/__pycache__/zero_padding3d.cpython-310.pyc,,
+keras/src/layers/reshaping/cropping1d.py,sha256=bijHIzcbrh8YYERUoeGPw2K5D_1y1IjvaUg2jZWK79I,3269
+keras/src/layers/reshaping/cropping2d.py,sha256=4CpCPh6MAFX8BEuKNq56bis_lCWLqy2el7QJ85g8v1k,8404
+keras/src/layers/reshaping/cropping3d.py,sha256=f3UQGwYv2QO7PE5GYgdAEzlJN5GcTv28nWcaN1d7B18,11934
+keras/src/layers/reshaping/flatten.py,sha256=2x31Dj1Feqz_dt9D2Cq5m5vavtIzPbSK7mMS2a-Lk-4,4555
+keras/src/layers/reshaping/permute.py,sha256=rFOjBKj7sobVC_I7GK8GBE2RNGXj-jORusp2NOaoJGA,2952
+keras/src/layers/reshaping/repeat_vector.py,sha256=PvZDRnPTg0aUU3MrOVExFqWjI0M5Y7Aa38yNYszXMbI,2233
+keras/src/layers/reshaping/reshape.py,sha256=UiD_13VqIUsAhxQR_yfIOL4nT3uZtn8j27Cbiq9EZnw,5406
+keras/src/layers/reshaping/up_sampling1d.py,sha256=Kr9tloueXbFxmcJ9jKxY7VBjKAfbwH7mWk21rbEMzUU,2579
+keras/src/layers/reshaping/up_sampling2d.py,sha256=A0rBhnpGqpt9yPxkKlJAJxjM9duMwYevrl2Jcp5hoVc,5037
+keras/src/layers/reshaping/up_sampling3d.py,sha256=VrFHw132iFxPx8aJPaPJlBcJpo3pNNmyMYgXRbFVvs0,4712
+keras/src/layers/reshaping/zero_padding1d.py,sha256=M10noa1O2eHkE6EzwmZyWDDoyWWPgQO8tvyuc9-OqMI,3028
+keras/src/layers/reshaping/zero_padding2d.py,sha256=y1TcCHOO-8GWIVmi5HFLhlrkbG1NdCrGWa1sBgAWdiE,5934
+keras/src/layers/reshaping/zero_padding3d.py,sha256=nPMerhuKmjPKMkX7TCzljnCE9MmttEyMerR4QiakUZE,6654
+keras/src/layers/rnn/__init__.py,sha256=-uUgz6rxTRdBqagRMvKVOkx-KezMViw4RbE3otx9SbA,2911
+keras/src/layers/rnn/__pycache__/__init__.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/abstract_rnn_cell.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/base_conv_lstm.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/base_conv_rnn.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/base_cudnn_rnn.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/base_rnn.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/base_wrapper.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/bidirectional.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/cell_wrappers.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/conv_lstm1d.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/conv_lstm2d.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/conv_lstm3d.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/cudnn_gru.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/cudnn_lstm.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/dropout_rnn_cell_mixin.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/gru.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/gru_lstm_utils.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/gru_v1.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/legacy_cell_wrappers.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/legacy_cells.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/lstm.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/lstm_v1.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/rnn_utils.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/simple_rnn.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/stacked_rnn_cells.cpython-310.pyc,,
+keras/src/layers/rnn/__pycache__/time_distributed.cpython-310.pyc,,
+keras/src/layers/rnn/abstract_rnn_cell.py,sha256=Ha6oZSSFoL6xwH5O82pnE2322N81kQzgBc2RGfHy6x0,4468
+keras/src/layers/rnn/base_conv_lstm.py,sha256=MJ9eJlLpGxnsZbXxOeZ2zH9BCMy2W2MFMnbSoD0oCjk,24975
+keras/src/layers/rnn/base_conv_rnn.py,sha256=8Kn1ubgGywjUMAKX0qR0MSShhr-GX6A-Ybf4nEz0m_4,18518
+keras/src/layers/rnn/base_cudnn_rnn.py,sha256=ColbbzC6PZcr4ONHQOPkoxBn4FNdklbtFQYV5zI0-IA,5403
+keras/src/layers/rnn/base_rnn.py,sha256=uJz4hfJAhGYS7C4jBWedqzSNx1A07MNv8KjE7RdMNho,41907
+keras/src/layers/rnn/base_wrapper.py,sha256=kSIGnQ5M2ADQdkeV75ATKF2rO1iKhTuBqFd7f1wRvfs,3135
+keras/src/layers/rnn/bidirectional.py,sha256=jiIlOjf5zgattZM83F061pn0v1AnSH5fxNO12rN_6tE,22544
+keras/src/layers/rnn/cell_wrappers.py,sha256=lo0UGA7ZnOB-Uphy_NAPGuULFZuqGSMh9x4rW2QS9K0,26821
+keras/src/layers/rnn/conv_lstm1d.py,sha256=oDLCN7qGEzitswJGe1tTIBkHtWKa6O_YHT1Ylk9joo8,8755
+keras/src/layers/rnn/conv_lstm2d.py,sha256=aAGTkpTlBOuhTcBX3TroGZTJIhfb3FWd_Ru-95c_KrE,8868
+keras/src/layers/rnn/conv_lstm3d.py,sha256=Pqb6DHso1WNVOYJ1tqpHfxMP2UmakUeCNXQHT8tLdP8,8963
+keras/src/layers/rnn/cudnn_gru.py,sha256=pvrHfwfqdxLtpQp41DkYiILA-0-7zOpy3XwxQMVJX0I,8610
+keras/src/layers/rnn/cudnn_lstm.py,sha256=vvD4q7Ca_VYvis3qwZMeEWaHCdT_KwKM7Fx_n3Aml44,10099
+keras/src/layers/rnn/dropout_rnn_cell_mixin.py,sha256=VaAmWBHppnJb9DFZvK7SAMjkiInW8_XPMnFZxXjI510,7607
+keras/src/layers/rnn/gru.py,sha256=K367B7-uFutyNTNbdM2pxRAsNAa-s7U3PEa0WAhpQTU,50693
+keras/src/layers/rnn/gru_lstm_utils.py,sha256=oRhtgOZxmM31Qthrt9G5ipQbq-x6_lO98w_46GY4Mdk,9910
+keras/src/layers/rnn/gru_v1.py,sha256=NfCmkFXJUVe4CwE9nfV-P51v5XVsRvz0KFgQPOo2vyQ,15737
+keras/src/layers/rnn/legacy_cell_wrappers.py,sha256=TISldyHOjf9NPOwiB8U0mKAm3tYXGpSCWoy4lcRPtCk,25368
+keras/src/layers/rnn/legacy_cells.py,sha256=3ao-sYgHSNPPy08KpVR7ZgiyoKOMGrvDGEaA2PHHvhI,52814
+keras/src/layers/rnn/lstm.py,sha256=gzPf1buUEscvD-P-8nfdAm7RXy-bX6A4s0OMRfe26y0,53429
+keras/src/layers/rnn/lstm_v1.py,sha256=WCrum5Pq-zd7HbHnLJIBsgWEFOed2oYbjkIFTVOmVHU,15766
+keras/src/layers/rnn/rnn_utils.py,sha256=Jmh9j05lsPnu6nWNjcof70cT5gyA6ahyjua7gwLRCx4,8177
+keras/src/layers/rnn/simple_rnn.py,sha256=cY2M-4AjoqChGdaty2IIRFCXMcnfgIDASkWmtHL_feE,19890
+keras/src/layers/rnn/stacked_rnn_cells.py,sha256=xHSCHkkRosQfyi2vdG-l3pB4IMxmQlql0iM1s09dqEo,8287
+keras/src/layers/rnn/time_distributed.py,sha256=M5JnRvX6taE-Fhx1VOauLCG1S7e-516k8zWp91qRhcg,15552
+keras/src/layers/serialization.py,sha256=BOTxwTpU0n0FbZTamMojJ71Od-BAEndVcCpzznkiDpY,10090
+keras/src/legacy_tf_layers/__init__.py,sha256=6qI8UYYB9V-XQdwjBD6BRdR8nBGFzyI7ZMsq4cwjcTw,74
+keras/src/legacy_tf_layers/__pycache__/__init__.cpython-310.pyc,,
+keras/src/legacy_tf_layers/__pycache__/base.cpython-310.pyc,,
+keras/src/legacy_tf_layers/__pycache__/convolutional.cpython-310.pyc,,
+keras/src/legacy_tf_layers/__pycache__/core.cpython-310.pyc,,
+keras/src/legacy_tf_layers/__pycache__/migration_utils.cpython-310.pyc,,
+keras/src/legacy_tf_layers/__pycache__/normalization.cpython-310.pyc,,
+keras/src/legacy_tf_layers/__pycache__/pooling.cpython-310.pyc,,
+keras/src/legacy_tf_layers/__pycache__/variable_scope_shim.cpython-310.pyc,,
+keras/src/legacy_tf_layers/base.py,sha256=LbvGHvoxVla0MJPkh-feyY56iAW5oZ-HMtgplYMvBOQ,26508
+keras/src/legacy_tf_layers/convolutional.py,sha256=csaa01AVkoGtV47Cu2p3pXO00nD_u9IjpBEwIFOufBk,82988
+keras/src/legacy_tf_layers/core.py,sha256=GpFCX7ADwwZGW4_PCEiN3AHEpwIFQNGNCBb6uszPhFg,19160
+keras/src/legacy_tf_layers/migration_utils.py,sha256=c2x0DNPZs9sLd7CKVlLzRuJ4Xr6nxAHz1qobmcwaZsM,4626
+keras/src/legacy_tf_layers/normalization.py,sha256=4_2bVbb8rv_opOuwiraR-R8ii81406crjVlDwJDD25g,22249
+keras/src/legacy_tf_layers/pooling.py,sha256=3H0SD6H9xaeBW5PBuWmEQw3yygm0cprGHmeJFX64lug,31871
+keras/src/legacy_tf_layers/variable_scope_shim.py,sha256=OzgAeNRC9pTdxEKuOzfwG0ELAyUVTZxpbYnk_lxSrzk,45018
+keras/src/losses.py,sha256=8eEEK2r900XaO2a3F3wT_-3lXnaChHjC-UxNsQdmT9k,110662
+keras/src/metrics/__init__.py,sha256=AjRgt94Sd3IbCd77SpfqgQHB_cbhuS7d0Lh4RBhTBN0,9447
+keras/src/metrics/__pycache__/__init__.cpython-310.pyc,,
+keras/src/metrics/__pycache__/accuracy_metrics.cpython-310.pyc,,
+keras/src/metrics/__pycache__/base_metric.cpython-310.pyc,,
+keras/src/metrics/__pycache__/confusion_metrics.cpython-310.pyc,,
+keras/src/metrics/__pycache__/f_score_metrics.cpython-310.pyc,,
+keras/src/metrics/__pycache__/hinge_metrics.cpython-310.pyc,,
+keras/src/metrics/__pycache__/iou_metrics.cpython-310.pyc,,
+keras/src/metrics/__pycache__/probabilistic_metrics.cpython-310.pyc,,
+keras/src/metrics/__pycache__/py_metric.cpython-310.pyc,,
+keras/src/metrics/__pycache__/regression_metrics.cpython-310.pyc,,
+keras/src/metrics/accuracy_metrics.py,sha256=mcQZGF_Xs9kIV8MDgoK2p_ovdynbThv9wkd_Z-ZfrOc,17502
+keras/src/metrics/base_metric.py,sha256=HhzQ_DDAaNwjkS00xhMHngjs9dZTuI-f_J9KQLvhz-g,36582
+keras/src/metrics/confusion_metrics.py,sha256=VgEtaLSoinwnNhuOIgojiiceRKmgjzRBY3aoK79vM3k,65952
+keras/src/metrics/f_score_metrics.py,sha256=Kpwlr7wPnHMBad14RBwL5JXVGVqMhOGDxw7F5K1kOU8,11994
+keras/src/metrics/hinge_metrics.py,sha256=eSEIS5ynw8Ry1cEDcXUbl4hx3Kv7Pe1rFZAYMnFIzVY,4117
+keras/src/metrics/iou_metrics.py,sha256=8MPqNagoZgT7ht0zeZxXMTOWVPw_wLnV_sXH5_mI2bg,28522
+keras/src/metrics/probabilistic_metrics.py,sha256=1-S8mhj5-mnyp34ASN1IGyRcNwQpS6RnLFG6uR9rm3M,12111
+keras/src/metrics/py_metric.py,sha256=1dWnhOWTOBm6csY94RxMF9fjNlL6xX9CGYtuIaediRI,7230
+keras/src/metrics/regression_metrics.py,sha256=ycIIj3V5H3rvMuAnTEibrvgM8PlHr4aMrwKaShsRCMM,21065
+keras/src/mixed_precision/__init__.py,sha256=vO1qkFSlsZahkxO2LUBq9w48PqMpT1AKKnBqmSooWzc,1098
+keras/src/mixed_precision/__pycache__/__init__.cpython-310.pyc,,
+keras/src/mixed_precision/__pycache__/autocast_variable.cpython-310.pyc,,
+keras/src/mixed_precision/__pycache__/device_compatibility_check.cpython-310.pyc,,
+keras/src/mixed_precision/__pycache__/loss_scale_optimizer.cpython-310.pyc,,
+keras/src/mixed_precision/__pycache__/policy.cpython-310.pyc,,
+keras/src/mixed_precision/__pycache__/test_util.cpython-310.pyc,,
+keras/src/mixed_precision/autocast_variable.py,sha256=kc33iTlwvxo3qSHnFjlv-xS4PBwWhjiFS2nX82M18HA,21708
+keras/src/mixed_precision/device_compatibility_check.py,sha256=oSVZwizUlPMTnhJxr7zgWxX2v8jHOHhyZCwDCo8aYK0,6252
+keras/src/mixed_precision/loss_scale_optimizer.py,sha256=_Cx_h840pbPvzkCTB-0Qjg-JKOCIRn9lMr7WXJw3igU,64086
+keras/src/mixed_precision/policy.py,sha256=DWzRipnyn3bUqNsojScIucqf8uf_qGSAapuAbw6AKWs,22699
+keras/src/mixed_precision/test_util.py,sha256=1bpHVyOnr7NX2uIlp8p2_vBWrr_1m6mq9bjT15GoLh0,8511
+keras/src/models/__init__.py,sha256=8RYOdpsneVD0YhXRZxq2MYCU0YRcJEvk3G3Od0PEsiw,1766
+keras/src/models/__pycache__/__init__.cpython-310.pyc,,
+keras/src/models/__pycache__/cloning.cpython-310.pyc,,
+keras/src/models/__pycache__/sharpness_aware_minimization.cpython-310.pyc,,
+keras/src/models/cloning.py,sha256=eA0xqylS1ExDYZMfoqMTJP7NAz6aPWQjYFIqRC1PUKw,36770
+keras/src/models/sharpness_aware_minimization.py,sha256=Bl_ruu3oLDmQa4gLkTigrnlClT9yG0OFh_p0CuhmjWs,7286
+keras/src/optimizers/__init__.py,sha256=W57xU2UoVLIEGWJXzKrNbtzC9KhTeooKFCh-bIlUqI8,12812
+keras/src/optimizers/__pycache__/__init__.cpython-310.pyc,,
+keras/src/optimizers/__pycache__/adadelta.cpython-310.pyc,,
+keras/src/optimizers/__pycache__/adafactor.cpython-310.pyc,,
+keras/src/optimizers/__pycache__/adagrad.cpython-310.pyc,,
+keras/src/optimizers/__pycache__/adam.cpython-310.pyc,,
+keras/src/optimizers/__pycache__/adamax.cpython-310.pyc,,
+keras/src/optimizers/__pycache__/adamw.cpython-310.pyc,,
+keras/src/optimizers/__pycache__/ftrl.cpython-310.pyc,,
+keras/src/optimizers/__pycache__/legacy_learning_rate_decay.cpython-310.pyc,,
+keras/src/optimizers/__pycache__/lion.cpython-310.pyc,,
+keras/src/optimizers/__pycache__/nadam.cpython-310.pyc,,
+keras/src/optimizers/__pycache__/optimizer.cpython-310.pyc,,
+keras/src/optimizers/__pycache__/optimizer_v1.cpython-310.pyc,,
+keras/src/optimizers/__pycache__/rmsprop.cpython-310.pyc,,
+keras/src/optimizers/__pycache__/sgd.cpython-310.pyc,,
+keras/src/optimizers/__pycache__/utils.cpython-310.pyc,,
+keras/src/optimizers/adadelta.py,sha256=UU-J38bxLdXHzeqObzWTWTUQwCfTIyMsgNcpg8BVd9I,6165
+keras/src/optimizers/adafactor.py,sha256=gQPx99btwLwNAVfJFWBTVfNiQhfmFxMzvb00NRiSOxk,8642
+keras/src/optimizers/adagrad.py,sha256=ffGyBTN0m2ZUcgEfPVxqo-Sv_aGpSDAXTs280aBo7yM,5378
+keras/src/optimizers/adam.py,sha256=Orm06pXiOVEhzgH8ns8UPucR5MX7ZH-yO_JBUxpj3Uo,8708
+keras/src/optimizers/adamax.py,sha256=eWLbZ8wfJ2Cfrbo6Gcwc7_FDKCUiO11ut5TuvW3eGWc,6607
+keras/src/optimizers/adamw.py,sha256=OUUdoALb7zDq9MddQx5fUYXf5afiK2Azew7BPzSneFA,8855
+keras/src/optimizers/ftrl.py,sha256=IwxpD3wBs5bWar_yqn9UDnhgw1Jg-z1cuVuI0sLXk2k,9798
+keras/src/optimizers/legacy/__init__.py,sha256=yrmnTOUMQ09fOgD3PD4NjpaeKz2OXCUmmoExRWhg9AY,690
+keras/src/optimizers/legacy/__pycache__/__init__.cpython-310.pyc,,
+keras/src/optimizers/legacy/__pycache__/adadelta.cpython-310.pyc,,
+keras/src/optimizers/legacy/__pycache__/adagrad.cpython-310.pyc,,
+keras/src/optimizers/legacy/__pycache__/adam.cpython-310.pyc,,
+keras/src/optimizers/legacy/__pycache__/adamax.cpython-310.pyc,,
+keras/src/optimizers/legacy/__pycache__/ftrl.cpython-310.pyc,,
+keras/src/optimizers/legacy/__pycache__/gradient_descent.cpython-310.pyc,,
+keras/src/optimizers/legacy/__pycache__/nadam.cpython-310.pyc,,
+keras/src/optimizers/legacy/__pycache__/optimizer_v2.cpython-310.pyc,,
+keras/src/optimizers/legacy/__pycache__/rmsprop.cpython-310.pyc,,
+keras/src/optimizers/legacy/adadelta.py,sha256=tbIYa9LwzmrarTwlPXd2G4pTb8Ye2udOpY0GrKAi92E,6576
+keras/src/optimizers/legacy/adagrad.py,sha256=6Eze0p_RlhIVWbryhY2jUOKYfKy9uglLhtlP6Od5Fpg,7180
+keras/src/optimizers/legacy/adam.py,sha256=2irCPFG6g7KEJC5f5ipzg4OxP_955pmnue2uCaIo0wY,22172
+keras/src/optimizers/legacy/adamax.py,sha256=7iAPfZrDd5pDlHKI84Kcz7Kz_J1se8PCcD2OBgeTXeM,8117
+keras/src/optimizers/legacy/ftrl.py,sha256=qtW4cQDuRCsG82ABhjiYhzVmLVFOAazGp6wON-c2ZNI,12638
+keras/src/optimizers/legacy/gradient_descent.py,sha256=N6_aekCdWO1VjzEsPxTJ7IxGVX780rcHg0ilaJkj0p0,7962
+keras/src/optimizers/legacy/nadam.py,sha256=sZwadDq_kyWQCcB493vwg3GeAUDfC4fEMf8j6adEsgU,9989
+keras/src/optimizers/legacy/optimizer_v2.py,sha256=jossdlvWPtAL2jCzHRrw3xjJ9hNxQ_S_FPnKmQdMZ9s,68778
+keras/src/optimizers/legacy/rmsprop.py,sha256=3APMjbWe9ISJ5h0W8zJJEWBuIIoG9jdy7zJOhRH6FWc,14723
+keras/src/optimizers/legacy_learning_rate_decay.py,sha256=cOirECSQ1n6mVJWaFS0iFup0YVXfcy7ao1LTm36ihXI,30048
+keras/src/optimizers/lion.py,sha256=L3GPM06rWHQp9H6ZL22Lp2pVmTS8FGOQGdsMrdAH2lk,6151
+keras/src/optimizers/nadam.py,sha256=0jguh8_UnbSHrZ-ZoDe0oP76EwdEAskF6GqSrW6tqRE,7446
+keras/src/optimizers/optimizer.py,sha256=L72n9XdLCo_upXpu00BMZUCqzaBlnxVpm7p6-3zYgpI,55940
+keras/src/optimizers/optimizer_v1.py,sha256=1ZyAAGIm9H6aC-tvY2o2f6BkF04e0fUlWljk_w7nUs4,32624
+keras/src/optimizers/rmsprop.py,sha256=zKGILNXs4iEyKWsxBM_U8pkzsh9vZKOjLAtgX57zrRI,7884
+keras/src/optimizers/schedules/__init__.py,sha256=OH7o8VF1RKdlTIw6XqxZD5J80Ek-0O-X6VjsYNeF_wY,1071
+keras/src/optimizers/schedules/__pycache__/__init__.cpython-310.pyc,,
+keras/src/optimizers/schedules/__pycache__/learning_rate_schedule.cpython-310.pyc,,
+keras/src/optimizers/schedules/learning_rate_schedule.py,sha256=Pg1sJJGfsm_LCf6JGbMhvT4dzLWptfQxQx-OwmfX-Fo,48043
+keras/src/optimizers/sgd.py,sha256=NGT0PSYKhGOWYXX5riUaAC7M4Uv0QrEn2sqHtTDwzMw,6757
+keras/src/optimizers/utils.py,sha256=PINkIXKUKnQ06GKTzAu2gK8ZHmKh7quXjErC8XZJ7fk,6160
+keras/src/premade_models/__init__.py,sha256=xMI5M6pB21G8Xilvxi_Hev_WkV_M3XNe3aYLUJZXNfw,807
+keras/src/premade_models/__pycache__/__init__.cpython-310.pyc,,
+keras/src/premade_models/__pycache__/linear.cpython-310.pyc,,
+keras/src/premade_models/__pycache__/wide_deep.cpython-310.pyc,,
+keras/src/premade_models/linear.py,sha256=m6HyCZReKwFW8oMUOIYxBGKXKOXanq2Wwfm-Aj3BOGI,8088
+keras/src/premade_models/wide_deep.py,sha256=OteXAOrWugm5YI-_1t-bTT-Bk8wWNkGH495E-GiMnHU,9976
+keras/src/preprocessing/__init__.py,sha256=7Mycn8tCjKjW2mqsIgQb8gIeq1f_EzyO7lite7ERC8s,1699
+keras/src/preprocessing/__pycache__/__init__.cpython-310.pyc,,
+keras/src/preprocessing/__pycache__/image.cpython-310.pyc,,
+keras/src/preprocessing/__pycache__/sequence.cpython-310.pyc,,
+keras/src/preprocessing/__pycache__/text.cpython-310.pyc,,
+keras/src/preprocessing/image.py,sha256=3gVawEp5Qa6JMhlnogM0331CqHkplZb_i6EWZgKrtvA,104404
+keras/src/preprocessing/sequence.py,sha256=4F-Ai7-qtqfZgT9MUGaByxOsY1OGoj7Er67483SM88g,13883
+keras/src/preprocessing/text.py,sha256=09ev9YvGMYUBISsy1fnKc5ZbcaHxA813_ZqSL_0GGXY,22768
+keras/src/regularizers.py,sha256=AqrYnXxLQLpCulhzOnNghrEB2h8SJqcdOQA8HtI6eGs,16581
+keras/src/saving/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+keras/src/saving/__pycache__/__init__.cpython-310.pyc,,
+keras/src/saving/__pycache__/object_registration.cpython-310.pyc,,
+keras/src/saving/__pycache__/pickle_utils.cpython-310.pyc,,
+keras/src/saving/__pycache__/saving_api.cpython-310.pyc,,
+keras/src/saving/__pycache__/saving_lib.cpython-310.pyc,,
+keras/src/saving/__pycache__/serialization_lib.cpython-310.pyc,,
+keras/src/saving/legacy/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+keras/src/saving/legacy/__pycache__/__init__.cpython-310.pyc,,
+keras/src/saving/legacy/__pycache__/hdf5_format.cpython-310.pyc,,
+keras/src/saving/legacy/__pycache__/model_config.cpython-310.pyc,,
+keras/src/saving/legacy/__pycache__/save.cpython-310.pyc,,
+keras/src/saving/legacy/__pycache__/saving_utils.cpython-310.pyc,,
+keras/src/saving/legacy/__pycache__/serialization.cpython-310.pyc,,
+keras/src/saving/legacy/hdf5_format.py,sha256=DjzewsmtJI0oMjjaeajIS6ypHxfkGSE7JSYyaGXiCKQ,42366
+keras/src/saving/legacy/model_config.py,sha256=xY3CALY5j0NIV517K1FGThIcjroiXA9dUVbCi6IgZ2k,4119
+keras/src/saving/legacy/save.py,sha256=AaBL7NqJ8jw-_IejG4fdCcSOHdYETLDWCxvsRUYUCA4,23622
+keras/src/saving/legacy/saved_model/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+keras/src/saving/legacy/saved_model/__pycache__/__init__.cpython-310.pyc,,
+keras/src/saving/legacy/saved_model/__pycache__/base_serialization.cpython-310.pyc,,
+keras/src/saving/legacy/saved_model/__pycache__/constants.cpython-310.pyc,,
+keras/src/saving/legacy/saved_model/__pycache__/create_test_saved_model.cpython-310.pyc,,
+keras/src/saving/legacy/saved_model/__pycache__/json_utils.cpython-310.pyc,,
+keras/src/saving/legacy/saved_model/__pycache__/layer_serialization.cpython-310.pyc,,
+keras/src/saving/legacy/saved_model/__pycache__/load.cpython-310.pyc,,
+keras/src/saving/legacy/saved_model/__pycache__/load_context.cpython-310.pyc,,
+keras/src/saving/legacy/saved_model/__pycache__/metric_serialization.cpython-310.pyc,,
+keras/src/saving/legacy/saved_model/__pycache__/model_serialization.cpython-310.pyc,,
+keras/src/saving/legacy/saved_model/__pycache__/network_serialization.cpython-310.pyc,,
+keras/src/saving/legacy/saved_model/__pycache__/order_preserving_set.cpython-310.pyc,,
+keras/src/saving/legacy/saved_model/__pycache__/save.cpython-310.pyc,,
+keras/src/saving/legacy/saved_model/__pycache__/save_impl.cpython-310.pyc,,
+keras/src/saving/legacy/saved_model/__pycache__/serialized_attributes.cpython-310.pyc,,
+keras/src/saving/legacy/saved_model/__pycache__/utils.cpython-310.pyc,,
+keras/src/saving/legacy/saved_model/base_serialization.py,sha256=ct6RORs15aXRLW1PksqQu2b79UXXEzB7u6aTsP7TEkU,5087
+keras/src/saving/legacy/saved_model/constants.py,sha256=ZYC0TDNy8qMdSWlAshVroxd95xdmk7gPNvj4iwiNR4M,1770
+keras/src/saving/legacy/saved_model/create_test_saved_model.py,sha256=4bq2jpIGRRABsSnFANMxAbrT8vzk_3ZYHtfNo8mBmQ4,1034
+keras/src/saving/legacy/saved_model/json_utils.py,sha256=6N2j5HEs5g8djqZZA2j7rSM1zb-v6-SmCupkaCRrHWg,8032
+keras/src/saving/legacy/saved_model/layer_serialization.py,sha256=dbemgaJ3iKmAl8KZ94J26hdA0Wq7NcC8ho2PNEBzlUE,8401
+keras/src/saving/legacy/saved_model/load.py,sha256=KwhoTcbjiYiAW6PGv-aVvAWNEgDagguSX0VX9NAz6I0,56876
+keras/src/saving/legacy/saved_model/load_context.py,sha256=lKgTnYAJUBpDDGt6rQVUrr0Pif0ceu0jcXZPSN_R3y8,1936
+keras/src/saving/legacy/saved_model/metric_serialization.py,sha256=5-TsvsWXpND-CHJ5N8GJW-HiFK44Tso2jPBPDC3-iQU,1898
+keras/src/saving/legacy/saved_model/model_serialization.py,sha256=52OGGDb4c0yysotvkDZ3YfNyb6cCMVpprfwAHp8hlhI,2780
+keras/src/saving/legacy/saved_model/network_serialization.py,sha256=aY46fBw5byyILHDobFfBk8GBotpEq5iGvxbplrfoIUc,1174
+keras/src/saving/legacy/saved_model/order_preserving_set.py,sha256=zvNFzss8wSc0vngv74dNnQO_hxpxmEWWBBv1TTLsbPY,3250
+keras/src/saving/legacy/saved_model/save.py,sha256=ANPyFEBvpkCVEjHE6qgXgBWAZPVKrteEpgogx9eVffA,6350
+keras/src/saving/legacy/saved_model/save_impl.py,sha256=XTjLFuizV8lpD6zVLj2cLR-OOvnx9vKsegadjSjfT88,29661
+keras/src/saving/legacy/saved_model/serialized_attributes.py,sha256=TndAD4QRKh1mb9PO0Fyl8uc-StaOmvH0bzVI4o4pzvs,14958
+keras/src/saving/legacy/saved_model/utils.py,sha256=Fuk7uixbK2oXZrIpRKkCAlhLoXDG2IZ5ZZIQPt1fXHU,9929
+keras/src/saving/legacy/saving_utils.py,sha256=wf3Ar9Ljtmkak9DD-JQGkrNIGItb_5S0hN7hoq1y2P4,13675
+keras/src/saving/legacy/serialization.py,sha256=ctclqEAs4lREbY1MaKLN-Sb2tBWUJmW-wzO-d98n1fU,22193
+keras/src/saving/object_registration.py,sha256=JUZAyrnPS5zgTIjPTs92uzSE5Pgxu9KzrU4PML8M4eE,7789
+keras/src/saving/pickle_utils.py,sha256=KlyppLPrWb02-KICTWJwVytUla8EhEhsR50jsmmscVE,2593
+keras/src/saving/saving_api.py,sha256=pR7IbuCy-uR_X-3Atj4awSfUYL5ncnojAyO2KYVCJk0,13118
+keras/src/saving/saving_lib.py,sha256=NQNLA8ksZ7XZ9dSY8xc5fg4K3m40uI1GEeXGRo4Uo6U,25161
+keras/src/saving/serialization_lib.py,sha256=6YftNbQZLq4u7c7z4Pd53tJTY74xeSE1-qMYOpmucoc,30127
+keras/src/testing_infra/__init__.py,sha256=yrmnTOUMQ09fOgD3PD4NjpaeKz2OXCUmmoExRWhg9AY,690
+keras/src/testing_infra/__pycache__/__init__.cpython-310.pyc,,
+keras/src/testing_infra/__pycache__/keras_doctest_lib.cpython-310.pyc,,
+keras/src/testing_infra/__pycache__/test_combinations.cpython-310.pyc,,
+keras/src/testing_infra/__pycache__/test_utils.cpython-310.pyc,,
+keras/src/testing_infra/keras_doctest_lib.py,sha256=khaRb1jHs7fDRm18pLc7b9UrtjLJdzup3gJYEc2BQv4,8089
+keras/src/testing_infra/test_combinations.py,sha256=WLd2D9sjvAU1pKGayhVAruYjJjqZD1K4qHLcoxgpmcM,21668
+keras/src/testing_infra/test_utils.py,sha256=znnJZ0r2zxFF-oxfz5xosK0YxGCiJextfRE5gRf5e0E,40226
+keras/src/tests/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+keras/src/tests/__pycache__/__init__.cpython-310.pyc,,
+keras/src/tests/__pycache__/get_config_samples.cpython-310.pyc,,
+keras/src/tests/__pycache__/keras_doctest.cpython-310.pyc,,
+keras/src/tests/__pycache__/model_architectures.cpython-310.pyc,,
+keras/src/tests/__pycache__/model_subclassing_test_util.cpython-310.pyc,,
+keras/src/tests/get_config_samples.py,sha256=qz2SZb_JIW2NoTak9NphLJkDTgYmlQ5RNm64T9wQ6L8,15307
+keras/src/tests/keras_doctest.py,sha256=8Bh6yvOwC2-8375a-pO9Uxl-CcbPCzxzA8kRpLg_ibw,4635
+keras/src/tests/model_architectures.py,sha256=Srb0mUMWf3Tz92k8HpplYxkk9hA952cGoYuC3MoM3is,10827
+keras/src/tests/model_subclassing_test_util.py,sha256=asgHw2p6BgbDENwBlw4Y7NRy78jI8TXJmKNpGEhnUsI,5509
+keras/src/utils/__init__.py,sha256=e7ZWfoLnzUR_nt9t_XRptQpW0bxkSoW_cPYxy-q-4d8,3021
+keras/src/utils/__pycache__/__init__.cpython-310.pyc,,
+keras/src/utils/__pycache__/audio_dataset.cpython-310.pyc,,
+keras/src/utils/__pycache__/control_flow_util.cpython-310.pyc,,
+keras/src/utils/__pycache__/conv_utils.cpython-310.pyc,,
+keras/src/utils/__pycache__/data_utils.cpython-310.pyc,,
+keras/src/utils/__pycache__/dataset_creator.cpython-310.pyc,,
+keras/src/utils/__pycache__/dataset_utils.cpython-310.pyc,,
+keras/src/utils/__pycache__/feature_space.cpython-310.pyc,,
+keras/src/utils/__pycache__/generic_utils.cpython-310.pyc,,
+keras/src/utils/__pycache__/image_dataset.cpython-310.pyc,,
+keras/src/utils/__pycache__/image_utils.cpython-310.pyc,,
+keras/src/utils/__pycache__/io_utils.cpython-310.pyc,,
+keras/src/utils/__pycache__/keras_logging.cpython-310.pyc,,
+keras/src/utils/__pycache__/kernelized_utils.cpython-310.pyc,,
+keras/src/utils/__pycache__/kpl_test_utils.cpython-310.pyc,,
+keras/src/utils/__pycache__/layer_utils.cpython-310.pyc,,
+keras/src/utils/__pycache__/losses_utils.cpython-310.pyc,,
+keras/src/utils/__pycache__/metrics_utils.cpython-310.pyc,,
+keras/src/utils/__pycache__/mode_keys.cpython-310.pyc,,
+keras/src/utils/__pycache__/np_utils.cpython-310.pyc,,
+keras/src/utils/__pycache__/object_identity.cpython-310.pyc,,
+keras/src/utils/__pycache__/sidecar_evaluator.cpython-310.pyc,,
+keras/src/utils/__pycache__/steps_per_execution_tuning.cpython-310.pyc,,
+keras/src/utils/__pycache__/text_dataset.cpython-310.pyc,,
+keras/src/utils/__pycache__/tf_contextlib.cpython-310.pyc,,
+keras/src/utils/__pycache__/tf_inspect.cpython-310.pyc,,
+keras/src/utils/__pycache__/tf_utils.cpython-310.pyc,,
+keras/src/utils/__pycache__/timed_threads.cpython-310.pyc,,
+keras/src/utils/__pycache__/timeseries_dataset.cpython-310.pyc,,
+keras/src/utils/__pycache__/traceback_utils.cpython-310.pyc,,
+keras/src/utils/__pycache__/version_utils.cpython-310.pyc,,
+keras/src/utils/__pycache__/vis_utils.cpython-310.pyc,,
+keras/src/utils/audio_dataset.py,sha256=Sn6zeFTKPiombuBMWDzNEqZSKCuhKeSBmftUw4tci0M,14815
+keras/src/utils/control_flow_util.py,sha256=AOqalI3Xg0thK98jCxV_HkScHf4hIt_sAhOtSBknFhY,4418
+keras/src/utils/conv_utils.py,sha256=HMRViGmvCwP2ecBR3rNdKQ1aYVX0kyJJrEkHFU_UflU,20185
+keras/src/utils/data_utils.py,sha256=92QcfLQa1CmOLtRK53AZXlTDR3Y6hhDboK4KYmpebfY,38170
+keras/src/utils/dataset_creator.py,sha256=snbbdHRC6CLbaFb2TAPWJfPiHtJ2xyD4zYJsErsEfR0,4746
+keras/src/utils/dataset_utils.py,sha256=6n6jv7cDi2sB-6L6dbBXoP40bLrRPcJoBrBWp0WuM7k,28008
+keras/src/utils/feature_space.py,sha256=CDdrQ7bHqB0LGRHjbt21lCLmFylDYZBLGizrjPDGRKg,28829
+keras/src/utils/generic_utils.py,sha256=iE26K3C2VOCemsk_nSG-uuF-tVLUNqpzofqt_ZNHH1U,19508
+keras/src/utils/image_dataset.py,sha256=w61pbO-23TycY1247M1H-uTqjlwJh05oUzEtfWvwnzM,14786
+keras/src/utils/image_utils.py,sha256=sHOAXQlzjV0DvRjqhk1c8R4B_jk0HEmtLo5lCBWes88,17834
+keras/src/utils/io_utils.py,sha256=wCU7XNzEDDrcbfV2xF-CnHEVx8NpGtAevX92U-8tovo,4012
+keras/src/utils/keras_logging.py,sha256=Fv4eOMemx3Jg1hEdHIxx9GblG5YTnW1q1D1zLF3JxUE,882
+keras/src/utils/kernelized_utils.py,sha256=s475SAos2zHQ1NT9AHZmbWUSahHKOhdctP6uIou0nRo,4517
+keras/src/utils/kpl_test_utils.py,sha256=sulaKD44y-4ZDMLNOQWJWLBkXill69STpTvqzo910wk,7359
+keras/src/utils/layer_utils.py,sha256=LQh7pqWEcIej44rgmQaakBUHUqwDCyi2hCi2EMr7G1s,41720
+keras/src/utils/legacy/__init__.py,sha256=z2tA5qetfkqoF2Awi96KO0qngfcgdzS12sorj3Jg15A,914
+keras/src/utils/legacy/__pycache__/__init__.cpython-310.pyc,,
+keras/src/utils/losses_utils.py,sha256=PT6dWv83OzWvtiLXort5_Q9EIFGLtSDJ6fRVyyDBtFc,16908
+keras/src/utils/metrics_utils.py,sha256=eWxd7ylas-OJNaUH2QV6I3-h5NA-hD3yDLYoww71v_0,39786
+keras/src/utils/mode_keys.py,sha256=_QYq58qr_b-RhvMYBYnL47NkC0G1ng8NYcVnS_IYi-A,856
+keras/src/utils/np_utils.py,sha256=4EZ58G1zThQfQEmMNBPnUYRszXRJoY4foxYhOGfS89s,4805
+keras/src/utils/object_identity.py,sha256=XDpdFsyH_8UAcYpIBSUJY-JdBJ7FV9SnDmE3zoQfaGE,6880
+keras/src/utils/sidecar_evaluator.py,sha256=4w2JY7pWIkWqpzNIHfLj_kGUk2I9vcUPlBGIPS12WFQ,18450
+keras/src/utils/steps_per_execution_tuning.py,sha256=0h79y_uM943n7KG8Cwcwq4dPHh_Xxtic2SQDPSiNwAA,9583
+keras/src/utils/text_dataset.py,sha256=4U0NDIn_HxVDiuFMRlG0KLclLV7LlymejjzlyOUC1jc,11081
+keras/src/utils/tf_contextlib.py,sha256=ysTHicWjRBEVGNC6cKSCO7GTX1DxGNX9Z0vi4j9Q6Z8,1300
+keras/src/utils/tf_inspect.py,sha256=hRMwGwU15gqC8JPhFJemU6Aa5J99Z1gerHT9u93AkKI,14237
+keras/src/utils/tf_utils.py,sha256=0YOkPi8omItktCuh5KhuQGppZnntOaC7mjk_uQh284Y,24052
+keras/src/utils/timed_threads.py,sha256=lbWobYK2kVKSVkxpv9ccozUIYbOezp_SJV8-ViXpyw0,5380
+keras/src/utils/timeseries_dataset.py,sha256=Xss44PsdJ4DsgRix32uCTsiCZvXMlmp6miqcKaXRgSg,10612
+keras/src/utils/traceback_utils.py,sha256=_h-E1JQX-mo2LV2GsnuR4xVxKt9Lz_bDvjvkejntcLc,6332
+keras/src/utils/version_utils.py,sha256=m0_PfgLJr1qQkoZON5dUDdf9Eh-MNahw4oVOdnBk2jI,4883
+keras/src/utils/vis_utils.py,sha256=r6g0v6I-GGshlwuUMFn2dMiENktQqhybizeJ2QjzL6k,18858
+keras/utils/__init__.py,sha256=JPCf9_Ht8T_CNZp1t7x7IwfmTczjxrtbHnw3f4MVmIw,2606
+keras/utils/__pycache__/__init__.cpython-310.pyc,,
+keras/utils/experimental/__init__.py,sha256=JasEFRg4TAriH7JXRBGmbeKUybZTpmBCYC0QQjBpJ2g,94
+keras/utils/experimental/__pycache__/__init__.cpython-310.pyc,,
+keras/utils/legacy/__init__.py,sha256=Dh85b96gSEHf9pLzzI04XRcscIsKNfgAa1tXqSozUa8,183
+keras/utils/legacy/__pycache__/__init__.cpython-310.pyc,,
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/kiwisolver/__init__.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/kiwisolver/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d157f7eca64e74dca194148078c7b9594bad9bb0
--- /dev/null
+++ b/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",
+]
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/kiwisolver/__pycache__/__init__.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/kiwisolver/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4440395587b5cff139f8a0cb84278d061f01bca1
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/kiwisolver/__pycache__/__init__.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/kiwisolver/__pycache__/exceptions.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/kiwisolver/__pycache__/exceptions.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8102eec5d9d1fae335b5542466c731b48876b4a4
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/kiwisolver/__pycache__/exceptions.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/kiwisolver/_cext.pyi b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/kiwisolver/_cext.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..47290749fba1ccb3878b8fe9eac871096f9bc8e6
--- /dev/null
+++ b/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."""
+        ...
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/kiwisolver/exceptions.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/kiwisolver/exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd06f23f3a76dae34f03708a831b7f34ff175343
--- /dev/null
+++ b/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
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/requests_oauthlib/__pycache__/__init__.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/requests_oauthlib/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..63fa57598d8a0a0a80b50685f9047e9e2f543186
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/requests_oauthlib/__pycache__/__init__.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/requests_oauthlib/__pycache__/oauth1_auth.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/requests_oauthlib/__pycache__/oauth1_auth.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5dd9145906a8481bb9252b07e57ec0e86a1b78b1
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/requests_oauthlib/__pycache__/oauth1_auth.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/requests_oauthlib/__pycache__/oauth1_session.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/requests_oauthlib/__pycache__/oauth1_session.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f40398ff967da513345b34a9e9090ec465cb71cb
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/requests_oauthlib/__pycache__/oauth1_session.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/requests_oauthlib/__pycache__/oauth2_auth.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/requests_oauthlib/__pycache__/oauth2_auth.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d5d135a80f929daba0c51b5662f9e0a87b8adfbb
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/requests_oauthlib/__pycache__/oauth2_auth.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/requests_oauthlib/__pycache__/oauth2_session.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/requests_oauthlib/__pycache__/oauth2_session.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..668bd925fd98cafbc092f1fe6476492a98b9cc94
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/requests_oauthlib/__pycache__/oauth2_session.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__init__.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e7689072b2932cd57dd95a501cedca34cce39b0b
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__init__.py
@@ -0,0 +1,60 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  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
+#
+#      https://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.
+"""RSA module
+
+Module for calculating large primes, and RSA encryption, decryption, signing
+and verification. Includes generating public and private keys.
+
+WARNING: this implementation does not use compression of the cleartext input to
+prevent repetitions, or other common security improvements. Use with care.
+
+"""
+
+from rsa.key import newkeys, PrivateKey, PublicKey
+from rsa.pkcs1 import (
+    encrypt,
+    decrypt,
+    sign,
+    verify,
+    DecryptionError,
+    VerificationError,
+    find_signature_hash,
+    sign_hash,
+    compute_hash,
+)
+
+__author__ = "Sybren Stuvel, Barry Mead and Yesudeep Mangalapilly"
+__date__ = "2025-04-16"
+__version__ = "4.9.1"
+
+# Do doctest if we're run directly
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
+
+__all__ = [
+    "newkeys",
+    "encrypt",
+    "decrypt",
+    "sign",
+    "verify",
+    "PublicKey",
+    "PrivateKey",
+    "DecryptionError",
+    "VerificationError",
+    "find_signature_hash",
+    "compute_hash",
+    "sign_hash",
+]
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/__init__.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..94c025b83f9ae64b42bb6c86416eb21a5fa5f127
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/__init__.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/asn1.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/asn1.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b7bb504fd8f4f701187b4bae77eaff74b854403b
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/asn1.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/cli.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/cli.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bc796abc7cc6f059a28936c8330c2a8b6faf110a
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/cli.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/common.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/common.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..66f9c48ad11141f37984168d083eeb2dc32680e5
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/common.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/core.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/core.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7d23809847dfb047fba416f6ec1873d3db308e9c
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/core.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/key.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/key.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f0f177bd43a10300937bda2abc9b3f238fd61964
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/key.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/parallel.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/parallel.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..430ff5ff1432258c821658ee8ec35918370a8631
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/parallel.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/pkcs1_v2.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/pkcs1_v2.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ee56901bd9d6c908b72dc47d14af174b19f49198
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/pkcs1_v2.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/prime.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/prime.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..843c48375c2f99eb1391f1bf9059cdab746fff22
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/prime.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/randnum.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/randnum.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5b283ae41f0a3b5dc6cea9a5e6051d9509e5cb7d
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/randnum.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/transform.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/transform.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2cabb2a5ede0fd17675c66f5474659d055a54025
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/transform.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/util.cpython-310.pyc b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/util.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d15a3e6d35e3185c836569802980ab3af99f0dd2
Binary files /dev/null and b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/__pycache__/util.cpython-310.pyc differ
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/asn1.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/asn1.py
new file mode 100644
index 0000000000000000000000000000000000000000..4cc4dd35de5e346154c5c179eca716f3ffdbb315
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/asn1.py
@@ -0,0 +1,52 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  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
+#
+#      https://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.
+
+"""ASN.1 definitions.
+
+Not all ASN.1-handling code use these definitions, but when it does, they should be here.
+"""
+
+from pyasn1.type import univ, namedtype, tag
+
+
+class PubKeyHeader(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType("oid", univ.ObjectIdentifier()),
+        namedtype.NamedType("parameters", univ.Null()),
+    )
+
+
+class OpenSSLPubKey(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType("header", PubKeyHeader()),
+        # This little hack (the implicit tag) allows us to get a Bit String as Octet String
+        namedtype.NamedType(
+            "key",
+            univ.OctetString().subtype(implicitTag=tag.Tag(tagClass=0, tagFormat=0, tagId=3)),
+        ),
+    )
+
+
+class AsnPubKey(univ.Sequence):
+    """ASN.1 contents of DER encoded public key:
+
+    RSAPublicKey ::= SEQUENCE {
+         modulus           INTEGER,  -- n
+         publicExponent    INTEGER,  -- e
+    """
+
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType("modulus", univ.Integer()),
+        namedtype.NamedType("publicExponent", univ.Integer()),
+    )
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/common.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/common.py
new file mode 100644
index 0000000000000000000000000000000000000000..ca732e58190391ddfd33d02142ce599f5bce76df
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/common.py
@@ -0,0 +1,184 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  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
+#
+#      https://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.
+
+"""Common functionality shared by several modules."""
+
+import typing
+
+
+class NotRelativePrimeError(ValueError):
+    def __init__(self, a: int, b: int, d: int, msg: str = "") -> None:
+        super().__init__(msg or "%d and %d are not relatively prime, divider=%i" % (a, b, d))
+        self.a = a
+        self.b = b
+        self.d = d
+
+
+def bit_size(num: int) -> int:
+    """
+    Number of bits needed to represent a integer excluding any prefix
+    0 bits.
+
+    Usage::
+
+        >>> bit_size(1023)
+        10
+        >>> bit_size(1024)
+        11
+        >>> bit_size(1025)
+        11
+
+    :param num:
+        Integer value. If num is 0, returns 0. Only the absolute value of the
+        number is considered. Therefore, signed integers will be abs(num)
+        before the number's bit length is determined.
+    :returns:
+        Returns the number of bits in the integer.
+    """
+
+    try:
+        return num.bit_length()
+    except AttributeError as ex:
+        raise TypeError("bit_size(num) only supports integers, not %r" % type(num)) from ex
+
+
+def byte_size(number: int) -> int:
+    """
+    Returns the number of bytes required to hold a specific long number.
+
+    The number of bytes is rounded up.
+
+    Usage::
+
+        >>> byte_size(1 << 1023)
+        128
+        >>> byte_size((1 << 1024) - 1)
+        128
+        >>> byte_size(1 << 1024)
+        129
+
+    :param number:
+        An unsigned integer
+    :returns:
+        The number of bytes required to hold a specific long number.
+    """
+    if number == 0:
+        return 1
+    return ceil_div(bit_size(number), 8)
+
+
+def ceil_div(num: int, div: int) -> int:
+    """
+    Returns the ceiling function of a division between `num` and `div`.
+
+    Usage::
+
+        >>> ceil_div(100, 7)
+        15
+        >>> ceil_div(100, 10)
+        10
+        >>> ceil_div(1, 4)
+        1
+
+    :param num: Division's numerator, a number
+    :param div: Division's divisor, a number
+
+    :return: Rounded up result of the division between the parameters.
+    """
+    quanta, mod = divmod(num, div)
+    if mod:
+        quanta += 1
+    return quanta
+
+
+def extended_gcd(a: int, b: int) -> typing.Tuple[int, int, int]:
+    """Returns a tuple (r, i, j) such that r = gcd(a, b) = ia + jb"""
+    # r = gcd(a,b) i = multiplicitive inverse of a mod b
+    #      or      j = multiplicitive inverse of b mod a
+    # Neg return values for i or j are made positive mod b or a respectively
+    # Iterateive Version is faster and uses much less stack space
+    x = 0
+    y = 1
+    lx = 1
+    ly = 0
+    oa = a  # Remember original a/b to remove
+    ob = b  # negative values from return results
+    while b != 0:
+        q = a // b
+        (a, b) = (b, a % b)
+        (x, lx) = ((lx - (q * x)), x)
+        (y, ly) = ((ly - (q * y)), y)
+    if lx < 0:
+        lx += ob  # If neg wrap modulo original b
+    if ly < 0:
+        ly += oa  # If neg wrap modulo original a
+    return a, lx, ly  # Return only positive values
+
+
+def inverse(x: int, n: int) -> int:
+    """Returns the inverse of x % n under multiplication, a.k.a x^-1 (mod n)
+
+    >>> inverse(7, 4)
+    3
+    >>> (inverse(143, 4) * 143) % 4
+    1
+    """
+
+    (divider, inv, _) = extended_gcd(x, n)
+
+    if divider != 1:
+        raise NotRelativePrimeError(x, n, divider)
+
+    return inv
+
+
+def crt(a_values: typing.Iterable[int], modulo_values: typing.Iterable[int]) -> int:
+    """Chinese Remainder Theorem.
+
+    Calculates x such that x = a[i] (mod m[i]) for each i.
+
+    :param a_values: the a-values of the above equation
+    :param modulo_values: the m-values of the above equation
+    :returns: x such that x = a[i] (mod m[i]) for each i
+
+
+    >>> crt([2, 3], [3, 5])
+    8
+
+    >>> crt([2, 3, 2], [3, 5, 7])
+    23
+
+    >>> crt([2, 3, 0], [7, 11, 15])
+    135
+    """
+
+    m = 1
+    x = 0
+
+    for modulo in modulo_values:
+        m *= modulo
+
+    for (m_i, a_i) in zip(modulo_values, a_values):
+        M_i = m // m_i
+        inv = inverse(M_i, m_i)
+
+        x = (x + a_i * M_i * inv) % m
+
+    return x
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/core.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..84ed3f883f70a30829f32966051e4a9d22fbeb0a
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/core.py
@@ -0,0 +1,53 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  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
+#
+#      https://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.
+
+"""Core mathematical operations.
+
+This is the actual core RSA implementation, which is only defined
+mathematically on integers.
+"""
+
+
+def assert_int(var: int, name: str) -> None:
+    if isinstance(var, int):
+        return
+
+    raise TypeError("%s should be an integer, not %s" % (name, var.__class__))
+
+
+def encrypt_int(message: int, ekey: int, n: int) -> int:
+    """Encrypts a message using encryption key 'ekey', working modulo n"""
+
+    assert_int(message, "message")
+    assert_int(ekey, "ekey")
+    assert_int(n, "n")
+
+    if message < 0:
+        raise ValueError("Only non-negative numbers are supported")
+
+    if message > n:
+        raise OverflowError("The message %i is too long for n=%i" % (message, n))
+
+    return pow(message, ekey, n)
+
+
+def decrypt_int(cyphertext: int, dkey: int, n: int) -> int:
+    """Decrypts a cypher text using the decryption key 'dkey', working modulo n"""
+
+    assert_int(cyphertext, "cyphertext")
+    assert_int(dkey, "dkey")
+    assert_int(n, "n")
+
+    message = pow(cyphertext, dkey, n)
+    return message
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/key.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/key.py
new file mode 100644
index 0000000000000000000000000000000000000000..f80064430869d8fb937ec703582fe363d4289b77
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/key.py
@@ -0,0 +1,858 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  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
+#
+#      https://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.
+
+"""RSA key generation code.
+
+Create new keys with the newkeys() function. It will give you a PublicKey and a
+PrivateKey object.
+
+Loading and saving keys requires the pyasn1 module. This module is imported as
+late as possible, such that other functionality will remain working in absence
+of pyasn1.
+
+.. note::
+
+    Storing public and private keys via the `pickle` module is possible.
+    However, it is insecure to load a key from an untrusted source.
+    The pickle module is not secure against erroneous or maliciously
+    constructed data. Never unpickle data received from an untrusted
+    or unauthenticated source.
+
+"""
+
+import threading
+import typing
+import warnings
+
+import rsa.prime
+import rsa.pem
+import rsa.common
+import rsa.randnum
+import rsa.core
+
+
+DEFAULT_EXPONENT = 65537
+
+
+T = typing.TypeVar("T", bound="AbstractKey")
+
+
+class AbstractKey:
+    """Abstract superclass for private and public keys."""
+
+    __slots__ = ("n", "e", "blindfac", "blindfac_inverse", "mutex")
+
+    def __init__(self, n: int, e: int) -> None:
+        self.n = n
+        self.e = e
+
+        # These will be computed properly on the first call to blind().
+        self.blindfac = self.blindfac_inverse = -1
+
+        # Used to protect updates to the blinding factor in multi-threaded
+        # environments.
+        self.mutex = threading.Lock()
+
+    @classmethod
+    def _load_pkcs1_pem(cls: typing.Type[T], keyfile: bytes) -> T:
+        """Loads a key in PKCS#1 PEM format, implement in a subclass.
+
+        :param keyfile: contents of a PEM-encoded file that contains
+            the public key.
+        :type keyfile: bytes
+
+        :return: the loaded key
+        :rtype: AbstractKey
+        """
+
+    @classmethod
+    def _load_pkcs1_der(cls: typing.Type[T], keyfile: bytes) -> T:
+        """Loads a key in PKCS#1 PEM format, implement in a subclass.
+
+        :param keyfile: contents of a DER-encoded file that contains
+            the public key.
+        :type keyfile: bytes
+
+        :return: the loaded key
+        :rtype: AbstractKey
+        """
+
+    def _save_pkcs1_pem(self) -> bytes:
+        """Saves the key in PKCS#1 PEM format, implement in a subclass.
+
+        :returns: the PEM-encoded key.
+        :rtype: bytes
+        """
+
+    def _save_pkcs1_der(self) -> bytes:
+        """Saves the key in PKCS#1 DER format, implement in a subclass.
+
+        :returns: the DER-encoded key.
+        :rtype: bytes
+        """
+
+    @classmethod
+    def load_pkcs1(cls: typing.Type[T], keyfile: bytes, format: str = "PEM") -> T:
+        """Loads a key in PKCS#1 DER or PEM format.
+
+        :param keyfile: contents of a DER- or PEM-encoded file that contains
+            the key.
+        :type keyfile: bytes
+        :param format: the format of the file to load; 'PEM' or 'DER'
+        :type format: str
+
+        :return: the loaded key
+        :rtype: AbstractKey
+        """
+
+        methods = {
+            "PEM": cls._load_pkcs1_pem,
+            "DER": cls._load_pkcs1_der,
+        }
+
+        method = cls._assert_format_exists(format, methods)
+        return method(keyfile)
+
+    @staticmethod
+    def _assert_format_exists(
+        file_format: str, methods: typing.Mapping[str, typing.Callable]
+    ) -> typing.Callable:
+        """Checks whether the given file format exists in 'methods'."""
+
+        try:
+            return methods[file_format]
+        except KeyError as ex:
+            formats = ", ".join(sorted(methods.keys()))
+            raise ValueError(
+                "Unsupported format: %r, try one of %s" % (file_format, formats)
+            ) from ex
+
+    def save_pkcs1(self, format: str = "PEM") -> bytes:
+        """Saves the key in PKCS#1 DER or PEM format.
+
+        :param format: the format to save; 'PEM' or 'DER'
+        :type format: str
+        :returns: the DER- or PEM-encoded key.
+        :rtype: bytes
+        """
+
+        methods = {
+            "PEM": self._save_pkcs1_pem,
+            "DER": self._save_pkcs1_der,
+        }
+
+        method = self._assert_format_exists(format, methods)
+        return method()
+
+    def blind(self, message: int) -> typing.Tuple[int, int]:
+        """Performs blinding on the message.
+
+        :param message: the message, as integer, to blind.
+        :param r: the random number to blind with.
+        :return: tuple (the blinded message, the inverse of the used blinding factor)
+
+        The blinding is such that message = unblind(decrypt(blind(encrypt(message))).
+
+        See https://en.wikipedia.org/wiki/Blinding_%28cryptography%29
+        """
+        blindfac, blindfac_inverse = self._update_blinding_factor()
+        blinded = (message * pow(blindfac, self.e, self.n)) % self.n
+        return blinded, blindfac_inverse
+
+    def unblind(self, blinded: int, blindfac_inverse: int) -> int:
+        """Performs blinding on the message using random number 'blindfac_inverse'.
+
+        :param blinded: the blinded message, as integer, to unblind.
+        :param blindfac: the factor to unblind with.
+        :return: the original message.
+
+        The blinding is such that message = unblind(decrypt(blind(encrypt(message))).
+
+        See https://en.wikipedia.org/wiki/Blinding_%28cryptography%29
+        """
+        return (blindfac_inverse * blinded) % self.n
+
+    def _initial_blinding_factor(self) -> int:
+        for _ in range(1000):
+            blind_r = rsa.randnum.randint(self.n - 1)
+            if rsa.prime.are_relatively_prime(self.n, blind_r):
+                return blind_r
+        raise RuntimeError("unable to find blinding factor")
+
+    def _update_blinding_factor(self) -> typing.Tuple[int, int]:
+        """Update blinding factors.
+
+        Computing a blinding factor is expensive, so instead this function
+        does this once, then updates the blinding factor as per section 9
+        of 'A Timing Attack against RSA with the Chinese Remainder Theorem'
+        by Werner Schindler.
+        See https://tls.mbed.org/public/WSchindler-RSA_Timing_Attack.pdf
+
+        :return: the new blinding factor and its inverse.
+        """
+
+        with self.mutex:
+            if self.blindfac < 0:
+                # Compute initial blinding factor, which is rather slow to do.
+                self.blindfac = self._initial_blinding_factor()
+                self.blindfac_inverse = rsa.common.inverse(self.blindfac, self.n)
+            else:
+                # Reuse previous blinding factor.
+                self.blindfac = pow(self.blindfac, 2, self.n)
+                self.blindfac_inverse = pow(self.blindfac_inverse, 2, self.n)
+
+            return self.blindfac, self.blindfac_inverse
+
+
+class PublicKey(AbstractKey):
+    """Represents a public RSA key.
+
+    This key is also known as the 'encryption key'. It contains the 'n' and 'e'
+    values.
+
+    Supports attributes as well as dictionary-like access. Attribute access is
+    faster, though.
+
+    >>> PublicKey(5, 3)
+    PublicKey(5, 3)
+
+    >>> key = PublicKey(5, 3)
+    >>> key.n
+    5
+    >>> key['n']
+    5
+    >>> key.e
+    3
+    >>> key['e']
+    3
+
+    """
+
+    __slots__ = ()
+
+    def __getitem__(self, key: str) -> int:
+        return getattr(self, key)
+
+    def __repr__(self) -> str:
+        return "PublicKey(%i, %i)" % (self.n, self.e)
+
+    def __getstate__(self) -> typing.Tuple[int, int]:
+        """Returns the key as tuple for pickling."""
+        return self.n, self.e
+
+    def __setstate__(self, state: typing.Tuple[int, int]) -> None:
+        """Sets the key from tuple."""
+        self.n, self.e = state
+        AbstractKey.__init__(self, self.n, self.e)
+
+    def __eq__(self, other: typing.Any) -> bool:
+        if other is None:
+            return False
+
+        if not isinstance(other, PublicKey):
+            return False
+
+        return self.n == other.n and self.e == other.e
+
+    def __ne__(self, other: typing.Any) -> bool:
+        return not (self == other)
+
+    def __hash__(self) -> int:
+        return hash((self.n, self.e))
+
+    @classmethod
+    def _load_pkcs1_der(cls, keyfile: bytes) -> "PublicKey":
+        """Loads a key in PKCS#1 DER format.
+
+        :param keyfile: contents of a DER-encoded file that contains the public
+            key.
+        :return: a PublicKey object
+
+        First let's construct a DER encoded key:
+
+        >>> import base64
+        >>> b64der = 'MAwCBQCNGmYtAgMBAAE='
+        >>> der = base64.standard_b64decode(b64der)
+
+        This loads the file:
+
+        >>> PublicKey._load_pkcs1_der(der)
+        PublicKey(2367317549, 65537)
+
+        """
+
+        from pyasn1.codec.der import decoder
+        from rsa.asn1 import AsnPubKey
+
+        (priv, _) = decoder.decode(keyfile, asn1Spec=AsnPubKey())
+        return cls(n=int(priv["modulus"]), e=int(priv["publicExponent"]))
+
+    def _save_pkcs1_der(self) -> bytes:
+        """Saves the public key in PKCS#1 DER format.
+
+        :returns: the DER-encoded public key.
+        :rtype: bytes
+        """
+
+        from pyasn1.codec.der import encoder
+        from rsa.asn1 import AsnPubKey
+
+        # Create the ASN object
+        asn_key = AsnPubKey()
+        asn_key.setComponentByName("modulus", self.n)
+        asn_key.setComponentByName("publicExponent", self.e)
+
+        return encoder.encode(asn_key)
+
+    @classmethod
+    def _load_pkcs1_pem(cls, keyfile: bytes) -> "PublicKey":
+        """Loads a PKCS#1 PEM-encoded public key file.
+
+        The contents of the file before the "-----BEGIN RSA PUBLIC KEY-----" and
+        after the "-----END RSA PUBLIC KEY-----" lines is ignored.
+
+        :param keyfile: contents of a PEM-encoded file that contains the public
+            key.
+        :return: a PublicKey object
+        """
+
+        der = rsa.pem.load_pem(keyfile, "RSA PUBLIC KEY")
+        return cls._load_pkcs1_der(der)
+
+    def _save_pkcs1_pem(self) -> bytes:
+        """Saves a PKCS#1 PEM-encoded public key file.
+
+        :return: contents of a PEM-encoded file that contains the public key.
+        :rtype: bytes
+        """
+
+        der = self._save_pkcs1_der()
+        return rsa.pem.save_pem(der, "RSA PUBLIC KEY")
+
+    @classmethod
+    def load_pkcs1_openssl_pem(cls, keyfile: bytes) -> "PublicKey":
+        """Loads a PKCS#1.5 PEM-encoded public key file from OpenSSL.
+
+        These files can be recognised in that they start with BEGIN PUBLIC KEY
+        rather than BEGIN RSA PUBLIC KEY.
+
+        The contents of the file before the "-----BEGIN PUBLIC KEY-----" and
+        after the "-----END PUBLIC KEY-----" lines is ignored.
+
+        :param keyfile: contents of a PEM-encoded file that contains the public
+            key, from OpenSSL.
+        :type keyfile: bytes
+        :return: a PublicKey object
+        """
+
+        der = rsa.pem.load_pem(keyfile, "PUBLIC KEY")
+        return cls.load_pkcs1_openssl_der(der)
+
+    @classmethod
+    def load_pkcs1_openssl_der(cls, keyfile: bytes) -> "PublicKey":
+        """Loads a PKCS#1 DER-encoded public key file from OpenSSL.
+
+        :param keyfile: contents of a DER-encoded file that contains the public
+            key, from OpenSSL.
+        :return: a PublicKey object
+        """
+
+        from rsa.asn1 import OpenSSLPubKey
+        from pyasn1.codec.der import decoder
+        from pyasn1.type import univ
+
+        (keyinfo, _) = decoder.decode(keyfile, asn1Spec=OpenSSLPubKey())
+
+        if keyinfo["header"]["oid"] != univ.ObjectIdentifier("1.2.840.113549.1.1.1"):
+            raise TypeError("This is not a DER-encoded OpenSSL-compatible public key")
+
+        return cls._load_pkcs1_der(keyinfo["key"][1:])
+
+
+class PrivateKey(AbstractKey):
+    """Represents a private RSA key.
+
+    This key is also known as the 'decryption key'. It contains the 'n', 'e',
+    'd', 'p', 'q' and other values.
+
+    Supports attributes as well as dictionary-like access. Attribute access is
+    faster, though.
+
+    >>> PrivateKey(3247, 65537, 833, 191, 17)
+    PrivateKey(3247, 65537, 833, 191, 17)
+
+    exp1, exp2 and coef will be calculated:
+
+    >>> pk = PrivateKey(3727264081, 65537, 3349121513, 65063, 57287)
+    >>> pk.exp1
+    55063
+    >>> pk.exp2
+    10095
+    >>> pk.coef
+    50797
+
+    """
+
+    __slots__ = ("d", "p", "q", "exp1", "exp2", "coef")
+
+    def __init__(self, n: int, e: int, d: int, p: int, q: int) -> None:
+        AbstractKey.__init__(self, n, e)
+        self.d = d
+        self.p = p
+        self.q = q
+
+        # Calculate exponents and coefficient.
+        self.exp1 = int(d % (p - 1))
+        self.exp2 = int(d % (q - 1))
+        self.coef = rsa.common.inverse(q, p)
+
+    def __getitem__(self, key: str) -> int:
+        return getattr(self, key)
+
+    def __repr__(self) -> str:
+        return "PrivateKey(%i, %i, %i, %i, %i)" % (
+            self.n,
+            self.e,
+            self.d,
+            self.p,
+            self.q,
+        )
+
+    def __getstate__(self) -> typing.Tuple[int, int, int, int, int, int, int, int]:
+        """Returns the key as tuple for pickling."""
+        return self.n, self.e, self.d, self.p, self.q, self.exp1, self.exp2, self.coef
+
+    def __setstate__(self, state: typing.Tuple[int, int, int, int, int, int, int, int]) -> None:
+        """Sets the key from tuple."""
+        self.n, self.e, self.d, self.p, self.q, self.exp1, self.exp2, self.coef = state
+        AbstractKey.__init__(self, self.n, self.e)
+
+    def __eq__(self, other: typing.Any) -> bool:
+        if other is None:
+            return False
+
+        if not isinstance(other, PrivateKey):
+            return False
+
+        return (
+            self.n == other.n
+            and self.e == other.e
+            and self.d == other.d
+            and self.p == other.p
+            and self.q == other.q
+            and self.exp1 == other.exp1
+            and self.exp2 == other.exp2
+            and self.coef == other.coef
+        )
+
+    def __ne__(self, other: typing.Any) -> bool:
+        return not (self == other)
+
+    def __hash__(self) -> int:
+        return hash((self.n, self.e, self.d, self.p, self.q, self.exp1, self.exp2, self.coef))
+
+    def blinded_decrypt(self, encrypted: int) -> int:
+        """Decrypts the message using blinding to prevent side-channel attacks.
+
+        :param encrypted: the encrypted message
+        :type encrypted: int
+
+        :returns: the decrypted message
+        :rtype: int
+        """
+
+        # Blinding and un-blinding should be using the same factor
+        blinded, blindfac_inverse = self.blind(encrypted)
+
+        # Instead of using the core functionality, use the Chinese Remainder
+        # Theorem and be 2-4x faster. This the same as:
+        #
+        # decrypted = rsa.core.decrypt_int(blinded, self.d, self.n)
+        s1 = pow(blinded, self.exp1, self.p)
+        s2 = pow(blinded, self.exp2, self.q)
+        h = ((s1 - s2) * self.coef) % self.p
+        decrypted = s2 + self.q * h
+
+        return self.unblind(decrypted, blindfac_inverse)
+
+    def blinded_encrypt(self, message: int) -> int:
+        """Encrypts the message using blinding to prevent side-channel attacks.
+
+        :param message: the message to encrypt
+        :type message: int
+
+        :returns: the encrypted message
+        :rtype: int
+        """
+
+        blinded, blindfac_inverse = self.blind(message)
+        encrypted = rsa.core.encrypt_int(blinded, self.d, self.n)
+        return self.unblind(encrypted, blindfac_inverse)
+
+    @classmethod
+    def _load_pkcs1_der(cls, keyfile: bytes) -> "PrivateKey":
+        """Loads a key in PKCS#1 DER format.
+
+        :param keyfile: contents of a DER-encoded file that contains the private
+            key.
+        :type keyfile: bytes
+        :return: a PrivateKey object
+
+        First let's construct a DER encoded key:
+
+        >>> import base64
+        >>> b64der = 'MC4CAQACBQDeKYlRAgMBAAECBQDHn4npAgMA/icCAwDfxwIDANcXAgInbwIDAMZt'
+        >>> der = base64.standard_b64decode(b64der)
+
+        This loads the file:
+
+        >>> PrivateKey._load_pkcs1_der(der)
+        PrivateKey(3727264081, 65537, 3349121513, 65063, 57287)
+
+        """
+
+        from pyasn1.codec.der import decoder
+
+        (priv, _) = decoder.decode(keyfile)
+
+        # ASN.1 contents of DER encoded private key:
+        #
+        # RSAPrivateKey ::= SEQUENCE {
+        #     version           Version,
+        #     modulus           INTEGER,  -- n
+        #     publicExponent    INTEGER,  -- e
+        #     privateExponent   INTEGER,  -- d
+        #     prime1            INTEGER,  -- p
+        #     prime2            INTEGER,  -- q
+        #     exponent1         INTEGER,  -- d mod (p-1)
+        #     exponent2         INTEGER,  -- d mod (q-1)
+        #     coefficient       INTEGER,  -- (inverse of q) mod p
+        #     otherPrimeInfos   OtherPrimeInfos OPTIONAL
+        # }
+
+        if priv[0] != 0:
+            raise ValueError("Unable to read this file, version %s != 0" % priv[0])
+
+        as_ints = map(int, priv[1:6])
+        key = cls(*as_ints)
+
+        exp1, exp2, coef = map(int, priv[6:9])
+
+        if (key.exp1, key.exp2, key.coef) != (exp1, exp2, coef):
+            warnings.warn(
+                "You have provided a malformed keyfile. Either the exponents "
+                "or the coefficient are incorrect. Using the correct values "
+                "instead.",
+                UserWarning,
+            )
+
+        return key
+
+    def _save_pkcs1_der(self) -> bytes:
+        """Saves the private key in PKCS#1 DER format.
+
+        :returns: the DER-encoded private key.
+        :rtype: bytes
+        """
+
+        from pyasn1.type import univ, namedtype
+        from pyasn1.codec.der import encoder
+
+        class AsnPrivKey(univ.Sequence):
+            componentType = namedtype.NamedTypes(
+                namedtype.NamedType("version", univ.Integer()),
+                namedtype.NamedType("modulus", univ.Integer()),
+                namedtype.NamedType("publicExponent", univ.Integer()),
+                namedtype.NamedType("privateExponent", univ.Integer()),
+                namedtype.NamedType("prime1", univ.Integer()),
+                namedtype.NamedType("prime2", univ.Integer()),
+                namedtype.NamedType("exponent1", univ.Integer()),
+                namedtype.NamedType("exponent2", univ.Integer()),
+                namedtype.NamedType("coefficient", univ.Integer()),
+            )
+
+        # Create the ASN object
+        asn_key = AsnPrivKey()
+        asn_key.setComponentByName("version", 0)
+        asn_key.setComponentByName("modulus", self.n)
+        asn_key.setComponentByName("publicExponent", self.e)
+        asn_key.setComponentByName("privateExponent", self.d)
+        asn_key.setComponentByName("prime1", self.p)
+        asn_key.setComponentByName("prime2", self.q)
+        asn_key.setComponentByName("exponent1", self.exp1)
+        asn_key.setComponentByName("exponent2", self.exp2)
+        asn_key.setComponentByName("coefficient", self.coef)
+
+        return encoder.encode(asn_key)
+
+    @classmethod
+    def _load_pkcs1_pem(cls, keyfile: bytes) -> "PrivateKey":
+        """Loads a PKCS#1 PEM-encoded private key file.
+
+        The contents of the file before the "-----BEGIN RSA PRIVATE KEY-----" and
+        after the "-----END RSA PRIVATE KEY-----" lines is ignored.
+
+        :param keyfile: contents of a PEM-encoded file that contains the private
+            key.
+        :type keyfile: bytes
+        :return: a PrivateKey object
+        """
+
+        der = rsa.pem.load_pem(keyfile, b"RSA PRIVATE KEY")
+        return cls._load_pkcs1_der(der)
+
+    def _save_pkcs1_pem(self) -> bytes:
+        """Saves a PKCS#1 PEM-encoded private key file.
+
+        :return: contents of a PEM-encoded file that contains the private key.
+        :rtype: bytes
+        """
+
+        der = self._save_pkcs1_der()
+        return rsa.pem.save_pem(der, b"RSA PRIVATE KEY")
+
+
+def find_p_q(
+    nbits: int,
+    getprime_func: typing.Callable[[int], int] = rsa.prime.getprime,
+    accurate: bool = True,
+) -> typing.Tuple[int, int]:
+    """Returns a tuple of two different primes of nbits bits each.
+
+    The resulting p * q has exactly 2 * nbits bits, and the returned p and q
+    will not be equal.
+
+    :param nbits: the number of bits in each of p and q.
+    :param getprime_func: the getprime function, defaults to
+        :py:func:`rsa.prime.getprime`.
+
+        *Introduced in Python-RSA 3.1*
+
+    :param accurate: whether to enable accurate mode or not.
+    :returns: (p, q), where p > q
+
+    >>> (p, q) = find_p_q(128)
+    >>> from rsa import common
+    >>> common.bit_size(p * q)
+    256
+
+    When not in accurate mode, the number of bits can be slightly less
+
+    >>> (p, q) = find_p_q(128, accurate=False)
+    >>> from rsa import common
+    >>> common.bit_size(p * q) <= 256
+    True
+    >>> common.bit_size(p * q) > 240
+    True
+
+    """
+
+    total_bits = nbits * 2
+
+    # Make sure that p and q aren't too close or the factoring programs can
+    # factor n.
+    shift = nbits // 16
+    pbits = nbits + shift
+    qbits = nbits - shift
+
+    # Choose the two initial primes
+    p = getprime_func(pbits)
+    q = getprime_func(qbits)
+
+    def is_acceptable(p: int, q: int) -> bool:
+        """Returns True iff p and q are acceptable:
+
+        - p and q differ
+        - (p * q) has the right nr of bits (when accurate=True)
+        """
+
+        if p == q:
+            return False
+
+        if not accurate:
+            return True
+
+        # Make sure we have just the right amount of bits
+        found_size = rsa.common.bit_size(p * q)
+        return total_bits == found_size
+
+    # Keep choosing other primes until they match our requirements.
+    change_p = False
+    while not is_acceptable(p, q):
+        # Change p on one iteration and q on the other
+        if change_p:
+            p = getprime_func(pbits)
+        else:
+            q = getprime_func(qbits)
+
+        change_p = not change_p
+
+    # We want p > q as described on
+    # http://www.di-mgt.com.au/rsa_alg.html#crt
+    return max(p, q), min(p, q)
+
+
+def calculate_keys_custom_exponent(p: int, q: int, exponent: int) -> typing.Tuple[int, int]:
+    """Calculates an encryption and a decryption key given p, q and an exponent,
+    and returns them as a tuple (e, d)
+
+    :param p: the first large prime
+    :param q: the second large prime
+    :param exponent: the exponent for the key; only change this if you know
+        what you're doing, as the exponent influences how difficult your
+        private key can be cracked. A very common choice for e is 65537.
+    :type exponent: int
+
+    """
+
+    phi_n = (p - 1) * (q - 1)
+
+    try:
+        d = rsa.common.inverse(exponent, phi_n)
+    except rsa.common.NotRelativePrimeError as ex:
+        raise rsa.common.NotRelativePrimeError(
+            exponent,
+            phi_n,
+            ex.d,
+            msg="e (%d) and phi_n (%d) are not relatively prime (divider=%i)"
+            % (exponent, phi_n, ex.d),
+        ) from ex
+
+    if (exponent * d) % phi_n != 1:
+        raise ValueError(
+            "e (%d) and d (%d) are not mult. inv. modulo " "phi_n (%d)" % (exponent, d, phi_n)
+        )
+
+    return exponent, d
+
+
+def calculate_keys(p: int, q: int) -> typing.Tuple[int, int]:
+    """Calculates an encryption and a decryption key given p and q, and
+    returns them as a tuple (e, d)
+
+    :param p: the first large prime
+    :param q: the second large prime
+
+    :return: tuple (e, d) with the encryption and decryption exponents.
+    """
+
+    return calculate_keys_custom_exponent(p, q, DEFAULT_EXPONENT)
+
+
+def gen_keys(
+    nbits: int,
+    getprime_func: typing.Callable[[int], int],
+    accurate: bool = True,
+    exponent: int = DEFAULT_EXPONENT,
+) -> typing.Tuple[int, int, int, int]:
+    """Generate RSA keys of nbits bits. Returns (p, q, e, d).
+
+    Note: this can take a long time, depending on the key size.
+
+    :param nbits: the total number of bits in ``p`` and ``q``. Both ``p`` and
+        ``q`` will use ``nbits/2`` bits.
+    :param getprime_func: either :py:func:`rsa.prime.getprime` or a function
+        with similar signature.
+    :param exponent: the exponent for the key; only change this if you know
+        what you're doing, as the exponent influences how difficult your
+        private key can be cracked. A very common choice for e is 65537.
+    :type exponent: int
+    """
+
+    # Regenerate p and q values, until calculate_keys doesn't raise a
+    # ValueError.
+    while True:
+        (p, q) = find_p_q(nbits // 2, getprime_func, accurate)
+        try:
+            (e, d) = calculate_keys_custom_exponent(p, q, exponent=exponent)
+            break
+        except ValueError:
+            pass
+
+    return p, q, e, d
+
+
+def newkeys(
+    nbits: int,
+    accurate: bool = True,
+    poolsize: int = 1,
+    exponent: int = DEFAULT_EXPONENT,
+) -> typing.Tuple[PublicKey, PrivateKey]:
+    """Generates public and private keys, and returns them as (pub, priv).
+
+    The public key is also known as the 'encryption key', and is a
+    :py:class:`rsa.PublicKey` object. The private key is also known as the
+    'decryption key' and is a :py:class:`rsa.PrivateKey` object.
+
+    :param nbits: the number of bits required to store ``n = p*q``.
+    :param accurate: when True, ``n`` will have exactly the number of bits you
+        asked for. However, this makes key generation much slower. When False,
+        `n`` may have slightly less bits.
+    :param poolsize: the number of processes to use to generate the prime
+        numbers. If set to a number > 1, a parallel algorithm will be used.
+        This requires Python 2.6 or newer.
+    :param exponent: the exponent for the key; only change this if you know
+        what you're doing, as the exponent influences how difficult your
+        private key can be cracked. A very common choice for e is 65537.
+    :type exponent: int
+
+    :returns: a tuple (:py:class:`rsa.PublicKey`, :py:class:`rsa.PrivateKey`)
+
+    The ``poolsize`` parameter was added in *Python-RSA 3.1* and requires
+    Python 2.6 or newer.
+
+    """
+
+    if nbits < 16:
+        raise ValueError("Key too small")
+
+    if poolsize < 1:
+        raise ValueError("Pool size (%i) should be >= 1" % poolsize)
+
+    # Determine which getprime function to use
+    if poolsize > 1:
+        from rsa import parallel
+
+        def getprime_func(nbits: int) -> int:
+            return parallel.getprime(nbits, poolsize=poolsize)
+
+    else:
+        getprime_func = rsa.prime.getprime
+
+    # Generate the key components
+    (p, q, e, d) = gen_keys(nbits, getprime_func, accurate=accurate, exponent=exponent)
+
+    # Create the key objects
+    n = p * q
+
+    return (PublicKey(n, e), PrivateKey(n, e, d, p, q))
+
+
+__all__ = ["PublicKey", "PrivateKey", "newkeys"]
+
+if __name__ == "__main__":
+    import doctest
+
+    try:
+        for count in range(100):
+            (failures, tests) = doctest.testmod()
+            if failures:
+                break
+
+            if (count % 10 == 0 and count) or count == 1:
+                print("%i times" % count)
+    except KeyboardInterrupt:
+        print("Aborted")
+    else:
+        print("Doctests done")
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/pem.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/pem.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d26e6ed097055bd56e8619358996529e0a59cd8
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/pem.py
@@ -0,0 +1,134 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  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
+#
+#      https://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.
+
+"""Functions that load and write PEM-encoded files."""
+
+import base64
+import typing
+
+# Should either be ASCII strings or bytes.
+FlexiText = typing.Union[str, bytes]
+
+
+def _markers(pem_marker: FlexiText) -> typing.Tuple[bytes, bytes]:
+    """
+    Returns the start and end PEM markers, as bytes.
+    """
+
+    if not isinstance(pem_marker, bytes):
+        pem_marker = pem_marker.encode("ascii")
+
+    return (
+        b"-----BEGIN " + pem_marker + b"-----",
+        b"-----END " + pem_marker + b"-----",
+    )
+
+
+def _pem_lines(contents: bytes, pem_start: bytes, pem_end: bytes) -> typing.Iterator[bytes]:
+    """Generator over PEM lines between pem_start and pem_end."""
+
+    in_pem_part = False
+    seen_pem_start = False
+
+    for line in contents.splitlines():
+        line = line.strip()
+
+        # Skip empty lines
+        if not line:
+            continue
+
+        # Handle start marker
+        if line == pem_start:
+            if in_pem_part:
+                raise ValueError('Seen start marker "%r" twice' % pem_start)
+
+            in_pem_part = True
+            seen_pem_start = True
+            continue
+
+        # Skip stuff before first marker
+        if not in_pem_part:
+            continue
+
+        # Handle end marker
+        if in_pem_part and line == pem_end:
+            in_pem_part = False
+            break
+
+        # Load fields
+        if b":" in line:
+            continue
+
+        yield line
+
+    # Do some sanity checks
+    if not seen_pem_start:
+        raise ValueError('No PEM start marker "%r" found' % pem_start)
+
+    if in_pem_part:
+        raise ValueError('No PEM end marker "%r" found' % pem_end)
+
+
+def load_pem(contents: FlexiText, pem_marker: FlexiText) -> bytes:
+    """Loads a PEM file.
+
+    :param contents: the contents of the file to interpret
+    :param pem_marker: the marker of the PEM content, such as 'RSA PRIVATE KEY'
+        when your file has '-----BEGIN RSA PRIVATE KEY-----' and
+        '-----END RSA PRIVATE KEY-----' markers.
+
+    :return: the base64-decoded content between the start and end markers.
+
+    @raise ValueError: when the content is invalid, for example when the start
+        marker cannot be found.
+
+    """
+
+    # We want bytes, not text. If it's text, it can be converted to ASCII bytes.
+    if not isinstance(contents, bytes):
+        contents = contents.encode("ascii")
+
+    (pem_start, pem_end) = _markers(pem_marker)
+    pem_lines = [line for line in _pem_lines(contents, pem_start, pem_end)]
+
+    # Base64-decode the contents
+    pem = b"".join(pem_lines)
+    return base64.standard_b64decode(pem)
+
+
+def save_pem(contents: bytes, pem_marker: FlexiText) -> bytes:
+    """Saves a PEM file.
+
+    :param contents: the contents to encode in PEM format
+    :param pem_marker: the marker of the PEM content, such as 'RSA PRIVATE KEY'
+        when your file has '-----BEGIN RSA PRIVATE KEY-----' and
+        '-----END RSA PRIVATE KEY-----' markers.
+
+    :return: the base64-encoded content between the start and end markers, as bytes.
+
+    """
+
+    (pem_start, pem_end) = _markers(pem_marker)
+
+    b64 = base64.standard_b64encode(contents).replace(b"\n", b"")
+    pem_lines = [pem_start]
+
+    for block_start in range(0, len(b64), 64):
+        block = b64[block_start : block_start + 64]
+        pem_lines.append(block)
+
+    pem_lines.append(pem_end)
+    pem_lines.append(b"")
+
+    return b"\n".join(pem_lines)
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/pkcs1.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/pkcs1.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec6998e537a26161f70dfb2267747e45e7c9d9ea
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/pkcs1.py
@@ -0,0 +1,485 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  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
+#
+#      https://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.
+
+"""Functions for PKCS#1 version 1.5 encryption and signing
+
+This module implements certain functionality from PKCS#1 version 1.5. For a
+very clear example, read http://www.di-mgt.com.au/rsa_alg.html#pkcs1schemes
+
+At least 8 bytes of random padding is used when encrypting a message. This makes
+these methods much more secure than the ones in the ``rsa`` module.
+
+WARNING: this module leaks information when decryption fails. The exceptions
+that are raised contain the Python traceback information, which can be used to
+deduce where in the process the failure occurred. DO NOT PASS SUCH INFORMATION
+to your users.
+"""
+
+import hashlib
+import os
+import sys
+import typing
+from hmac import compare_digest
+
+from . import common, transform, core, key
+
+if typing.TYPE_CHECKING:
+    HashType = hashlib._Hash
+else:
+    HashType = typing.Any
+
+# ASN.1 codes that describe the hash algorithm used.
+HASH_ASN1 = {
+    "MD5": b"\x30\x20\x30\x0c\x06\x08\x2a\x86\x48\x86\xf7\x0d\x02\x05\x05\x00\x04\x10",
+    "SHA-1": b"\x30\x21\x30\x09\x06\x05\x2b\x0e\x03\x02\x1a\x05\x00\x04\x14",
+    "SHA-224": b"\x30\x2d\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x04\x05\x00\x04\x1c",
+    "SHA-256": b"\x30\x31\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x01\x05\x00\x04\x20",
+    "SHA-384": b"\x30\x41\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x02\x05\x00\x04\x30",
+    "SHA-512": b"\x30\x51\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x03\x05\x00\x04\x40",
+}
+
+HASH_METHODS: typing.Dict[str, typing.Callable[[], HashType]] = {
+    "MD5": hashlib.md5,
+    "SHA-1": hashlib.sha1,
+    "SHA-224": hashlib.sha224,
+    "SHA-256": hashlib.sha256,
+    "SHA-384": hashlib.sha384,
+    "SHA-512": hashlib.sha512,
+}
+"""Hash methods supported by this library."""
+
+
+if sys.version_info >= (3, 6):
+    # Python 3.6 introduced SHA3 support.
+    HASH_ASN1.update(
+        {
+            "SHA3-256": b"\x30\x31\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x08\x05\x00\x04\x20",
+            "SHA3-384": b"\x30\x41\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x09\x05\x00\x04\x30",
+            "SHA3-512": b"\x30\x51\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x0a\x05\x00\x04\x40",
+        }
+    )
+
+    HASH_METHODS.update(
+        {
+            "SHA3-256": hashlib.sha3_256,
+            "SHA3-384": hashlib.sha3_384,
+            "SHA3-512": hashlib.sha3_512,
+        }
+    )
+
+
+class CryptoError(Exception):
+    """Base class for all exceptions in this module."""
+
+
+class DecryptionError(CryptoError):
+    """Raised when decryption fails."""
+
+
+class VerificationError(CryptoError):
+    """Raised when verification fails."""
+
+
+def _pad_for_encryption(message: bytes, target_length: int) -> bytes:
+    r"""Pads the message for encryption, returning the padded message.
+
+    :return: 00 02 RANDOM_DATA 00 MESSAGE
+
+    >>> block = _pad_for_encryption(b'hello', 16)
+    >>> len(block)
+    16
+    >>> block[0:2]
+    b'\x00\x02'
+    >>> block[-6:]
+    b'\x00hello'
+
+    """
+
+    max_msglength = target_length - 11
+    msglength = len(message)
+
+    if msglength > max_msglength:
+        raise OverflowError(
+            "%i bytes needed for message, but there is only"
+            " space for %i" % (msglength, max_msglength)
+        )
+
+    # Get random padding
+    padding = b""
+    padding_length = target_length - msglength - 3
+
+    # We remove 0-bytes, so we'll end up with less padding than we've asked for,
+    # so keep adding data until we're at the correct length.
+    while len(padding) < padding_length:
+        needed_bytes = padding_length - len(padding)
+
+        # Always read at least 8 bytes more than we need, and trim off the rest
+        # after removing the 0-bytes. This increases the chance of getting
+        # enough bytes, especially when needed_bytes is small
+        new_padding = os.urandom(needed_bytes + 5)
+        new_padding = new_padding.replace(b"\x00", b"")
+        padding = padding + new_padding[:needed_bytes]
+
+    assert len(padding) == padding_length
+
+    return b"".join([b"\x00\x02", padding, b"\x00", message])
+
+
+def _pad_for_signing(message: bytes, target_length: int) -> bytes:
+    r"""Pads the message for signing, returning the padded message.
+
+    The padding is always a repetition of FF bytes.
+
+    :return: 00 01 PADDING 00 MESSAGE
+
+    >>> block = _pad_for_signing(b'hello', 16)
+    >>> len(block)
+    16
+    >>> block[0:2]
+    b'\x00\x01'
+    >>> block[-6:]
+    b'\x00hello'
+    >>> block[2:-6]
+    b'\xff\xff\xff\xff\xff\xff\xff\xff'
+
+    """
+
+    max_msglength = target_length - 11
+    msglength = len(message)
+
+    if msglength > max_msglength:
+        raise OverflowError(
+            "%i bytes needed for message, but there is only"
+            " space for %i" % (msglength, max_msglength)
+        )
+
+    padding_length = target_length - msglength - 3
+
+    return b"".join([b"\x00\x01", padding_length * b"\xff", b"\x00", message])
+
+
+def encrypt(message: bytes, pub_key: key.PublicKey) -> bytes:
+    """Encrypts the given message using PKCS#1 v1.5
+
+    :param message: the message to encrypt. Must be a byte string no longer than
+        ``k-11`` bytes, where ``k`` is the number of bytes needed to encode
+        the ``n`` component of the public key.
+    :param pub_key: the :py:class:`rsa.PublicKey` to encrypt with.
+    :raise OverflowError: when the message is too large to fit in the padded
+        block.
+
+    >>> from rsa import key, common
+    >>> (pub_key, priv_key) = key.newkeys(256)
+    >>> message = b'hello'
+    >>> crypto = encrypt(message, pub_key)
+
+    The crypto text should be just as long as the public key 'n' component:
+
+    >>> len(crypto) == common.byte_size(pub_key.n)
+    True
+
+    """
+
+    keylength = common.byte_size(pub_key.n)
+    padded = _pad_for_encryption(message, keylength)
+
+    payload = transform.bytes2int(padded)
+    encrypted = core.encrypt_int(payload, pub_key.e, pub_key.n)
+    block = transform.int2bytes(encrypted, keylength)
+
+    return block
+
+
+def decrypt(crypto: bytes, priv_key: key.PrivateKey) -> bytes:
+    r"""Decrypts the given message using PKCS#1 v1.5
+
+    The decryption is considered 'failed' when the resulting cleartext doesn't
+    start with the bytes 00 02, or when the 00 byte between the padding and
+    the message cannot be found.
+
+    :param crypto: the crypto text as returned by :py:func:`rsa.encrypt`
+    :param priv_key: the :py:class:`rsa.PrivateKey` to decrypt with.
+    :raise DecryptionError: when the decryption fails. No details are given as
+        to why the code thinks the decryption fails, as this would leak
+        information about the private key.
+
+
+    >>> import rsa
+    >>> (pub_key, priv_key) = rsa.newkeys(256)
+
+    It works with strings:
+
+    >>> crypto = encrypt(b'hello', pub_key)
+    >>> decrypt(crypto, priv_key)
+    b'hello'
+
+    And with binary data:
+
+    >>> crypto = encrypt(b'\x00\x00\x00\x00\x01', pub_key)
+    >>> decrypt(crypto, priv_key)
+    b'\x00\x00\x00\x00\x01'
+
+    Altering the encrypted information will *likely* cause a
+    :py:class:`rsa.pkcs1.DecryptionError`. If you want to be *sure*, use
+    :py:func:`rsa.sign`.
+
+
+    .. warning::
+
+        Never display the stack trace of a
+        :py:class:`rsa.pkcs1.DecryptionError` exception. It shows where in the
+        code the exception occurred, and thus leaks information about the key.
+        It's only a tiny bit of information, but every bit makes cracking the
+        keys easier.
+
+    >>> crypto = encrypt(b'hello', pub_key)
+    >>> crypto = crypto[0:5] + b'X' + crypto[6:] # change a byte
+    >>> decrypt(crypto, priv_key)
+    Traceback (most recent call last):
+    ...
+    rsa.pkcs1.DecryptionError: Decryption failed
+
+    """
+
+    blocksize = common.byte_size(priv_key.n)
+    encrypted = transform.bytes2int(crypto)
+    decrypted = priv_key.blinded_decrypt(encrypted)
+    cleartext = transform.int2bytes(decrypted, blocksize)
+
+    # Detect leading zeroes in the crypto. These are not reflected in the
+    # encrypted value (as leading zeroes do not influence the value of an
+    # integer). This fixes CVE-2020-13757.
+    if len(crypto) > blocksize:
+        # This is operating on public information, so doesn't need to be constant-time.
+        raise DecryptionError("Decryption failed")
+
+    # If we can't find the cleartext marker, decryption failed.
+    cleartext_marker_bad = not compare_digest(cleartext[:2], b"\x00\x02")
+
+    # Find the 00 separator between the padding and the message
+    sep_idx = cleartext.find(b"\x00", 2)
+
+    # sep_idx indicates the position of the `\x00` separator that separates the
+    # padding from the actual message. The padding should be at least 8 bytes
+    # long (see https://tools.ietf.org/html/rfc8017#section-7.2.2 step 3), which
+    # means the separator should be at least at index 10 (because of the
+    # `\x00\x02` marker that precedes it).
+    sep_idx_bad = sep_idx < 10
+
+    anything_bad = cleartext_marker_bad | sep_idx_bad
+    if anything_bad:
+        raise DecryptionError("Decryption failed")
+
+    return cleartext[sep_idx + 1 :]
+
+
+def sign_hash(hash_value: bytes, priv_key: key.PrivateKey, hash_method: str) -> bytes:
+    """Signs a precomputed hash with the private key.
+
+    Hashes the message, then signs the hash with the given key. This is known
+    as a "detached signature", because the message itself isn't altered.
+
+    :param hash_value: A precomputed hash to sign (ignores message).
+    :param priv_key: the :py:class:`rsa.PrivateKey` to sign with
+    :param hash_method: the hash method used on the message. Use 'MD5', 'SHA-1',
+        'SHA-224', SHA-256', 'SHA-384' or 'SHA-512'.
+    :return: a message signature block.
+    :raise OverflowError: if the private key is too small to contain the
+        requested hash.
+
+    """
+
+    # Get the ASN1 code for this hash method
+    if hash_method not in HASH_ASN1:
+        raise ValueError("Invalid hash method: %s" % hash_method)
+    asn1code = HASH_ASN1[hash_method]
+
+    # Encrypt the hash with the private key
+    cleartext = asn1code + hash_value
+    keylength = common.byte_size(priv_key.n)
+    padded = _pad_for_signing(cleartext, keylength)
+
+    payload = transform.bytes2int(padded)
+    encrypted = priv_key.blinded_encrypt(payload)
+    block = transform.int2bytes(encrypted, keylength)
+
+    return block
+
+
+def sign(message: bytes, priv_key: key.PrivateKey, hash_method: str) -> bytes:
+    """Signs the message with the private key.
+
+    Hashes the message, then signs the hash with the given key. This is known
+    as a "detached signature", because the message itself isn't altered.
+
+    :param message: the message to sign. Can be an 8-bit string or a file-like
+        object. If ``message`` has a ``read()`` method, it is assumed to be a
+        file-like object.
+    :param priv_key: the :py:class:`rsa.PrivateKey` to sign with
+    :param hash_method: the hash method used on the message. Use 'MD5', 'SHA-1',
+        'SHA-224', SHA-256', 'SHA-384' or 'SHA-512'.
+    :return: a message signature block.
+    :raise OverflowError: if the private key is too small to contain the
+        requested hash.
+
+    """
+
+    msg_hash = compute_hash(message, hash_method)
+    return sign_hash(msg_hash, priv_key, hash_method)
+
+
+def verify(message: bytes, signature: bytes, pub_key: key.PublicKey) -> str:
+    """Verifies that the signature matches the message.
+
+    The hash method is detected automatically from the signature.
+
+    :param message: the signed message. Can be an 8-bit string or a file-like
+        object. If ``message`` has a ``read()`` method, it is assumed to be a
+        file-like object.
+    :param signature: the signature block, as created with :py:func:`rsa.sign`.
+    :param pub_key: the :py:class:`rsa.PublicKey` of the person signing the message.
+    :raise VerificationError: when the signature doesn't match the message.
+    :returns: the name of the used hash.
+
+    """
+
+    keylength = common.byte_size(pub_key.n)
+    encrypted = transform.bytes2int(signature)
+    decrypted = core.decrypt_int(encrypted, pub_key.e, pub_key.n)
+    clearsig = transform.int2bytes(decrypted, keylength)
+
+    # Get the hash method
+    method_name = _find_method_hash(clearsig)
+    message_hash = compute_hash(message, method_name)
+
+    # Reconstruct the expected padded hash
+    cleartext = HASH_ASN1[method_name] + message_hash
+    expected = _pad_for_signing(cleartext, keylength)
+
+    if len(signature) != keylength:
+        raise VerificationError("Verification failed")
+
+    # Compare with the signed one
+    if expected != clearsig:
+        raise VerificationError("Verification failed")
+
+    return method_name
+
+
+def find_signature_hash(signature: bytes, pub_key: key.PublicKey) -> str:
+    """Returns the hash name detected from the signature.
+
+    If you also want to verify the message, use :py:func:`rsa.verify()` instead.
+    It also returns the name of the used hash.
+
+    :param signature: the signature block, as created with :py:func:`rsa.sign`.
+    :param pub_key: the :py:class:`rsa.PublicKey` of the person signing the message.
+    :returns: the name of the used hash.
+    """
+
+    keylength = common.byte_size(pub_key.n)
+    encrypted = transform.bytes2int(signature)
+    decrypted = core.decrypt_int(encrypted, pub_key.e, pub_key.n)
+    clearsig = transform.int2bytes(decrypted, keylength)
+
+    return _find_method_hash(clearsig)
+
+
+def yield_fixedblocks(infile: typing.BinaryIO, blocksize: int) -> typing.Iterator[bytes]:
+    """Generator, yields each block of ``blocksize`` bytes in the input file.
+
+    :param infile: file to read and separate in blocks.
+    :param blocksize: block size in bytes.
+    :returns: a generator that yields the contents of each block
+    """
+
+    while True:
+        block = infile.read(blocksize)
+
+        read_bytes = len(block)
+        if read_bytes == 0:
+            break
+
+        yield block
+
+        if read_bytes < blocksize:
+            break
+
+
+def compute_hash(message: typing.Union[bytes, typing.BinaryIO], method_name: str) -> bytes:
+    """Returns the message digest.
+
+    :param message: the signed message. Can be an 8-bit string or a file-like
+        object. If ``message`` has a ``read()`` method, it is assumed to be a
+        file-like object.
+    :param method_name: the hash method, must be a key of
+        :py:const:`rsa.pkcs1.HASH_METHODS`.
+
+    """
+
+    if method_name not in HASH_METHODS:
+        raise ValueError("Invalid hash method: %s" % method_name)
+
+    method = HASH_METHODS[method_name]
+    hasher = method()
+
+    if isinstance(message, bytes):
+        hasher.update(message)
+    else:
+        assert hasattr(message, "read") and hasattr(message.read, "__call__")
+        # read as 1K blocks
+        for block in yield_fixedblocks(message, 1024):
+            hasher.update(block)
+
+    return hasher.digest()
+
+
+def _find_method_hash(clearsig: bytes) -> str:
+    """Finds the hash method.
+
+    :param clearsig: full padded ASN1 and hash.
+    :return: the used hash method.
+    :raise VerificationFailed: when the hash method cannot be found
+    """
+
+    for (hashname, asn1code) in HASH_ASN1.items():
+        if asn1code in clearsig:
+            return hashname
+
+    raise VerificationError("Verification failed")
+
+
+__all__ = [
+    "encrypt",
+    "decrypt",
+    "sign",
+    "verify",
+    "DecryptionError",
+    "VerificationError",
+    "CryptoError",
+]
+
+if __name__ == "__main__":
+    print("Running doctests 1000x or until failure")
+    import doctest
+
+    for count in range(1000):
+        (failures, tests) = doctest.testmod()
+        if failures:
+            break
+
+        if count % 100 == 0 and count:
+            print("%i times" % count)
+
+    print("Doctests done")
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/pkcs1_v2.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/pkcs1_v2.py
new file mode 100644
index 0000000000000000000000000000000000000000..d68b9077215d0d69e181ccda47d6969cd4b245a3
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/pkcs1_v2.py
@@ -0,0 +1,100 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  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
+#
+#      https://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.
+
+"""Functions for PKCS#1 version 2 encryption and signing
+
+This module implements certain functionality from PKCS#1 version 2. Main
+documentation is RFC 2437: https://tools.ietf.org/html/rfc2437
+"""
+
+from rsa import (
+    common,
+    pkcs1,
+    transform,
+)
+
+
+def mgf1(seed: bytes, length: int, hasher: str = "SHA-1") -> bytes:
+    """
+    MGF1 is a Mask Generation Function based on a hash function.
+
+    A mask generation function takes an octet string of variable length and a
+    desired output length as input, and outputs an octet string of the desired
+    length. The plaintext-awareness of RSAES-OAEP relies on the random nature of
+    the output of the mask generation function, which in turn relies on the
+    random nature of the underlying hash.
+
+    :param bytes seed: seed from which mask is generated, an octet string
+    :param int length: intended length in octets of the mask, at most 2^32(hLen)
+    :param str hasher: hash function (hLen denotes the length in octets of the hash
+        function output)
+
+    :return: mask, an octet string of length `length`
+    :rtype: bytes
+
+    :raise OverflowError: when `length` is too large for the specified `hasher`
+    :raise ValueError: when specified `hasher` is invalid
+    """
+
+    try:
+        hash_length = pkcs1.HASH_METHODS[hasher]().digest_size
+    except KeyError as ex:
+        raise ValueError(
+            "Invalid `hasher` specified. Please select one of: {hash_list}".format(
+                hash_list=", ".join(sorted(pkcs1.HASH_METHODS.keys()))
+            )
+        ) from ex
+
+    # If l > 2^32(hLen), output "mask too long" and stop.
+    if length > (2 ** 32 * hash_length):
+        raise OverflowError(
+            "Desired length should be at most 2**32 times the hasher's output "
+            "length ({hash_length} for {hasher} function)".format(
+                hash_length=hash_length,
+                hasher=hasher,
+            )
+        )
+
+    # Looping `counter` from 0 to ceil(l / hLen)-1, build `output` based on the
+    # hashes formed by (`seed` + C), being `C` an octet string of length 4
+    # generated by converting `counter` with the primitive I2OSP
+    output = b"".join(
+        pkcs1.compute_hash(
+            seed + transform.int2bytes(counter, fill_size=4),
+            method_name=hasher,
+        )
+        for counter in range(common.ceil_div(length, hash_length) + 1)
+    )
+
+    # Output the leading `length` octets of `output` as the octet string mask.
+    return output[:length]
+
+
+__all__ = [
+    "mgf1",
+]
+
+if __name__ == "__main__":
+    print("Running doctests 1000x or until failure")
+    import doctest
+
+    for count in range(1000):
+        (failures, tests) = doctest.testmod()
+        if failures:
+            break
+
+        if count % 100 == 0 and count:
+            print("%i times" % count)
+
+    print("Doctests done")
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/randnum.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/randnum.py
new file mode 100644
index 0000000000000000000000000000000000000000..c65facddc70f9d4da9d12c94ccd8e334b03c954f
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/randnum.py
@@ -0,0 +1,95 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  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
+#
+#      https://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.
+
+"""Functions for generating random numbers."""
+
+# Source inspired by code by Yesudeep Mangalapilly <yesudeep@gmail.com>
+
+import os
+import struct
+
+from rsa import common, transform
+
+
+def read_random_bits(nbits: int) -> bytes:
+    """Reads 'nbits' random bits.
+
+    If nbits isn't a whole number of bytes, an extra byte will be appended with
+    only the lower bits set.
+    """
+
+    nbytes, rbits = divmod(nbits, 8)
+
+    # Get the random bytes
+    randomdata = os.urandom(nbytes)
+
+    # Add the remaining random bits
+    if rbits > 0:
+        randomvalue = ord(os.urandom(1))
+        randomvalue >>= 8 - rbits
+        randomdata = struct.pack("B", randomvalue) + randomdata
+
+    return randomdata
+
+
+def read_random_int(nbits: int) -> int:
+    """Reads a random integer of approximately nbits bits."""
+
+    randomdata = read_random_bits(nbits)
+    value = transform.bytes2int(randomdata)
+
+    # Ensure that the number is large enough to just fill out the required
+    # number of bits.
+    value |= 1 << (nbits - 1)
+
+    return value
+
+
+def read_random_odd_int(nbits: int) -> int:
+    """Reads a random odd integer of approximately nbits bits.
+
+    >>> read_random_odd_int(512) & 1
+    1
+    """
+
+    value = read_random_int(nbits)
+
+    # Make sure it's odd
+    return value | 1
+
+
+def randint(maxvalue: int) -> int:
+    """Returns a random integer x with 1 <= x <= maxvalue
+
+    May take a very long time in specific situations. If maxvalue needs N bits
+    to store, the closer maxvalue is to (2 ** N) - 1, the faster this function
+    is.
+    """
+
+    bit_size = common.bit_size(maxvalue)
+
+    tries = 0
+    while True:
+        value = read_random_int(bit_size)
+        if value <= maxvalue:
+            break
+
+        if tries % 10 == 0 and tries:
+            # After a lot of tries to get the right number of bits but still
+            # smaller than maxvalue, decrease the number of bits by 1. That'll
+            # dramatically increase the chances to get a large enough number.
+            bit_size -= 1
+        tries += 1
+
+    return value
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/transform.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/transform.py
new file mode 100644
index 0000000000000000000000000000000000000000..c609b65f3cdb8877efd7cb071974de87a794acc3
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/rsa/transform.py
@@ -0,0 +1,72 @@
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  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
+#
+#      https://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.
+
+"""Data transformation functions.
+
+From bytes to a number, number to bytes, etc.
+"""
+
+import math
+
+
+def bytes2int(raw_bytes: bytes) -> int:
+    r"""Converts a list of bytes or an 8-bit string to an integer.
+
+    When using unicode strings, encode it to some encoding like UTF8 first.
+
+    >>> (((128 * 256) + 64) * 256) + 15
+    8405007
+    >>> bytes2int(b'\x80@\x0f')
+    8405007
+
+    """
+    return int.from_bytes(raw_bytes, "big", signed=False)
+
+
+def int2bytes(number: int, fill_size: int = 0) -> bytes:
+    """
+    Convert an unsigned integer to bytes (big-endian)::
+
+    Does not preserve leading zeros if you don't specify a fill size.
+
+    :param number:
+        Integer value
+    :param fill_size:
+        If the optional fill size is given the length of the resulting
+        byte string is expected to be the fill size and will be padded
+        with prefix zero bytes to satisfy that length.
+    :returns:
+        Raw bytes (base-256 representation).
+    :raises:
+        ``OverflowError`` when fill_size is given and the number takes up more
+        bytes than fit into the block. This requires the ``overflow``
+        argument to this function to be set to ``False`` otherwise, no
+        error will be raised.
+    """
+
+    if number < 0:
+        raise ValueError("Number must be an unsigned integer: %d" % number)
+
+    bytes_required = max(1, math.ceil(number.bit_length() / 8))
+
+    if fill_size > 0:
+        return number.to_bytes(fill_size, "big")
+
+    return number.to_bytes(bytes_required, "big")
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/sniffio/__init__.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/sniffio/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..63f2f19e409c7f4b3c6c064022e8f104227873aa
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/sniffio/__init__.py
@@ -0,0 +1,17 @@
+"""Top-level package for sniffio."""
+
+__all__ = [
+    "current_async_library",
+    "AsyncLibraryNotFoundError",
+    "current_async_library_cvar",
+    "thread_local",
+]
+
+from ._version import __version__
+
+from ._impl import (
+    current_async_library,
+    AsyncLibraryNotFoundError,
+    current_async_library_cvar,
+    thread_local,
+)
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/sniffio/_version.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/sniffio/_version.py
new file mode 100644
index 0000000000000000000000000000000000000000..0495d10545c9fd515ed51e890309d2b66e2c30bb
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/sniffio/_version.py
@@ -0,0 +1,3 @@
+# This file is imported from __init__.py and exec'd from setup.py
+
+__version__ = "1.3.1"
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/sniffio/py.typed b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/sniffio/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/wrapt/__init__.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/wrapt/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ee6539b774afe6e4dbfb5428e02a9dac3ffac76c
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/wrapt/__init__.py
@@ -0,0 +1,27 @@
+__version_info__ = ('1', '14', '1')
+__version__ = '.'.join(__version_info__)
+
+from .wrappers import (ObjectProxy, CallableObjectProxy, FunctionWrapper,
+        BoundFunctionWrapper, WeakFunctionProxy, PartialCallableObjectProxy,
+        resolve_path, apply_patch, wrap_object, wrap_object_attribute,
+        function_wrapper, wrap_function_wrapper, patch_function_wrapper,
+        transient_function_wrapper)
+
+from .decorators import (adapter_factory, AdapterFactory, decorator,
+        synchronized)
+
+from .importer import (register_post_import_hook, when_imported,
+        notify_module_loaded, discover_post_import_hooks)
+
+# Import of inspect.getcallargs() included for backward compatibility. An
+# implementation of this was previously bundled and made available here for
+# Python <2.7. Avoid using this in future.
+
+from inspect import getcallargs
+
+# Variant of inspect.formatargspec() included here for forward compatibility.
+# This is being done because Python 3.11 dropped inspect.formatargspec() but
+# code for handling signature changing decorators relied on it. Exposing the
+# bundled implementation here in case any user of wrapt was also needing it.
+
+from .arguments import formatargspec
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/wrapt/decorators.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/wrapt/decorators.py
new file mode 100644
index 0000000000000000000000000000000000000000..c3f2547295a815f8e0b377bfdc90b3838de84726
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/wrapt/decorators.py
@@ -0,0 +1,541 @@
+"""This module implements decorators for implementing other decorators
+as well as some commonly used decorators.
+
+"""
+
+import sys
+
+PY2 = sys.version_info[0] == 2
+
+if PY2:
+    string_types = basestring,
+
+    def exec_(_code_, _globs_=None, _locs_=None):
+        """Execute code in a namespace."""
+        if _globs_ is None:
+            frame = sys._getframe(1)
+            _globs_ = frame.f_globals
+            if _locs_ is None:
+                _locs_ = frame.f_locals
+            del frame
+        elif _locs_ is None:
+            _locs_ = _globs_
+        exec("""exec _code_ in _globs_, _locs_""")
+
+else:
+    string_types = str,
+
+    import builtins
+
+    exec_ = getattr(builtins, "exec")
+    del builtins
+
+from functools import partial
+from inspect import isclass
+from threading import Lock, RLock
+
+from .arguments import formatargspec
+
+try:
+    from inspect import signature
+except ImportError:
+    pass
+
+from .wrappers import (FunctionWrapper, BoundFunctionWrapper, ObjectProxy,
+    CallableObjectProxy)
+
+# Adapter wrapper for the wrapped function which will overlay certain
+# properties from the adapter function onto the wrapped function so that
+# functions such as inspect.getargspec(), inspect.getfullargspec(),
+# inspect.signature() and inspect.getsource() return the correct results
+# one would expect.
+
+class _AdapterFunctionCode(CallableObjectProxy):
+
+    def __init__(self, wrapped_code, adapter_code):
+        super(_AdapterFunctionCode, self).__init__(wrapped_code)
+        self._self_adapter_code = adapter_code
+
+    @property
+    def co_argcount(self):
+        return self._self_adapter_code.co_argcount
+
+    @property
+    def co_code(self):
+        return self._self_adapter_code.co_code
+
+    @property
+    def co_flags(self):
+        return self._self_adapter_code.co_flags
+
+    @property
+    def co_kwonlyargcount(self):
+        return self._self_adapter_code.co_kwonlyargcount
+
+    @property
+    def co_varnames(self):
+        return self._self_adapter_code.co_varnames
+
+class _AdapterFunctionSurrogate(CallableObjectProxy):
+
+    def __init__(self, wrapped, adapter):
+        super(_AdapterFunctionSurrogate, self).__init__(wrapped)
+        self._self_adapter = adapter
+
+    @property
+    def __code__(self):
+        return _AdapterFunctionCode(self.__wrapped__.__code__,
+                self._self_adapter.__code__)
+
+    @property
+    def __defaults__(self):
+        return self._self_adapter.__defaults__
+
+    @property
+    def __kwdefaults__(self):
+        return self._self_adapter.__kwdefaults__
+
+    @property
+    def __signature__(self):
+        if 'signature' not in globals():
+            return self._self_adapter.__signature__
+        else:
+            return signature(self._self_adapter)
+
+    if PY2:
+        func_code = __code__
+        func_defaults = __defaults__
+
+class _BoundAdapterWrapper(BoundFunctionWrapper):
+
+    @property
+    def __func__(self):
+        return _AdapterFunctionSurrogate(self.__wrapped__.__func__,
+                self._self_parent._self_adapter)
+
+    @property
+    def __signature__(self):
+        if 'signature' not in globals():
+            return self.__wrapped__.__signature__
+        else:
+            return signature(self._self_parent._self_adapter)
+
+    if PY2:
+        im_func = __func__
+
+class AdapterWrapper(FunctionWrapper):
+
+    __bound_function_wrapper__ = _BoundAdapterWrapper
+
+    def __init__(self, *args, **kwargs):
+        adapter = kwargs.pop('adapter')
+        super(AdapterWrapper, self).__init__(*args, **kwargs)
+        self._self_surrogate = _AdapterFunctionSurrogate(
+                self.__wrapped__, adapter)
+        self._self_adapter = adapter
+
+    @property
+    def __code__(self):
+        return self._self_surrogate.__code__
+
+    @property
+    def __defaults__(self):
+        return self._self_surrogate.__defaults__
+
+    @property
+    def __kwdefaults__(self):
+        return self._self_surrogate.__kwdefaults__
+
+    if PY2:
+        func_code = __code__
+        func_defaults = __defaults__
+
+    @property
+    def __signature__(self):
+        return self._self_surrogate.__signature__
+
+class AdapterFactory(object):
+    def __call__(self, wrapped):
+        raise NotImplementedError()
+
+class DelegatedAdapterFactory(AdapterFactory):
+    def __init__(self, factory):
+        super(DelegatedAdapterFactory, self).__init__()
+        self.factory = factory
+    def __call__(self, wrapped):
+        return self.factory(wrapped)
+
+adapter_factory = DelegatedAdapterFactory
+
+# Decorator for creating other decorators. This decorator and the
+# wrappers which they use are designed to properly preserve any name
+# attributes, function signatures etc, in addition to the wrappers
+# themselves acting like a transparent proxy for the original wrapped
+# function so the wrapper is effectively indistinguishable from the
+# original wrapped function.
+
+def decorator(wrapper=None, enabled=None, adapter=None, proxy=FunctionWrapper):
+    # The decorator should be supplied with a single positional argument
+    # which is the wrapper function to be used to implement the
+    # decorator. This may be preceded by a step whereby the keyword
+    # arguments are supplied to customise the behaviour of the
+    # decorator. The 'adapter' argument is used to optionally denote a
+    # separate function which is notionally used by an adapter
+    # decorator. In that case parts of the function '__code__' and
+    # '__defaults__' attributes are used from the adapter function
+    # rather than those of the wrapped function. This allows for the
+    # argument specification from inspect.getfullargspec() and similar
+    # functions to be overridden with a prototype for a different
+    # function than what was wrapped. The 'enabled' argument provides a
+    # way to enable/disable the use of the decorator. If the type of
+    # 'enabled' is a boolean, then it is evaluated immediately and the
+    # wrapper not even applied if it is False. If not a boolean, it will
+    # be evaluated when the wrapper is called for an unbound wrapper,
+    # and when binding occurs for a bound wrapper. When being evaluated,
+    # if 'enabled' is callable it will be called to obtain the value to
+    # be checked. If False, the wrapper will not be called and instead
+    # the original wrapped function will be called directly instead.
+    # The 'proxy' argument provides a way of passing a custom version of
+    # the FunctionWrapper class used in decorating the function.
+
+    if wrapper is not None:
+        # Helper function for creating wrapper of the appropriate
+        # time when we need it down below.
+
+        def _build(wrapped, wrapper, enabled=None, adapter=None):
+            if adapter:
+                if isinstance(adapter, AdapterFactory):
+                    adapter = adapter(wrapped)
+
+                if not callable(adapter):
+                    ns = {}
+
+                    # Check if the signature argument specification has
+                    # annotations. If it does then we need to remember
+                    # it but also drop it when attempting to manufacture
+                    # a standin adapter function. This is necessary else
+                    # it will try and look up any types referenced in
+                    # the annotations in the empty namespace we use,
+                    # which will fail.
+
+                    annotations = {}
+
+                    if not isinstance(adapter, string_types):
+                        if len(adapter) == 7:
+                            annotations = adapter[-1]
+                            adapter = adapter[:-1]
+                        adapter = formatargspec(*adapter)
+
+                    exec_('def adapter{}: pass'.format(adapter), ns, ns)
+                    adapter = ns['adapter']
+
+                    # Override the annotations for the manufactured
+                    # adapter function so they match the original
+                    # adapter signature argument specification.
+
+                    if annotations:
+                        adapter.__annotations__ = annotations
+
+                return AdapterWrapper(wrapped=wrapped, wrapper=wrapper,
+                        enabled=enabled, adapter=adapter)
+
+            return proxy(wrapped=wrapped, wrapper=wrapper, enabled=enabled)
+
+        # The wrapper has been provided so return the final decorator.
+        # The decorator is itself one of our function wrappers so we
+        # can determine when it is applied to functions, instance methods
+        # or class methods. This allows us to bind the instance or class
+        # method so the appropriate self or cls attribute is supplied
+        # when it is finally called.
+
+        def _wrapper(wrapped, instance, args, kwargs):
+            # We first check for the case where the decorator was applied
+            # to a class type.
+            #
+            #     @decorator
+            #     class mydecoratorclass(object):
+            #         def __init__(self, arg=None):
+            #             self.arg = arg
+            #         def __call__(self, wrapped, instance, args, kwargs):
+            #             return wrapped(*args, **kwargs)
+            #
+            #     @mydecoratorclass(arg=1)
+            #     def function():
+            #         pass
+            #
+            # In this case an instance of the class is to be used as the
+            # decorator wrapper function. If args was empty at this point,
+            # then it means that there were optional keyword arguments
+            # supplied to be used when creating an instance of the class
+            # to be used as the wrapper function.
+
+            if instance is None and isclass(wrapped) and not args:
+                # We still need to be passed the target function to be
+                # wrapped as yet, so we need to return a further function
+                # to be able to capture it.
+
+                def _capture(target_wrapped):
+                    # Now have the target function to be wrapped and need
+                    # to create an instance of the class which is to act
+                    # as the decorator wrapper function. Before we do that,
+                    # we need to first check that use of the decorator
+                    # hadn't been disabled by a simple boolean. If it was,
+                    # the target function to be wrapped is returned instead.
+
+                    _enabled = enabled
+                    if type(_enabled) is bool:
+                        if not _enabled:
+                            return target_wrapped
+                        _enabled = None
+
+                    # Now create an instance of the class which is to act
+                    # as the decorator wrapper function. Any arguments had
+                    # to be supplied as keyword only arguments so that is
+                    # all we pass when creating it.
+
+                    target_wrapper = wrapped(**kwargs)
+
+                    # Finally build the wrapper itself and return it.
+
+                    return _build(target_wrapped, target_wrapper,
+                            _enabled, adapter)
+
+                return _capture
+
+            # We should always have the target function to be wrapped at
+            # this point as the first (and only) value in args.
+
+            target_wrapped = args[0]
+
+            # Need to now check that use of the decorator hadn't been
+            # disabled by a simple boolean. If it was, then target
+            # function to be wrapped is returned instead.
+
+            _enabled = enabled
+            if type(_enabled) is bool:
+                if not _enabled:
+                    return target_wrapped
+                _enabled = None
+
+            # We now need to build the wrapper, but there are a couple of
+            # different cases we need to consider.
+
+            if instance is None:
+                if isclass(wrapped):
+                    # In this case the decorator was applied to a class
+                    # type but optional keyword arguments were not supplied
+                    # for initialising an instance of the class to be used
+                    # as the decorator wrapper function.
+                    #
+                    #     @decorator
+                    #     class mydecoratorclass(object):
+                    #         def __init__(self, arg=None):
+                    #             self.arg = arg
+                    #         def __call__(self, wrapped, instance,
+                    #                 args, kwargs):
+                    #             return wrapped(*args, **kwargs)
+                    #
+                    #     @mydecoratorclass
+                    #     def function():
+                    #         pass
+                    #
+                    # We still need to create an instance of the class to
+                    # be used as the decorator wrapper function, but no
+                    # arguments are pass.
+
+                    target_wrapper = wrapped()
+
+                else:
+                    # In this case the decorator was applied to a normal
+                    # function, or possibly a static method of a class.
+                    #
+                    #     @decorator
+                    #     def mydecoratorfuntion(wrapped, instance,
+                    #             args, kwargs):
+                    #         return wrapped(*args, **kwargs)
+                    #
+                    #     @mydecoratorfunction
+                    #     def function():
+                    #         pass
+                    #
+                    # That normal function becomes the decorator wrapper
+                    # function.
+
+                    target_wrapper = wrapper
+
+            else:
+                if isclass(instance):
+                    # In this case the decorator was applied to a class
+                    # method.
+                    #
+                    #     class myclass(object):
+                    #         @decorator
+                    #         @classmethod
+                    #         def decoratorclassmethod(cls, wrapped,
+                    #                 instance, args, kwargs):
+                    #             return wrapped(*args, **kwargs)
+                    #
+                    #     instance = myclass()
+                    #
+                    #     @instance.decoratorclassmethod
+                    #     def function():
+                    #         pass
+                    #
+                    # This one is a bit strange because binding was actually
+                    # performed on the wrapper created by our decorator
+                    # factory. We need to apply that binding to the decorator
+                    # wrapper function that the decorator factory
+                    # was applied to.
+
+                    target_wrapper = wrapper.__get__(None, instance)
+
+                else:
+                    # In this case the decorator was applied to an instance
+                    # method.
+                    #
+                    #     class myclass(object):
+                    #         @decorator
+                    #         def decoratorclassmethod(self, wrapped,
+                    #                 instance, args, kwargs):
+                    #             return wrapped(*args, **kwargs)
+                    #
+                    #     instance = myclass()
+                    #
+                    #     @instance.decoratorclassmethod
+                    #     def function():
+                    #         pass
+                    #
+                    # This one is a bit strange because binding was actually
+                    # performed on the wrapper created by our decorator
+                    # factory. We need to apply that binding to the decorator
+                    # wrapper function that the decorator factory
+                    # was applied to.
+
+                    target_wrapper = wrapper.__get__(instance, type(instance))
+
+            # Finally build the wrapper itself and return it.
+
+            return _build(target_wrapped, target_wrapper, _enabled, adapter)
+
+        # We first return our magic function wrapper here so we can
+        # determine in what context the decorator factory was used. In
+        # other words, it is itself a universal decorator. The decorator
+        # function is used as the adapter so that linters see a signature
+        # corresponding to the decorator and not the wrapper it is being
+        # applied to.
+
+        return _build(wrapper, _wrapper, adapter=decorator)
+
+    else:
+        # The wrapper still has not been provided, so we are just
+        # collecting the optional keyword arguments. Return the
+        # decorator again wrapped in a partial using the collected
+        # arguments.
+
+        return partial(decorator, enabled=enabled, adapter=adapter,
+                proxy=proxy)
+
+# Decorator for implementing thread synchronization. It can be used as a
+# decorator, in which case the synchronization context is determined by
+# what type of function is wrapped, or it can also be used as a context
+# manager, where the user needs to supply the correct synchronization
+# context. It is also possible to supply an object which appears to be a
+# synchronization primitive of some sort, by virtue of having release()
+# and acquire() methods. In that case that will be used directly as the
+# synchronization primitive without creating a separate lock against the
+# derived or supplied context.
+
+def synchronized(wrapped):
+    # Determine if being passed an object which is a synchronization
+    # primitive. We can't check by type for Lock, RLock, Semaphore etc,
+    # as the means of creating them isn't the type. Therefore use the
+    # existence of acquire() and release() methods. This is more
+    # extensible anyway as it allows custom synchronization mechanisms.
+
+    if hasattr(wrapped, 'acquire') and hasattr(wrapped, 'release'):
+        # We remember what the original lock is and then return a new
+        # decorator which accesses and locks it. When returning the new
+        # decorator we wrap it with an object proxy so we can override
+        # the context manager methods in case it is being used to wrap
+        # synchronized statements with a 'with' statement.
+
+        lock = wrapped
+
+        @decorator
+        def _synchronized(wrapped, instance, args, kwargs):
+            # Execute the wrapped function while the original supplied
+            # lock is held.
+
+            with lock:
+                return wrapped(*args, **kwargs)
+
+        class _PartialDecorator(CallableObjectProxy):
+
+            def __enter__(self):
+                lock.acquire()
+                return lock
+
+            def __exit__(self, *args):
+                lock.release()
+
+        return _PartialDecorator(wrapped=_synchronized)
+
+    # Following only apply when the lock is being created automatically
+    # based on the context of what was supplied. In this case we supply
+    # a final decorator, but need to use FunctionWrapper directly as we
+    # want to derive from it to add context manager methods in case it is
+    # being used to wrap synchronized statements with a 'with' statement.
+
+    def _synchronized_lock(context):
+        # Attempt to retrieve the lock for the specific context.
+
+        lock = vars(context).get('_synchronized_lock', None)
+
+        if lock is None:
+            # There is no existing lock defined for the context we
+            # are dealing with so we need to create one. This needs
+            # to be done in a way to guarantee there is only one
+            # created, even if multiple threads try and create it at
+            # the same time. We can't always use the setdefault()
+            # method on the __dict__ for the context. This is the
+            # case where the context is a class, as __dict__ is
+            # actually a dictproxy. What we therefore do is use a
+            # meta lock on this wrapper itself, to control the
+            # creation and assignment of the lock attribute against
+            # the context.
+
+            with synchronized._synchronized_meta_lock:
+                # We need to check again for whether the lock we want
+                # exists in case two threads were trying to create it
+                # at the same time and were competing to create the
+                # meta lock.
+
+                lock = vars(context).get('_synchronized_lock', None)
+
+                if lock is None:
+                    lock = RLock()
+                    setattr(context, '_synchronized_lock', lock)
+
+        return lock
+
+    def _synchronized_wrapper(wrapped, instance, args, kwargs):
+        # Execute the wrapped function while the lock for the
+        # desired context is held. If instance is None then the
+        # wrapped function is used as the context.
+
+        with _synchronized_lock(instance if instance is not None else wrapped):
+            return wrapped(*args, **kwargs)
+
+    class _FinalDecorator(FunctionWrapper):
+
+        def __enter__(self):
+            self._self_lock = _synchronized_lock(self.__wrapped__)
+            self._self_lock.acquire()
+            return self._self_lock
+
+        def __exit__(self, *args):
+            self._self_lock.release()
+
+    return _FinalDecorator(wrapped=wrapped, wrapper=_synchronized_wrapper)
+
+synchronized._synchronized_meta_lock = Lock()
diff --git a/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/wrapt/wrappers.py b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/wrapt/wrappers.py
new file mode 100644
index 0000000000000000000000000000000000000000..2716cd1da1a5fbb4f260b5344b3ec6c37ea2c6b2
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/wrapt/wrappers.py
@@ -0,0 +1,986 @@
+import os
+import sys
+import functools
+import operator
+import weakref
+import inspect
+
+PY2 = sys.version_info[0] == 2
+
+if PY2:
+    string_types = basestring,
+else:
+    string_types = str,
+
+def with_metaclass(meta, *bases):
+    """Create a base class with a metaclass."""
+    return meta("NewBase", bases, {})
+
+class _ObjectProxyMethods(object):
+
+    # We use properties to override the values of __module__ and
+    # __doc__. If we add these in ObjectProxy, the derived class
+    # __dict__ will still be setup to have string variants of these
+    # attributes and the rules of descriptors means that they appear to
+    # take precedence over the properties in the base class. To avoid
+    # that, we copy the properties into the derived class type itself
+    # via a meta class. In that way the properties will always take
+    # precedence.
+
+    @property
+    def __module__(self):
+        return self.__wrapped__.__module__
+
+    @__module__.setter
+    def __module__(self, value):
+        self.__wrapped__.__module__ = value
+
+    @property
+    def __doc__(self):
+        return self.__wrapped__.__doc__
+
+    @__doc__.setter
+    def __doc__(self, value):
+        self.__wrapped__.__doc__ = value
+
+    # We similar use a property for __dict__. We need __dict__ to be
+    # explicit to ensure that vars() works as expected.
+
+    @property
+    def __dict__(self):
+        return self.__wrapped__.__dict__
+
+    # Need to also propagate the special __weakref__ attribute for case
+    # where decorating classes which will define this. If do not define
+    # it and use a function like inspect.getmembers() on a decorator
+    # class it will fail. This can't be in the derived classes.
+
+    @property
+    def __weakref__(self):
+        return self.__wrapped__.__weakref__
+
+class _ObjectProxyMetaType(type):
+    def __new__(cls, name, bases, dictionary):
+        # Copy our special properties into the class so that they
+        # always take precedence over attributes of the same name added
+        # during construction of a derived class. This is to save
+        # duplicating the implementation for them in all derived classes.
+
+        dictionary.update(vars(_ObjectProxyMethods))
+
+        return type.__new__(cls, name, bases, dictionary)
+
+class ObjectProxy(with_metaclass(_ObjectProxyMetaType)):
+
+    __slots__ = '__wrapped__'
+
+    def __init__(self, wrapped):
+        object.__setattr__(self, '__wrapped__', wrapped)
+
+        # Python 3.2+ has the __qualname__ attribute, but it does not
+        # allow it to be overridden using a property and it must instead
+        # be an actual string object instead.
+
+        try:
+            object.__setattr__(self, '__qualname__', wrapped.__qualname__)
+        except AttributeError:
+            pass
+
+        # Python 3.10 onwards also does not allow itself to be overridden
+        # using a property and it must instead be set explicitly.
+
+        try:
+            object.__setattr__(self, '__annotations__', wrapped.__annotations__)
+        except AttributeError:
+            pass
+
+    @property
+    def __name__(self):
+        return self.__wrapped__.__name__
+
+    @__name__.setter
+    def __name__(self, value):
+        self.__wrapped__.__name__ = value
+
+    @property
+    def __class__(self):
+        return self.__wrapped__.__class__
+
+    @__class__.setter
+    def __class__(self, value):
+        self.__wrapped__.__class__ = value
+
+    def __dir__(self):
+        return dir(self.__wrapped__)
+
+    def __str__(self):
+        return str(self.__wrapped__)
+
+    if not PY2:
+        def __bytes__(self):
+            return bytes(self.__wrapped__)
+
+    def __repr__(self):
+        return '<{} at 0x{:x} for {} at 0x{:x}>'.format(
+                type(self).__name__, id(self),
+                type(self.__wrapped__).__name__,
+                id(self.__wrapped__))
+
+    def __reversed__(self):
+        return reversed(self.__wrapped__)
+
+    if not PY2:
+        def __round__(self):
+            return round(self.__wrapped__)
+
+    if sys.hexversion >= 0x03070000:
+        def __mro_entries__(self, bases):
+            return (self.__wrapped__,)
+
+    def __lt__(self, other):
+        return self.__wrapped__ < other
+
+    def __le__(self, other):
+        return self.__wrapped__ <= other
+
+    def __eq__(self, other):
+        return self.__wrapped__ == other
+
+    def __ne__(self, other):
+        return self.__wrapped__ != other
+
+    def __gt__(self, other):
+        return self.__wrapped__ > other
+
+    def __ge__(self, other):
+        return self.__wrapped__ >= other
+
+    def __hash__(self):
+        return hash(self.__wrapped__)
+
+    def __nonzero__(self):
+        return bool(self.__wrapped__)
+
+    def __bool__(self):
+        return bool(self.__wrapped__)
+
+    def __setattr__(self, name, value):
+        if name.startswith('_self_'):
+            object.__setattr__(self, name, value)
+
+        elif name == '__wrapped__':
+            object.__setattr__(self, name, value)
+            try:
+                object.__delattr__(self, '__qualname__')
+            except AttributeError:
+                pass
+            try:
+                object.__setattr__(self, '__qualname__', value.__qualname__)
+            except AttributeError:
+                pass
+            try:
+                object.__delattr__(self, '__annotations__')
+            except AttributeError:
+                pass
+            try:
+                object.__setattr__(self, '__annotations__', value.__annotations__)
+            except AttributeError:
+                pass
+
+        elif name == '__qualname__':
+            setattr(self.__wrapped__, name, value)
+            object.__setattr__(self, name, value)
+
+        elif name == '__annotations__':
+            setattr(self.__wrapped__, name, value)
+            object.__setattr__(self, name, value)
+
+        elif hasattr(type(self), name):
+            object.__setattr__(self, name, value)
+
+        else:
+            setattr(self.__wrapped__, name, value)
+
+    def __getattr__(self, name):
+        # If we are being to lookup '__wrapped__' then the
+        # '__init__()' method cannot have been called.
+
+        if name == '__wrapped__':
+            raise ValueError('wrapper has not been initialised')
+
+        return getattr(self.__wrapped__, name)
+
+    def __delattr__(self, name):
+        if name.startswith('_self_'):
+            object.__delattr__(self, name)
+
+        elif name == '__wrapped__':
+            raise TypeError('__wrapped__ must be an object')
+
+        elif name == '__qualname__':
+            object.__delattr__(self, name)
+            delattr(self.__wrapped__, name)
+
+        elif hasattr(type(self), name):
+            object.__delattr__(self, name)
+
+        else:
+            delattr(self.__wrapped__, name)
+
+    def __add__(self, other):
+        return self.__wrapped__ + other
+
+    def __sub__(self, other):
+        return self.__wrapped__ - other
+
+    def __mul__(self, other):
+        return self.__wrapped__ * other
+
+    def __div__(self, other):
+        return operator.div(self.__wrapped__, other)
+
+    def __truediv__(self, other):
+        return operator.truediv(self.__wrapped__, other)
+
+    def __floordiv__(self, other):
+        return self.__wrapped__ // other
+
+    def __mod__(self, other):
+        return self.__wrapped__ % other
+
+    def __divmod__(self, other):
+        return divmod(self.__wrapped__, other)
+
+    def __pow__(self, other, *args):
+        return pow(self.__wrapped__, other, *args)
+
+    def __lshift__(self, other):
+        return self.__wrapped__ << other
+
+    def __rshift__(self, other):
+        return self.__wrapped__ >> other
+
+    def __and__(self, other):
+        return self.__wrapped__ & other
+
+    def __xor__(self, other):
+        return self.__wrapped__ ^ other
+
+    def __or__(self, other):
+        return self.__wrapped__ | other
+
+    def __radd__(self, other):
+        return other + self.__wrapped__
+
+    def __rsub__(self, other):
+        return other - self.__wrapped__
+
+    def __rmul__(self, other):
+        return other * self.__wrapped__
+
+    def __rdiv__(self, other):
+        return operator.div(other, self.__wrapped__)
+
+    def __rtruediv__(self, other):
+        return operator.truediv(other, self.__wrapped__)
+
+    def __rfloordiv__(self, other):
+        return other // self.__wrapped__
+
+    def __rmod__(self, other):
+        return other % self.__wrapped__
+
+    def __rdivmod__(self, other):
+        return divmod(other, self.__wrapped__)
+
+    def __rpow__(self, other, *args):
+        return pow(other, self.__wrapped__, *args)
+
+    def __rlshift__(self, other):
+        return other << self.__wrapped__
+
+    def __rrshift__(self, other):
+        return other >> self.__wrapped__
+
+    def __rand__(self, other):
+        return other & self.__wrapped__
+
+    def __rxor__(self, other):
+        return other ^ self.__wrapped__
+
+    def __ror__(self, other):
+        return other | self.__wrapped__
+
+    def __iadd__(self, other):
+        self.__wrapped__ += other
+        return self
+
+    def __isub__(self, other):
+        self.__wrapped__ -= other
+        return self
+
+    def __imul__(self, other):
+        self.__wrapped__ *= other
+        return self
+
+    def __idiv__(self, other):
+        self.__wrapped__ = operator.idiv(self.__wrapped__, other)
+        return self
+
+    def __itruediv__(self, other):
+        self.__wrapped__ = operator.itruediv(self.__wrapped__, other)
+        return self
+
+    def __ifloordiv__(self, other):
+        self.__wrapped__ //= other
+        return self
+
+    def __imod__(self, other):
+        self.__wrapped__ %= other
+        return self
+
+    def __ipow__(self, other):
+        self.__wrapped__ **= other
+        return self
+
+    def __ilshift__(self, other):
+        self.__wrapped__ <<= other
+        return self
+
+    def __irshift__(self, other):
+        self.__wrapped__ >>= other
+        return self
+
+    def __iand__(self, other):
+        self.__wrapped__ &= other
+        return self
+
+    def __ixor__(self, other):
+        self.__wrapped__ ^= other
+        return self
+
+    def __ior__(self, other):
+        self.__wrapped__ |= other
+        return self
+
+    def __neg__(self):
+        return -self.__wrapped__
+
+    def __pos__(self):
+        return +self.__wrapped__
+
+    def __abs__(self):
+        return abs(self.__wrapped__)
+
+    def __invert__(self):
+        return ~self.__wrapped__
+
+    def __int__(self):
+        return int(self.__wrapped__)
+
+    def __long__(self):
+        return long(self.__wrapped__)
+
+    def __float__(self):
+        return float(self.__wrapped__)
+
+    def __complex__(self):
+        return complex(self.__wrapped__)
+
+    def __oct__(self):
+        return oct(self.__wrapped__)
+
+    def __hex__(self):
+        return hex(self.__wrapped__)
+
+    def __index__(self):
+        return operator.index(self.__wrapped__)
+
+    def __len__(self):
+        return len(self.__wrapped__)
+
+    def __contains__(self, value):
+        return value in self.__wrapped__
+
+    def __getitem__(self, key):
+        return self.__wrapped__[key]
+
+    def __setitem__(self, key, value):
+        self.__wrapped__[key] = value
+
+    def __delitem__(self, key):
+        del self.__wrapped__[key]
+
+    def __getslice__(self, i, j):
+        return self.__wrapped__[i:j]
+
+    def __setslice__(self, i, j, value):
+        self.__wrapped__[i:j] = value
+
+    def __delslice__(self, i, j):
+        del self.__wrapped__[i:j]
+
+    def __enter__(self):
+        return self.__wrapped__.__enter__()
+
+    def __exit__(self, *args, **kwargs):
+        return self.__wrapped__.__exit__(*args, **kwargs)
+
+    def __iter__(self):
+        return iter(self.__wrapped__)
+
+    def __copy__(self):
+        raise NotImplementedError('object proxy must define __copy__()')
+
+    def __deepcopy__(self, memo):
+        raise NotImplementedError('object proxy must define __deepcopy__()')
+
+    def __reduce__(self):
+        raise NotImplementedError(
+                'object proxy must define __reduce_ex__()')
+
+    def __reduce_ex__(self, protocol):
+        raise NotImplementedError(
+                'object proxy must define __reduce_ex__()')
+
+class CallableObjectProxy(ObjectProxy):
+
+    def __call__(self, *args, **kwargs):
+        return self.__wrapped__(*args, **kwargs)
+
+class PartialCallableObjectProxy(ObjectProxy):
+
+    def __init__(self, *args, **kwargs):
+        if len(args) < 1:
+            raise TypeError('partial type takes at least one argument')
+
+        wrapped, args = args[0], args[1:]
+
+        if not callable(wrapped):
+            raise TypeError('the first argument must be callable')
+
+        super(PartialCallableObjectProxy, self).__init__(wrapped)
+
+        self._self_args = args
+        self._self_kwargs = kwargs
+
+    def __call__(self, *args, **kwargs):
+        _args = self._self_args + args
+
+        _kwargs = dict(self._self_kwargs)
+        _kwargs.update(kwargs)
+
+        return self.__wrapped__(*_args, **_kwargs)
+
+class _FunctionWrapperBase(ObjectProxy):
+
+    __slots__ = ('_self_instance', '_self_wrapper', '_self_enabled',
+            '_self_binding', '_self_parent')
+
+    def __init__(self, wrapped, instance, wrapper, enabled=None,
+            binding='function', parent=None):
+
+        super(_FunctionWrapperBase, self).__init__(wrapped)
+
+        object.__setattr__(self, '_self_instance', instance)
+        object.__setattr__(self, '_self_wrapper', wrapper)
+        object.__setattr__(self, '_self_enabled', enabled)
+        object.__setattr__(self, '_self_binding', binding)
+        object.__setattr__(self, '_self_parent', parent)
+
+    def __get__(self, instance, owner):
+        # This method is actually doing double duty for both unbound and
+        # bound derived wrapper classes. It should possibly be broken up
+        # and the distinct functionality moved into the derived classes.
+        # Can't do that straight away due to some legacy code which is
+        # relying on it being here in this base class.
+        #
+        # The distinguishing attribute which determines whether we are
+        # being called in an unbound or bound wrapper is the parent
+        # attribute. If binding has never occurred, then the parent will
+        # be None.
+        #
+        # First therefore, is if we are called in an unbound wrapper. In
+        # this case we perform the binding.
+        #
+        # We have one special case to worry about here. This is where we
+        # are decorating a nested class. In this case the wrapped class
+        # would not have a __get__() method to call. In that case we
+        # simply return self.
+        #
+        # Note that we otherwise still do binding even if instance is
+        # None and accessing an unbound instance method from a class.
+        # This is because we need to be able to later detect that
+        # specific case as we will need to extract the instance from the
+        # first argument of those passed in.
+
+        if self._self_parent is None:
+            if not inspect.isclass(self.__wrapped__):
+                descriptor = self.__wrapped__.__get__(instance, owner)
+
+                return self.__bound_function_wrapper__(descriptor, instance,
+                        self._self_wrapper, self._self_enabled,
+                        self._self_binding, self)
+
+            return self
+
+        # Now we have the case of binding occurring a second time on what
+        # was already a bound function. In this case we would usually
+        # return ourselves again. This mirrors what Python does.
+        #
+        # The special case this time is where we were originally bound
+        # with an instance of None and we were likely an instance
+        # method. In that case we rebind against the original wrapped
+        # function from the parent again.
+
+        if self._self_instance is None and self._self_binding == 'function':
+            descriptor = self._self_parent.__wrapped__.__get__(
+                    instance, owner)
+
+            return self._self_parent.__bound_function_wrapper__(
+                    descriptor, instance, self._self_wrapper,
+                    self._self_enabled, self._self_binding,
+                    self._self_parent)
+
+        return self
+
+    def __call__(self, *args, **kwargs):
+        # If enabled has been specified, then evaluate it at this point
+        # and if the wrapper is not to be executed, then simply return
+        # the bound function rather than a bound wrapper for the bound
+        # function. When evaluating enabled, if it is callable we call
+        # it, otherwise we evaluate it as a boolean.
+
+        if self._self_enabled is not None:
+            if callable(self._self_enabled):
+                if not self._self_enabled():
+                    return self.__wrapped__(*args, **kwargs)
+            elif not self._self_enabled:
+                return self.__wrapped__(*args, **kwargs)
+
+        # This can occur where initial function wrapper was applied to
+        # a function that was already bound to an instance. In that case
+        # we want to extract the instance from the function and use it.
+
+        if self._self_binding in ('function', 'classmethod'):
+            if self._self_instance is None:
+                instance = getattr(self.__wrapped__, '__self__', None)
+                if instance is not None:
+                    return self._self_wrapper(self.__wrapped__, instance,
+                            args, kwargs)
+
+        # This is generally invoked when the wrapped function is being
+        # called as a normal function and is not bound to a class as an
+        # instance method. This is also invoked in the case where the
+        # wrapped function was a method, but this wrapper was in turn
+        # wrapped using the staticmethod decorator.
+
+        return self._self_wrapper(self.__wrapped__, self._self_instance,
+                args, kwargs)
+
+    def __set_name__(self, owner, name):
+        # This is a special method use to supply information to
+        # descriptors about what the name of variable in a class
+        # definition is. Not wanting to add this to ObjectProxy as not
+        # sure of broader implications of doing that. Thus restrict to
+        # FunctionWrapper used by decorators.
+
+        if hasattr(self.__wrapped__, "__set_name__"):
+            self.__wrapped__.__set_name__(owner, name)
+
+    def __instancecheck__(self, instance):
+        # This is a special method used by isinstance() to make checks
+        # instance of the `__wrapped__`.
+        return isinstance(instance, self.__wrapped__)
+
+    def __subclasscheck__(self, subclass):
+        # This is a special method used by issubclass() to make checks
+        # about inheritance of classes. We need to upwrap any object
+        # proxy. Not wanting to add this to ObjectProxy as not sure of
+        # broader implications of doing that. Thus restrict to
+        # FunctionWrapper used by decorators.
+
+        if hasattr(subclass, "__wrapped__"):
+            return issubclass(subclass.__wrapped__, self.__wrapped__)
+        else:
+            return issubclass(subclass, self.__wrapped__)
+
+class BoundFunctionWrapper(_FunctionWrapperBase):
+
+    def __call__(self, *args, **kwargs):
+        # If enabled has been specified, then evaluate it at this point
+        # and if the wrapper is not to be executed, then simply return
+        # the bound function rather than a bound wrapper for the bound
+        # function. When evaluating enabled, if it is callable we call
+        # it, otherwise we evaluate it as a boolean.
+
+        if self._self_enabled is not None:
+            if callable(self._self_enabled):
+                if not self._self_enabled():
+                    return self.__wrapped__(*args, **kwargs)
+            elif not self._self_enabled:
+                return self.__wrapped__(*args, **kwargs)
+
+        # We need to do things different depending on whether we are
+        # likely wrapping an instance method vs a static method or class
+        # method.
+
+        if self._self_binding == 'function':
+            if self._self_instance is None:
+                # This situation can occur where someone is calling the
+                # instancemethod via the class type and passing the instance
+                # as the first argument. We need to shift the args before
+                # making the call to the wrapper and effectively bind the
+                # instance to the wrapped function using a partial so the
+                # wrapper doesn't see anything as being different.
+
+                if not args:
+                    raise TypeError('missing 1 required positional argument')
+
+                instance, args = args[0], args[1:]
+                wrapped = PartialCallableObjectProxy(self.__wrapped__, instance)
+                return self._self_wrapper(wrapped, instance, args, kwargs)
+
+            return self._self_wrapper(self.__wrapped__, self._self_instance,
+                    args, kwargs)
+
+        else:
+            # As in this case we would be dealing with a classmethod or
+            # staticmethod, then _self_instance will only tell us whether
+            # when calling the classmethod or staticmethod they did it via an
+            # instance of the class it is bound to and not the case where
+            # done by the class type itself. We thus ignore _self_instance
+            # and use the __self__ attribute of the bound function instead.
+            # For a classmethod, this means instance will be the class type
+            # and for a staticmethod it will be None. This is probably the
+            # more useful thing we can pass through even though we loose
+            # knowledge of whether they were called on the instance vs the
+            # class type, as it reflects what they have available in the
+            # decoratored function.
+
+            instance = getattr(self.__wrapped__, '__self__', None)
+
+            return self._self_wrapper(self.__wrapped__, instance, args,
+                    kwargs)
+
+class FunctionWrapper(_FunctionWrapperBase):
+
+    __bound_function_wrapper__ = BoundFunctionWrapper
+
+    def __init__(self, wrapped, wrapper, enabled=None):
+        # What it is we are wrapping here could be anything. We need to
+        # try and detect specific cases though. In particular, we need
+        # to detect when we are given something that is a method of a
+        # class. Further, we need to know when it is likely an instance
+        # method, as opposed to a class or static method. This can
+        # become problematic though as there isn't strictly a fool proof
+        # method of knowing.
+        #
+        # The situations we could encounter when wrapping a method are:
+        #
+        # 1. The wrapper is being applied as part of a decorator which
+        # is a part of the class definition. In this case what we are
+        # given is the raw unbound function, classmethod or staticmethod
+        # wrapper objects.
+        #
+        # The problem here is that we will not know we are being applied
+        # in the context of the class being set up. This becomes
+        # important later for the case of an instance method, because in
+        # that case we just see it as a raw function and can't
+        # distinguish it from wrapping a normal function outside of
+        # a class context.
+        #
+        # 2. The wrapper is being applied when performing monkey
+        # patching of the class type afterwards and the method to be
+        # wrapped was retrieved direct from the __dict__ of the class
+        # type. This is effectively the same as (1) above.
+        #
+        # 3. The wrapper is being applied when performing monkey
+        # patching of the class type afterwards and the method to be
+        # wrapped was retrieved from the class type. In this case
+        # binding will have been performed where the instance against
+        # which the method is bound will be None at that point.
+        #
+        # This case is a problem because we can no longer tell if the
+        # method was a static method, plus if using Python3, we cannot
+        # tell if it was an instance method as the concept of an
+        # unnbound method no longer exists.
+        #
+        # 4. The wrapper is being applied when performing monkey
+        # patching of an instance of a class. In this case binding will
+        # have been perfomed where the instance was not None.
+        #
+        # This case is a problem because we can no longer tell if the
+        # method was a static method.
+        #
+        # Overall, the best we can do is look at the original type of the
+        # object which was wrapped prior to any binding being done and
+        # see if it is an instance of classmethod or staticmethod. In
+        # the case where other decorators are between us and them, if
+        # they do not propagate the __class__  attribute so that the
+        # isinstance() checks works, then likely this will do the wrong
+        # thing where classmethod and staticmethod are used.
+        #
+        # Since it is likely to be very rare that anyone even puts
+        # decorators around classmethod and staticmethod, likelihood of
+        # that being an issue is very small, so we accept it and suggest
+        # that those other decorators be fixed. It is also only an issue
+        # if a decorator wants to actually do things with the arguments.
+        #
+        # As to not being able to identify static methods properly, we
+        # just hope that that isn't something people are going to want
+        # to wrap, or if they do suggest they do it the correct way by
+        # ensuring that it is decorated in the class definition itself,
+        # or patch it in the __dict__ of the class type.
+        #
+        # So to get the best outcome we can, whenever we aren't sure what
+        # it is, we label it as a 'function'. If it was already bound and
+        # that is rebound later, we assume that it will be an instance
+        # method and try an cope with the possibility that the 'self'
+        # argument it being passed as an explicit argument and shuffle
+        # the arguments around to extract 'self' for use as the instance.
+
+        if isinstance(wrapped, classmethod):
+            binding = 'classmethod'
+
+        elif isinstance(wrapped, staticmethod):
+            binding = 'staticmethod'
+
+        elif hasattr(wrapped, '__self__'):
+            if inspect.isclass(wrapped.__self__):
+                binding = 'classmethod'
+            else:
+                binding = 'function'
+
+        else:
+            binding = 'function'
+
+        super(FunctionWrapper, self).__init__(wrapped, None, wrapper,
+                enabled, binding)
+
+try:
+    if not os.environ.get('WRAPT_DISABLE_EXTENSIONS'):
+        from ._wrappers import (ObjectProxy, CallableObjectProxy,
+            PartialCallableObjectProxy, FunctionWrapper,
+            BoundFunctionWrapper, _FunctionWrapperBase)
+except ImportError:
+    pass
+
+# Helper functions for applying wrappers to existing functions.
+
+def resolve_path(module, name):
+    if isinstance(module, string_types):
+        __import__(module)
+        module = sys.modules[module]
+
+    parent = module
+
+    path = name.split('.')
+    attribute = path[0]
+
+    # We can't just always use getattr() because in doing
+    # that on a class it will cause binding to occur which
+    # will complicate things later and cause some things not
+    # to work. For the case of a class we therefore access
+    # the __dict__ directly. To cope though with the wrong
+    # class being given to us, or a method being moved into
+    # a base class, we need to walk the class hierarchy to
+    # work out exactly which __dict__ the method was defined
+    # in, as accessing it from __dict__ will fail if it was
+    # not actually on the class given. Fallback to using
+    # getattr() if we can't find it. If it truly doesn't
+    # exist, then that will fail.
+
+    def lookup_attribute(parent, attribute):
+        if inspect.isclass(parent):
+            for cls in inspect.getmro(parent):
+                if attribute in vars(cls):
+                    return vars(cls)[attribute]
+            else:
+                return getattr(parent, attribute)
+        else:
+            return getattr(parent, attribute)
+
+    original = lookup_attribute(parent, attribute)
+
+    for attribute in path[1:]:
+        parent = original
+        original = lookup_attribute(parent, attribute)
+
+    return (parent, attribute, original)
+
+def apply_patch(parent, attribute, replacement):
+    setattr(parent, attribute, replacement)
+
+def wrap_object(module, name, factory, args=(), kwargs={}):
+    (parent, attribute, original) = resolve_path(module, name)
+    wrapper = factory(original, *args, **kwargs)
+    apply_patch(parent, attribute, wrapper)
+    return wrapper
+
+# Function for applying a proxy object to an attribute of a class
+# instance. The wrapper works by defining an attribute of the same name
+# on the class which is a descriptor and which intercepts access to the
+# instance attribute. Note that this cannot be used on attributes which
+# are themselves defined by a property object.
+
+class AttributeWrapper(object):
+
+    def __init__(self, attribute, factory, args, kwargs):
+        self.attribute = attribute
+        self.factory = factory
+        self.args = args
+        self.kwargs = kwargs
+
+    def __get__(self, instance, owner):
+        value = instance.__dict__[self.attribute]
+        return self.factory(value, *self.args, **self.kwargs)
+
+    def __set__(self, instance, value):
+        instance.__dict__[self.attribute] = value
+
+    def __delete__(self, instance):
+        del instance.__dict__[self.attribute]
+
+def wrap_object_attribute(module, name, factory, args=(), kwargs={}):
+    path, attribute = name.rsplit('.', 1)
+    parent = resolve_path(module, path)[2]
+    wrapper = AttributeWrapper(attribute, factory, args, kwargs)
+    apply_patch(parent, attribute, wrapper)
+    return wrapper
+
+# Functions for creating a simple decorator using a FunctionWrapper,
+# plus short cut functions for applying wrappers to functions. These are
+# for use when doing monkey patching. For a more featured way of
+# creating decorators see the decorator decorator instead.
+
+def function_wrapper(wrapper):
+    def _wrapper(wrapped, instance, args, kwargs):
+        target_wrapped = args[0]
+        if instance is None:
+            target_wrapper = wrapper
+        elif inspect.isclass(instance):
+            target_wrapper = wrapper.__get__(None, instance)
+        else:
+            target_wrapper = wrapper.__get__(instance, type(instance))
+        return FunctionWrapper(target_wrapped, target_wrapper)
+    return FunctionWrapper(wrapper, _wrapper)
+
+def wrap_function_wrapper(module, name, wrapper):
+    return wrap_object(module, name, FunctionWrapper, (wrapper,))
+
+def patch_function_wrapper(module, name):
+    def _wrapper(wrapper):
+        return wrap_object(module, name, FunctionWrapper, (wrapper,))
+    return _wrapper
+
+def transient_function_wrapper(module, name):
+    def _decorator(wrapper):
+        def _wrapper(wrapped, instance, args, kwargs):
+            target_wrapped = args[0]
+            if instance is None:
+                target_wrapper = wrapper
+            elif inspect.isclass(instance):
+                target_wrapper = wrapper.__get__(None, instance)
+            else:
+                target_wrapper = wrapper.__get__(instance, type(instance))
+            def _execute(wrapped, instance, args, kwargs):
+                (parent, attribute, original) = resolve_path(module, name)
+                replacement = FunctionWrapper(original, target_wrapper)
+                setattr(parent, attribute, replacement)
+                try:
+                    return wrapped(*args, **kwargs)
+                finally:
+                    setattr(parent, attribute, original)
+            return FunctionWrapper(target_wrapped, _execute)
+        return FunctionWrapper(wrapper, _wrapper)
+    return _decorator
+
+# A weak function proxy. This will work on instance methods, class
+# methods, static methods and regular functions. Special treatment is
+# needed for the method types because the bound method is effectively a
+# transient object and applying a weak reference to one will immediately
+# result in it being destroyed and the weakref callback called. The weak
+# reference is therefore applied to the instance the method is bound to
+# and the original function. The function is then rebound at the point
+# of a call via the weak function proxy.
+
+def _weak_function_proxy_callback(ref, proxy, callback):
+    if proxy._self_expired:
+        return
+
+    proxy._self_expired = True
+
+    # This could raise an exception. We let it propagate back and let
+    # the weakref.proxy() deal with it, at which point it generally
+    # prints out a short error message direct to stderr and keeps going.
+
+    if callback is not None:
+        callback(proxy)
+
+class WeakFunctionProxy(ObjectProxy):
+
+    __slots__ = ('_self_expired', '_self_instance')
+
+    def __init__(self, wrapped, callback=None):
+        # We need to determine if the wrapped function is actually a
+        # bound method. In the case of a bound method, we need to keep a
+        # reference to the original unbound function and the instance.
+        # This is necessary because if we hold a reference to the bound
+        # function, it will be the only reference and given it is a
+        # temporary object, it will almost immediately expire and
+        # the weakref callback triggered. So what is done is that we
+        # hold a reference to the instance and unbound function and
+        # when called bind the function to the instance once again and
+        # then call it. Note that we avoid using a nested function for
+        # the callback here so as not to cause any odd reference cycles.
+
+        _callback = callback and functools.partial(
+                _weak_function_proxy_callback, proxy=self,
+                callback=callback)
+
+        self._self_expired = False
+
+        if isinstance(wrapped, _FunctionWrapperBase):
+            self._self_instance = weakref.ref(wrapped._self_instance,
+                    _callback)
+
+            if wrapped._self_parent is not None:
+                super(WeakFunctionProxy, self).__init__(
+                        weakref.proxy(wrapped._self_parent, _callback))
+
+            else:
+                super(WeakFunctionProxy, self).__init__(
+                        weakref.proxy(wrapped, _callback))
+
+            return
+
+        try:
+            self._self_instance = weakref.ref(wrapped.__self__, _callback)
+
+            super(WeakFunctionProxy, self).__init__(
+                    weakref.proxy(wrapped.__func__, _callback))
+
+        except AttributeError:
+            self._self_instance = None
+
+            super(WeakFunctionProxy, self).__init__(
+                    weakref.proxy(wrapped, _callback))
+
+    def __call__(self, *args, **kwargs):
+        # We perform a boolean check here on the instance and wrapped
+        # function as that will trigger the reference error prior to
+        # calling if the reference had expired.
+
+        instance = self._self_instance and self._self_instance()
+        function = self.__wrapped__ and self.__wrapped__
+
+        # If the wrapped function was originally a bound function, for
+        # which we retained a reference to the instance and the unbound
+        # function we need to rebind the function and then call it. If
+        # not just called the wrapped function.
+
+        if instance is None:
+            return self.__wrapped__(*args, **kwargs)
+
+        return function.__get__(instance, type(instance))(*args, **kwargs)
diff --git a/material/dataset/xpsdeeplearning/tests/data/20240206_Ni_linear_combination_small_gas_phase.h5 b/material/dataset/xpsdeeplearning/tests/data/20240206_Ni_linear_combination_small_gas_phase.h5
new file mode 100644
index 0000000000000000000000000000000000000000..86d2bda0ea15cf2aa47ce2510e95e8401cc51b59
--- /dev/null
+++ b/material/dataset/xpsdeeplearning/tests/data/20240206_Ni_linear_combination_small_gas_phase.h5
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b052306c0b0985ad95bb21800e7cf8c9ae78ce18c027c0a329d5544d6dfa1194
+size 110455