diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/__init__.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dfeffa8fe502313da891297153eeeccd90b32609
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/__init__.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/generate_legacy_storage_files.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/generate_legacy_storage_files.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..78bc4d707d6faa8a3e40cc2d75ac4d75c37e3bd1
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/generate_legacy_storage_files.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_clipboard.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_clipboard.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..06ba51071957b8be42af1ceb4303bbb2554abb9b
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_clipboard.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_common.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_common.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..db12661c1385dcfb61f62314ec4993135c291517
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_common.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_compression.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_compression.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2cfd1da5755b0e4ffd5cba6b209f931f776ca4f0
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_compression.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_feather.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_feather.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4c43c8f125a1eae2b96fcf7b7783ed60bf65658f
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_feather.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_fsspec.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_fsspec.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4964a927879652e1ae248b09aceea7b69d9d3f58
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_fsspec.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_sql.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_sql.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d25083ca403bb485785709bf95100e51dabd1483
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_sql.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_stata.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_stata.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fe373667d6d940d81878bddfcb21cf8837c94022
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/io/__pycache__/test_stata.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/data/fixed_width/fixed_width_format.txt b/videochat2/lib/python3.10/site-packages/pandas/tests/io/data/fixed_width/fixed_width_format.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bb487d8de7ef960a671826ee8b83f49e7fea5d0a
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/io/data/fixed_width/fixed_width_format.txt
@@ -0,0 +1,3 @@
+A B C
+1 2 3
+4 5 6
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/data/gbq_fake_job.txt b/videochat2/lib/python3.10/site-packages/pandas/tests/io/data/gbq_fake_job.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b0995222292e484697745b2d960b85367efd557e
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/io/data/gbq_fake_job.txt
@@ -0,0 +1 @@
+{'status': {'state': 'DONE'}, 'kind': 'bigquery#job', 'statistics': {'query': {'cacheHit': True, 'totalBytesProcessed': '0'}, 'endTime': '1377668744674', 'totalBytesProcessed': '0', 'startTime': '1377668744466'}, 'jobReference': {'projectId': '57288129629', 'jobId': 'bqjob_r5f956972f0190bdf_00000140c374bf42_2'}, 'etag': '"4PTsVxg68bQkQs1RJ1Ndewqkgg4/oO4VmgFrAku4N6FWci9s7iFIftc"', 'configuration': {'query': {'createDisposition': 'CREATE_IF_NEEDED', 'query': 'SELECT * FROM [publicdata:samples.shakespeare]', 'writeDisposition': 'WRITE_TRUNCATE', 'destinationTable': {'projectId': '57288129629', 'tableId': 'anonb5ec450da88eeeb78a27784ea482ee75a146d442', 'datasetId': '_d0b4f5f0d50dc68a3eb0fa6cba66a9a8687d9253'}}}, 'id': '57288129629:bqjob_r5f956972f0190bdf_00000140c374bf42_2', 'selfLink': 'https://www.googleapis.com/bigquery/v2/projects/57288129629/jobs/bqjob_r5f956972f0190bdf_00000140c374bf42_2'}
\ No newline at end of file
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/data/xml/books.xml b/videochat2/lib/python3.10/site-packages/pandas/tests/io/data/xml/books.xml
new file mode 100644
index 0000000000000000000000000000000000000000..666ce60e9a2bea19bedd289815e4cc6afa251a45
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/io/data/xml/books.xml
@@ -0,0 +1,21 @@
+
+
+
+ Everyday Italian
+ Giada De Laurentiis
+ 2005
+ 30.00
+
+
+ Harry Potter
+ J K. Rowling
+ 2005
+ 29.99
+
+
+ Learning XML
+ Erik T. Ray
+ 2003
+ 39.95
+
+
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/formats/style/__pycache__/test_bar.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/io/formats/style/__pycache__/test_bar.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..888183bcf849b256930557bacd90297f69ea1420
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/io/formats/style/__pycache__/test_bar.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/formats/style/__pycache__/test_highlight.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/io/formats/style/__pycache__/test_highlight.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9eb8a2728d1e5bf7494bd2bdc5fffa4d45ccf154
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/io/formats/style/__pycache__/test_highlight.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/formats/style/__pycache__/test_non_unique.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/io/formats/style/__pycache__/test_non_unique.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ec05032af717a66fc849f4bbcce44c83d2efaa2e
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/io/formats/style/__pycache__/test_non_unique.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/formats/style/__pycache__/test_style.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/io/formats/style/__pycache__/test_style.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5b1fe5e99b2bd3dfdfc97e402296ad8e26a360d2
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/io/formats/style/__pycache__/test_style.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/formats/style/__pycache__/test_tooltip.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/io/formats/style/__pycache__/test_tooltip.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..27ab111a0505b418c02e7ea04b1a8857453963e5
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/io/formats/style/__pycache__/test_tooltip.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/__pycache__/__init__.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f34270cd54700d3533752af4ed1df5d93be7bb9f
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/__pycache__/__init__.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/__pycache__/test_python_parser_only.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/__pycache__/test_python_parser_only.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..13100034f6cef6822c996892e8cbf22bc1156718
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/__pycache__/test_python_parser_only.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/__pycache__/test_quoting.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/__pycache__/test_quoting.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3e1006bc5e06410171cde54915d35d0e64bccbfc
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/__pycache__/test_quoting.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/__pycache__/test_unsupported.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/__pycache__/test_unsupported.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d6070fb4cfbd7610e346ad058b4498a2c7d3981e
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/__pycache__/test_unsupported.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/usecols/__init__.py b/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/usecols/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/usecols/__pycache__/test_strings.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/usecols/__pycache__/test_strings.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6ed524c4d4fe6cbd5f2eb8b211b015d2bb9d9cbd
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/usecols/__pycache__/test_strings.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/usecols/__pycache__/test_usecols_basic.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/usecols/__pycache__/test_usecols_basic.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..12569fd08add77ae15862aa14afe5bdd4d2b1e9c
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/usecols/__pycache__/test_usecols_basic.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/usecols/test_parse_dates.py b/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/usecols/test_parse_dates.py
new file mode 100644
index 0000000000000000000000000000000000000000..f818d621c744f0e4360310146cff912f35ff4926
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/usecols/test_parse_dates.py
@@ -0,0 +1,159 @@
+"""
+Tests the usecols functionality during parsing
+for all of the parsers defined in parsers.py
+"""
+from io import StringIO
+
+import pytest
+
+from pandas import (
+ DataFrame,
+ Index,
+ Timestamp,
+)
+import pandas._testing as tm
+
+_msg_validate_usecols_arg = (
+ "'usecols' must either be list-like "
+ "of all strings, all unicode, all "
+ "integers or a callable."
+)
+_msg_validate_usecols_names = (
+ "Usecols do not match columns, columns expected but not found: {0}"
+)
+
+# TODO(1.4): Change these to xfails whenever parse_dates support(which was
+# intentionally disable to keep small PR sizes) is added back
+pytestmark = pytest.mark.usefixtures("pyarrow_skip")
+
+
+@pytest.mark.parametrize("usecols", [[0, 2, 3], [3, 0, 2]])
+def test_usecols_with_parse_dates(all_parsers, usecols):
+ # see gh-9755
+ data = """a,b,c,d,e
+0,1,2014-01-01,09:00,4
+0,1,2014-01-02,10:00,4"""
+ parser = all_parsers
+ parse_dates = [[1, 2]]
+
+ cols = {
+ "a": [0, 0],
+ "c_d": [Timestamp("2014-01-01 09:00:00"), Timestamp("2014-01-02 10:00:00")],
+ }
+ expected = DataFrame(cols, columns=["c_d", "a"])
+ result = parser.read_csv(StringIO(data), usecols=usecols, parse_dates=parse_dates)
+ tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_with_parse_dates2(all_parsers):
+ # see gh-13604
+ parser = all_parsers
+ data = """2008-02-07 09:40,1032.43
+2008-02-07 09:50,1042.54
+2008-02-07 10:00,1051.65"""
+
+ names = ["date", "values"]
+ usecols = names[:]
+ parse_dates = [0]
+
+ index = Index(
+ [
+ Timestamp("2008-02-07 09:40"),
+ Timestamp("2008-02-07 09:50"),
+ Timestamp("2008-02-07 10:00"),
+ ],
+ name="date",
+ )
+ cols = {"values": [1032.43, 1042.54, 1051.65]}
+ expected = DataFrame(cols, index=index)
+
+ result = parser.read_csv(
+ StringIO(data),
+ parse_dates=parse_dates,
+ index_col=0,
+ usecols=usecols,
+ header=None,
+ names=names,
+ )
+ tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_with_parse_dates3(all_parsers):
+ # see gh-14792
+ parser = all_parsers
+ data = """a,b,c,d,e,f,g,h,i,j
+2016/09/21,1,1,2,3,4,5,6,7,8"""
+
+ usecols = list("abcdefghij")
+ parse_dates = [0]
+
+ cols = {
+ "a": Timestamp("2016-09-21"),
+ "b": [1],
+ "c": [1],
+ "d": [2],
+ "e": [3],
+ "f": [4],
+ "g": [5],
+ "h": [6],
+ "i": [7],
+ "j": [8],
+ }
+ expected = DataFrame(cols, columns=usecols)
+
+ result = parser.read_csv(StringIO(data), usecols=usecols, parse_dates=parse_dates)
+ tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_with_parse_dates4(all_parsers):
+ data = "a,b,c,d,e,f,g,h,i,j\n2016/09/21,1,1,2,3,4,5,6,7,8"
+ usecols = list("abcdefghij")
+ parse_dates = [[0, 1]]
+ parser = all_parsers
+
+ cols = {
+ "a_b": "2016/09/21 1",
+ "c": [1],
+ "d": [2],
+ "e": [3],
+ "f": [4],
+ "g": [5],
+ "h": [6],
+ "i": [7],
+ "j": [8],
+ }
+ expected = DataFrame(cols, columns=["a_b"] + list("cdefghij"))
+
+ result = parser.read_csv(
+ StringIO(data),
+ usecols=usecols,
+ parse_dates=parse_dates,
+ )
+ tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("usecols", [[0, 2, 3], [3, 0, 2]])
+@pytest.mark.parametrize(
+ "names",
+ [
+ list("abcde"), # Names span all columns in original data.
+ list("acd"), # Names span only the selected columns.
+ ],
+)
+def test_usecols_with_parse_dates_and_names(all_parsers, usecols, names):
+ # see gh-9755
+ s = """0,1,2014-01-01,09:00,4
+0,1,2014-01-02,10:00,4"""
+ parse_dates = [[1, 2]]
+ parser = all_parsers
+
+ cols = {
+ "a": [0, 0],
+ "c_d": [Timestamp("2014-01-01 09:00:00"), Timestamp("2014-01-02 10:00:00")],
+ }
+ expected = DataFrame(cols, columns=["c_d", "a"])
+
+ result = parser.read_csv(
+ StringIO(s), names=names, parse_dates=parse_dates, usecols=usecols
+ )
+ tm.assert_frame_equal(result, expected)
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/usecols/test_strings.py b/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/usecols/test_strings.py
new file mode 100644
index 0000000000000000000000000000000000000000..8cecf1fc981eefa40c40661fafd2bb70e3c3d7dc
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/usecols/test_strings.py
@@ -0,0 +1,97 @@
+"""
+Tests the usecols functionality during parsing
+for all of the parsers defined in parsers.py
+"""
+from io import StringIO
+
+import pytest
+
+from pandas import DataFrame
+import pandas._testing as tm
+
+_msg_validate_usecols_arg = (
+ "'usecols' must either be list-like "
+ "of all strings, all unicode, all "
+ "integers or a callable."
+)
+_msg_validate_usecols_names = (
+ "Usecols do not match columns, columns expected but not found: {0}"
+)
+
+
+def test_usecols_with_unicode_strings(all_parsers):
+ # see gh-13219
+ data = """AAA,BBB,CCC,DDD
+0.056674973,8,True,a
+2.613230982,2,False,b
+3.568935038,7,False,a"""
+ parser = all_parsers
+
+ exp_data = {
+ "AAA": {
+ 0: 0.056674972999999997,
+ 1: 2.6132309819999997,
+ 2: 3.5689350380000002,
+ },
+ "BBB": {0: 8, 1: 2, 2: 7},
+ }
+ expected = DataFrame(exp_data)
+
+ result = parser.read_csv(StringIO(data), usecols=["AAA", "BBB"])
+ tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_with_single_byte_unicode_strings(all_parsers):
+ # see gh-13219
+ data = """A,B,C,D
+0.056674973,8,True,a
+2.613230982,2,False,b
+3.568935038,7,False,a"""
+ parser = all_parsers
+
+ exp_data = {
+ "A": {
+ 0: 0.056674972999999997,
+ 1: 2.6132309819999997,
+ 2: 3.5689350380000002,
+ },
+ "B": {0: 8, 1: 2, 2: 7},
+ }
+ expected = DataFrame(exp_data)
+
+ result = parser.read_csv(StringIO(data), usecols=["A", "B"])
+ tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("usecols", [["AAA", b"BBB"], [b"AAA", "BBB"]])
+def test_usecols_with_mixed_encoding_strings(all_parsers, usecols):
+ data = """AAA,BBB,CCC,DDD
+0.056674973,8,True,a
+2.613230982,2,False,b
+3.568935038,7,False,a"""
+ parser = all_parsers
+
+ with pytest.raises(ValueError, match=_msg_validate_usecols_arg):
+ parser.read_csv(StringIO(data), usecols=usecols)
+
+
+@pytest.mark.parametrize("usecols", [["あああ", "いい"], ["あああ", "いい"]])
+def test_usecols_with_multi_byte_characters(all_parsers, usecols):
+ data = """あああ,いい,ううう,ええええ
+0.056674973,8,True,a
+2.613230982,2,False,b
+3.568935038,7,False,a"""
+ parser = all_parsers
+
+ exp_data = {
+ "あああ": {
+ 0: 0.056674972999999997,
+ 1: 2.6132309819999997,
+ 2: 3.5689350380000002,
+ },
+ "いい": {0: 8, 1: 2, 2: 7},
+ }
+ expected = DataFrame(exp_data)
+
+ result = parser.read_csv(StringIO(data), usecols=usecols)
+ tm.assert_frame_equal(result, expected)
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/usecols/test_usecols_basic.py b/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/usecols/test_usecols_basic.py
new file mode 100644
index 0000000000000000000000000000000000000000..032cb961103dfda3234331088929053fafac577a
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/io/parser/usecols/test_usecols_basic.py
@@ -0,0 +1,432 @@
+"""
+Tests the usecols functionality during parsing
+for all of the parsers defined in parsers.py
+"""
+from io import StringIO
+
+import numpy as np
+import pytest
+
+from pandas.errors import ParserError
+
+from pandas import (
+ DataFrame,
+ Index,
+)
+import pandas._testing as tm
+
+_msg_validate_usecols_arg = (
+ "'usecols' must either be list-like "
+ "of all strings, all unicode, all "
+ "integers or a callable."
+)
+_msg_validate_usecols_names = (
+ "Usecols do not match columns, columns expected but not found: {0}"
+)
+
+# TODO(1.4): Change to xfails at release time
+pytestmark = pytest.mark.usefixtures("pyarrow_skip")
+
+
+def test_raise_on_mixed_dtype_usecols(all_parsers):
+ # See gh-12678
+ data = """a,b,c
+ 1000,2000,3000
+ 4000,5000,6000
+ """
+ usecols = [0, "b", 2]
+ parser = all_parsers
+
+ with pytest.raises(ValueError, match=_msg_validate_usecols_arg):
+ parser.read_csv(StringIO(data), usecols=usecols)
+
+
+@pytest.mark.parametrize("usecols", [(1, 2), ("b", "c")])
+def test_usecols(all_parsers, usecols):
+ data = """\
+a,b,c
+1,2,3
+4,5,6
+7,8,9
+10,11,12"""
+ parser = all_parsers
+ result = parser.read_csv(StringIO(data), usecols=usecols)
+
+ expected = DataFrame([[2, 3], [5, 6], [8, 9], [11, 12]], columns=["b", "c"])
+ tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_with_names(all_parsers):
+ data = """\
+a,b,c
+1,2,3
+4,5,6
+7,8,9
+10,11,12"""
+ parser = all_parsers
+ names = ["foo", "bar"]
+ result = parser.read_csv(StringIO(data), names=names, usecols=[1, 2], header=0)
+
+ expected = DataFrame([[2, 3], [5, 6], [8, 9], [11, 12]], columns=names)
+ tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+ "names,usecols", [(["b", "c"], [1, 2]), (["a", "b", "c"], ["b", "c"])]
+)
+def test_usecols_relative_to_names(all_parsers, names, usecols):
+ data = """\
+1,2,3
+4,5,6
+7,8,9
+10,11,12"""
+ parser = all_parsers
+ result = parser.read_csv(StringIO(data), names=names, header=None, usecols=usecols)
+
+ expected = DataFrame([[2, 3], [5, 6], [8, 9], [11, 12]], columns=["b", "c"])
+ tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_relative_to_names2(all_parsers):
+ # see gh-5766
+ data = """\
+1,2,3
+4,5,6
+7,8,9
+10,11,12"""
+ parser = all_parsers
+ result = parser.read_csv(
+ StringIO(data), names=["a", "b"], header=None, usecols=[0, 1]
+ )
+
+ expected = DataFrame([[1, 2], [4, 5], [7, 8], [10, 11]], columns=["a", "b"])
+ tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_name_length_conflict(all_parsers):
+ data = """\
+1,2,3
+4,5,6
+7,8,9
+10,11,12"""
+ parser = all_parsers
+ msg = "Number of passed names did not match number of header fields in the file"
+
+ with pytest.raises(ValueError, match=msg):
+ parser.read_csv(StringIO(data), names=["a", "b"], header=None, usecols=[1])
+
+
+def test_usecols_single_string(all_parsers):
+ # see gh-20558
+ parser = all_parsers
+ data = """foo, bar, baz
+1000, 2000, 3000
+4000, 5000, 6000"""
+
+ with pytest.raises(ValueError, match=_msg_validate_usecols_arg):
+ parser.read_csv(StringIO(data), usecols="foo")
+
+
+@pytest.mark.parametrize(
+ "data", ["a,b,c,d\n1,2,3,4\n5,6,7,8", "a,b,c,d\n1,2,3,4,\n5,6,7,8,"]
+)
+def test_usecols_index_col_false(all_parsers, data):
+ # see gh-9082
+ parser = all_parsers
+ usecols = ["a", "c", "d"]
+ expected = DataFrame({"a": [1, 5], "c": [3, 7], "d": [4, 8]})
+
+ result = parser.read_csv(StringIO(data), usecols=usecols, index_col=False)
+ tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("index_col", ["b", 0])
+@pytest.mark.parametrize("usecols", [["b", "c"], [1, 2]])
+def test_usecols_index_col_conflict(all_parsers, usecols, index_col):
+ # see gh-4201: test that index_col as integer reflects usecols
+ parser = all_parsers
+ data = "a,b,c,d\nA,a,1,one\nB,b,2,two"
+ expected = DataFrame({"c": [1, 2]}, index=Index(["a", "b"], name="b"))
+
+ result = parser.read_csv(StringIO(data), usecols=usecols, index_col=index_col)
+ tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_index_col_conflict2(all_parsers):
+ # see gh-4201: test that index_col as integer reflects usecols
+ parser = all_parsers
+ data = "a,b,c,d\nA,a,1,one\nB,b,2,two"
+
+ expected = DataFrame({"b": ["a", "b"], "c": [1, 2], "d": ("one", "two")})
+ expected = expected.set_index(["b", "c"])
+
+ result = parser.read_csv(
+ StringIO(data), usecols=["b", "c", "d"], index_col=["b", "c"]
+ )
+ tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_implicit_index_col(all_parsers):
+ # see gh-2654
+ parser = all_parsers
+ data = "a,b,c\n4,apple,bat,5.7\n8,orange,cow,10"
+
+ result = parser.read_csv(StringIO(data), usecols=["a", "b"])
+ expected = DataFrame({"a": ["apple", "orange"], "b": ["bat", "cow"]}, index=[4, 8])
+ tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_index_col_middle(all_parsers):
+ # GH#9098
+ parser = all_parsers
+ data = """a,b,c,d
+1,2,3,4
+"""
+ result = parser.read_csv(StringIO(data), usecols=["b", "c", "d"], index_col="c")
+ expected = DataFrame({"b": [2], "d": [4]}, index=Index([3], name="c"))
+ tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_index_col_end(all_parsers):
+ # GH#9098
+ parser = all_parsers
+ data = """a,b,c,d
+1,2,3,4
+"""
+ result = parser.read_csv(StringIO(data), usecols=["b", "c", "d"], index_col="d")
+ expected = DataFrame({"b": [2], "c": [3]}, index=Index([4], name="d"))
+ tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_regex_sep(all_parsers):
+ # see gh-2733
+ parser = all_parsers
+ data = "a b c\n4 apple bat 5.7\n8 orange cow 10"
+ result = parser.read_csv(StringIO(data), sep=r"\s+", usecols=("a", "b"))
+
+ expected = DataFrame({"a": ["apple", "orange"], "b": ["bat", "cow"]}, index=[4, 8])
+ tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_with_whitespace(all_parsers):
+ parser = all_parsers
+ data = "a b c\n4 apple bat 5.7\n8 orange cow 10"
+
+ result = parser.read_csv(StringIO(data), delim_whitespace=True, usecols=("a", "b"))
+ expected = DataFrame({"a": ["apple", "orange"], "b": ["bat", "cow"]}, index=[4, 8])
+ tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+ "usecols,expected",
+ [
+ # Column selection by index.
+ ([0, 1], DataFrame(data=[[1000, 2000], [4000, 5000]], columns=["2", "0"])),
+ # Column selection by name.
+ (
+ ["0", "1"],
+ DataFrame(data=[[2000, 3000], [5000, 6000]], columns=["0", "1"]),
+ ),
+ ],
+)
+def test_usecols_with_integer_like_header(all_parsers, usecols, expected):
+ parser = all_parsers
+ data = """2,0,1
+1000,2000,3000
+4000,5000,6000"""
+
+ result = parser.read_csv(StringIO(data), usecols=usecols)
+ tm.assert_frame_equal(result, expected)
+
+
+def test_empty_usecols(all_parsers):
+ data = "a,b,c\n1,2,3\n4,5,6"
+ expected = DataFrame(columns=Index([]))
+ parser = all_parsers
+
+ result = parser.read_csv(StringIO(data), usecols=set())
+ tm.assert_frame_equal(result, expected)
+
+
+def test_np_array_usecols(all_parsers):
+ # see gh-12546
+ parser = all_parsers
+ data = "a,b,c\n1,2,3"
+ usecols = np.array(["a", "b"])
+
+ expected = DataFrame([[1, 2]], columns=usecols)
+ result = parser.read_csv(StringIO(data), usecols=usecols)
+ tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+ "usecols,expected",
+ [
+ (
+ lambda x: x.upper() in ["AAA", "BBB", "DDD"],
+ DataFrame(
+ {
+ "AaA": {
+ 0: 0.056674972999999997,
+ 1: 2.6132309819999997,
+ 2: 3.5689350380000002,
+ },
+ "bBb": {0: 8, 1: 2, 2: 7},
+ "ddd": {0: "a", 1: "b", 2: "a"},
+ }
+ ),
+ ),
+ (lambda x: False, DataFrame(columns=Index([]))),
+ ],
+)
+def test_callable_usecols(all_parsers, usecols, expected):
+ # see gh-14154
+ data = """AaA,bBb,CCC,ddd
+0.056674973,8,True,a
+2.613230982,2,False,b
+3.568935038,7,False,a"""
+ parser = all_parsers
+
+ result = parser.read_csv(StringIO(data), usecols=usecols)
+ tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("usecols", [["a", "c"], lambda x: x in ["a", "c"]])
+def test_incomplete_first_row(all_parsers, usecols):
+ # see gh-6710
+ data = "1,2\n1,2,3"
+ parser = all_parsers
+ names = ["a", "b", "c"]
+ expected = DataFrame({"a": [1, 1], "c": [np.nan, 3]})
+
+ result = parser.read_csv(StringIO(data), names=names, usecols=usecols)
+ tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+ "data,usecols,kwargs,expected",
+ [
+ # see gh-8985
+ (
+ "19,29,39\n" * 2 + "10,20,30,40",
+ [0, 1, 2],
+ {"header": None},
+ DataFrame([[19, 29, 39], [19, 29, 39], [10, 20, 30]]),
+ ),
+ # see gh-9549
+ (
+ ("A,B,C\n1,2,3\n3,4,5\n1,2,4,5,1,6\n1,2,3,,,1,\n1,2,3\n5,6,7"),
+ ["A", "B", "C"],
+ {},
+ DataFrame(
+ {
+ "A": [1, 3, 1, 1, 1, 5],
+ "B": [2, 4, 2, 2, 2, 6],
+ "C": [3, 5, 4, 3, 3, 7],
+ }
+ ),
+ ),
+ ],
+)
+def test_uneven_length_cols(all_parsers, data, usecols, kwargs, expected):
+ # see gh-8985
+ parser = all_parsers
+ result = parser.read_csv(StringIO(data), usecols=usecols, **kwargs)
+ tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+ "usecols,kwargs,expected,msg",
+ [
+ (
+ ["a", "b", "c", "d"],
+ {},
+ DataFrame({"a": [1, 5], "b": [2, 6], "c": [3, 7], "d": [4, 8]}),
+ None,
+ ),
+ (
+ ["a", "b", "c", "f"],
+ {},
+ None,
+ _msg_validate_usecols_names.format(r"\['f'\]"),
+ ),
+ (["a", "b", "f"], {}, None, _msg_validate_usecols_names.format(r"\['f'\]")),
+ (
+ ["a", "b", "f", "g"],
+ {},
+ None,
+ _msg_validate_usecols_names.format(r"\[('f', 'g'|'g', 'f')\]"),
+ ),
+ # see gh-14671
+ (
+ None,
+ {"header": 0, "names": ["A", "B", "C", "D"]},
+ DataFrame({"A": [1, 5], "B": [2, 6], "C": [3, 7], "D": [4, 8]}),
+ None,
+ ),
+ (
+ ["A", "B", "C", "f"],
+ {"header": 0, "names": ["A", "B", "C", "D"]},
+ None,
+ _msg_validate_usecols_names.format(r"\['f'\]"),
+ ),
+ (
+ ["A", "B", "f"],
+ {"names": ["A", "B", "C", "D"]},
+ None,
+ _msg_validate_usecols_names.format(r"\['f'\]"),
+ ),
+ ],
+)
+def test_raises_on_usecols_names_mismatch(all_parsers, usecols, kwargs, expected, msg):
+ data = "a,b,c,d\n1,2,3,4\n5,6,7,8"
+ kwargs.update(usecols=usecols)
+ parser = all_parsers
+
+ if expected is None:
+ with pytest.raises(ValueError, match=msg):
+ parser.read_csv(StringIO(data), **kwargs)
+ else:
+ result = parser.read_csv(StringIO(data), **kwargs)
+ tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("usecols", [["A", "C"], [0, 2]])
+def test_usecols_subset_names_mismatch_orig_columns(all_parsers, usecols):
+ data = "a,b,c,d\n1,2,3,4\n5,6,7,8"
+ names = ["A", "B", "C", "D"]
+ parser = all_parsers
+
+ result = parser.read_csv(StringIO(data), header=0, names=names, usecols=usecols)
+ expected = DataFrame({"A": [1, 5], "C": [3, 7]})
+ tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("names", [None, ["a", "b"]])
+def test_usecols_indices_out_of_bounds(all_parsers, names):
+ # GH#25623 & GH 41130; enforced in 2.0
+ parser = all_parsers
+ data = """
+a,b
+1,2
+ """
+ with pytest.raises(ParserError, match="Defining usecols without of bounds"):
+ parser.read_csv(StringIO(data), usecols=[0, 2], names=names, header=0)
+
+
+def test_usecols_additional_columns(all_parsers):
+ # GH#46997
+ parser = all_parsers
+ usecols = lambda header: header.strip() in ["a", "b", "c"]
+ result = parser.read_csv(StringIO("a,b\nx,y,z"), index_col=False, usecols=usecols)
+ expected = DataFrame({"a": ["x"], "b": "y"})
+ tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_additional_columns_integer_columns(all_parsers):
+ # GH#46997
+ parser = all_parsers
+ usecols = lambda header: header.strip() in ["0", "1"]
+ result = parser.read_csv(StringIO("0,1\nx,y,z"), index_col=False, usecols=usecols)
+ expected = DataFrame({"0": ["x"], "1": "y"})
+ tm.assert_frame_equal(result, expected)
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/__init__.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_attr_equal.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_attr_equal.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b508939c3d339faaa04263b4a4f202cdb3320b4f
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_attr_equal.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_extension_array_equal.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_extension_array_equal.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b3aabd5818f625d7d0201f8ea330a996821367f9
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_extension_array_equal.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_frame_equal.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_frame_equal.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7300e452103d5ceccfd4993920dfc39fee4cf4af
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_frame_equal.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_index_equal.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_index_equal.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..679e960a473a95e352faa210de94a1c2aa7fa641
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_index_equal.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_interval_array_equal.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_interval_array_equal.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3807e6abde0acb122f1ba1d1dad3546fbdfb9c60
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_interval_array_equal.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_numpy_array_equal.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_numpy_array_equal.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e21536b26c941c972dee4a3edf3afee561dd9bd2
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_numpy_array_equal.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_produces_warning.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_produces_warning.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5959521573d56dfeb4ced1cab36f6c41c5a95b1e
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_produces_warning.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_series_equal.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_series_equal.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ab36b8ad9138257295f47bc1b0c38b8cfea703f9
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_series_equal.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_deprecate.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_deprecate.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b569c1c4d766426b058f13a2a52e38ba9e394da8
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_deprecate.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_deprecate_kwarg.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_deprecate_kwarg.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..151c92fe98eea77ce0802743ddbda0d280a9b2fb
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_deprecate_kwarg.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_doc.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_doc.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4151c81be5289234372797e5ab8ebe46e6af4733
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_doc.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_hashing.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_hashing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..73c0c196a1ca8c0a8e9600f5173629539d5b03a0
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_hashing.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_make_objects.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_make_objects.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d92b5476a250b8c1d360b52a4d6fe21ec02fcba1
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_make_objects.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_numba.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_numba.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cdb31e37badc91ec74eb91fc499de0b9b2d14220
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_numba.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_rewrite_warning.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_rewrite_warning.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ee04eb43e2950942ae25a714359f42d06971ab04
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_rewrite_warning.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_show_versions.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_show_versions.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0af641bc5527180e4a10d699e1398ee54abc6ef7
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_show_versions.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_str_methods.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_str_methods.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ed469f716d1e861845bae6810b41e14fd59a16c2
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_str_methods.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_validate_args_and_kwargs.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_validate_args_and_kwargs.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e1f262ffaefd8e83219bb43d8801c6f28c9c215e
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_validate_args_and_kwargs.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_validate_inclusive.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_validate_inclusive.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2cdc05003c8f2987f7db2d44a7702b3a14bdb2e5
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_validate_inclusive.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/conftest.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..b68bcc93431d015a5b9bdc47bdd7e46dd531b703
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/conftest.py
@@ -0,0 +1,26 @@
+import pytest
+
+
+@pytest.fixture(params=[True, False])
+def check_dtype(request):
+ return request.param
+
+
+@pytest.fixture(params=[True, False])
+def check_exact(request):
+ return request.param
+
+
+@pytest.fixture(params=[True, False])
+def check_index_type(request):
+ return request.param
+
+
+@pytest.fixture(params=[0.5e-3, 0.5e-5])
+def rtol(request):
+ return request.param
+
+
+@pytest.fixture(params=[True, False])
+def check_categorical(request):
+ return request.param
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_almost_equal.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_almost_equal.py
new file mode 100644
index 0000000000000000000000000000000000000000..987af3ee1e78ef728abe8bcff8a08c8359816e52
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_almost_equal.py
@@ -0,0 +1,533 @@
+import numpy as np
+import pytest
+
+from pandas import (
+ DataFrame,
+ Index,
+ Series,
+ Timestamp,
+)
+import pandas._testing as tm
+
+
+def _assert_almost_equal_both(a, b, **kwargs):
+ """
+ Check that two objects are approximately equal.
+
+ This check is performed commutatively.
+
+ Parameters
+ ----------
+ a : object
+ The first object to compare.
+ b : object
+ The second object to compare.
+ **kwargs
+ The arguments passed to `tm.assert_almost_equal`.
+ """
+ tm.assert_almost_equal(a, b, **kwargs)
+ tm.assert_almost_equal(b, a, **kwargs)
+
+
+def _assert_not_almost_equal(a, b, **kwargs):
+ """
+ Check that two objects are not approximately equal.
+
+ Parameters
+ ----------
+ a : object
+ The first object to compare.
+ b : object
+ The second object to compare.
+ **kwargs
+ The arguments passed to `tm.assert_almost_equal`.
+ """
+ try:
+ tm.assert_almost_equal(a, b, **kwargs)
+ msg = f"{a} and {b} were approximately equal when they shouldn't have been"
+ pytest.fail(msg=msg)
+ except AssertionError:
+ pass
+
+
+def _assert_not_almost_equal_both(a, b, **kwargs):
+ """
+ Check that two objects are not approximately equal.
+
+ This check is performed commutatively.
+
+ Parameters
+ ----------
+ a : object
+ The first object to compare.
+ b : object
+ The second object to compare.
+ **kwargs
+ The arguments passed to `tm.assert_almost_equal`.
+ """
+ _assert_not_almost_equal(a, b, **kwargs)
+ _assert_not_almost_equal(b, a, **kwargs)
+
+
+@pytest.mark.parametrize(
+ "a,b",
+ [
+ (1.1, 1.1),
+ (1.1, 1.100001),
+ (np.int16(1), 1.000001),
+ (np.float64(1.1), 1.1),
+ (np.uint32(5), 5),
+ ],
+)
+def test_assert_almost_equal_numbers(a, b):
+ _assert_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize(
+ "a,b",
+ [
+ (1.1, 1),
+ (1.1, True),
+ (1, 2),
+ (1.0001, np.int16(1)),
+ # The following two examples are not "almost equal" due to tol.
+ (0.1, 0.1001),
+ (0.0011, 0.0012),
+ ],
+)
+def test_assert_not_almost_equal_numbers(a, b):
+ _assert_not_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize(
+ "a,b",
+ [
+ (1.1, 1.1),
+ (1.1, 1.100001),
+ (1.1, 1.1001),
+ (0.000001, 0.000005),
+ (1000.0, 1000.0005),
+ # Testing this example, as per #13357
+ (0.000011, 0.000012),
+ ],
+)
+def test_assert_almost_equal_numbers_atol(a, b):
+ # Equivalent to the deprecated check_less_precise=True, enforced in 2.0
+ _assert_almost_equal_both(a, b, rtol=0.5e-3, atol=0.5e-3)
+
+
+@pytest.mark.parametrize("a,b", [(1.1, 1.11), (0.1, 0.101), (0.000011, 0.001012)])
+def test_assert_not_almost_equal_numbers_atol(a, b):
+ _assert_not_almost_equal_both(a, b, atol=1e-3)
+
+
+@pytest.mark.parametrize(
+ "a,b",
+ [
+ (1.1, 1.1),
+ (1.1, 1.100001),
+ (1.1, 1.1001),
+ (1000.0, 1000.0005),
+ (1.1, 1.11),
+ (0.1, 0.101),
+ ],
+)
+def test_assert_almost_equal_numbers_rtol(a, b):
+ _assert_almost_equal_both(a, b, rtol=0.05)
+
+
+@pytest.mark.parametrize("a,b", [(0.000011, 0.000012), (0.000001, 0.000005)])
+def test_assert_not_almost_equal_numbers_rtol(a, b):
+ _assert_not_almost_equal_both(a, b, rtol=0.05)
+
+
+@pytest.mark.parametrize(
+ "a,b,rtol",
+ [
+ (1.00001, 1.00005, 0.001),
+ (-0.908356 + 0.2j, -0.908358 + 0.2j, 1e-3),
+ (0.1 + 1.009j, 0.1 + 1.006j, 0.1),
+ (0.1001 + 2.0j, 0.1 + 2.001j, 0.01),
+ ],
+)
+def test_assert_almost_equal_complex_numbers(a, b, rtol):
+ _assert_almost_equal_both(a, b, rtol=rtol)
+ _assert_almost_equal_both(np.complex64(a), np.complex64(b), rtol=rtol)
+ _assert_almost_equal_both(np.complex128(a), np.complex128(b), rtol=rtol)
+
+
+@pytest.mark.parametrize(
+ "a,b,rtol",
+ [
+ (0.58310768, 0.58330768, 1e-7),
+ (-0.908 + 0.2j, -0.978 + 0.2j, 0.001),
+ (0.1 + 1j, 0.1 + 2j, 0.01),
+ (-0.132 + 1.001j, -0.132 + 1.005j, 1e-5),
+ (0.58310768j, 0.58330768j, 1e-9),
+ ],
+)
+def test_assert_not_almost_equal_complex_numbers(a, b, rtol):
+ _assert_not_almost_equal_both(a, b, rtol=rtol)
+ _assert_not_almost_equal_both(np.complex64(a), np.complex64(b), rtol=rtol)
+ _assert_not_almost_equal_both(np.complex128(a), np.complex128(b), rtol=rtol)
+
+
+@pytest.mark.parametrize("a,b", [(0, 0), (0, 0.0), (0, np.float64(0)), (0.00000001, 0)])
+def test_assert_almost_equal_numbers_with_zeros(a, b):
+ _assert_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize("a,b", [(0.001, 0), (1, 0)])
+def test_assert_not_almost_equal_numbers_with_zeros(a, b):
+ _assert_not_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize("a,b", [(1, "abc"), (1, [1]), (1, object())])
+def test_assert_not_almost_equal_numbers_with_mixed(a, b):
+ _assert_not_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize(
+ "left_dtype", ["M8[ns]", "m8[ns]", "float64", "int64", "object"]
+)
+@pytest.mark.parametrize(
+ "right_dtype", ["M8[ns]", "m8[ns]", "float64", "int64", "object"]
+)
+def test_assert_almost_equal_edge_case_ndarrays(left_dtype, right_dtype):
+ # Empty compare.
+ _assert_almost_equal_both(
+ np.array([], dtype=left_dtype),
+ np.array([], dtype=right_dtype),
+ check_dtype=False,
+ )
+
+
+def test_assert_almost_equal_dicts():
+ _assert_almost_equal_both({"a": 1, "b": 2}, {"a": 1, "b": 2})
+
+
+@pytest.mark.parametrize(
+ "a,b",
+ [
+ ({"a": 1, "b": 2}, {"a": 1, "b": 3}),
+ ({"a": 1, "b": 2}, {"a": 1, "b": 2, "c": 3}),
+ ({"a": 1}, 1),
+ ({"a": 1}, "abc"),
+ ({"a": 1}, [1]),
+ ],
+)
+def test_assert_not_almost_equal_dicts(a, b):
+ _assert_not_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize("val", [1, 2])
+def test_assert_almost_equal_dict_like_object(val):
+ dict_val = 1
+ real_dict = {"a": val}
+
+ class DictLikeObj:
+ def keys(self):
+ return ("a",)
+
+ def __getitem__(self, item):
+ if item == "a":
+ return dict_val
+
+ func = (
+ _assert_almost_equal_both if val == dict_val else _assert_not_almost_equal_both
+ )
+ func(real_dict, DictLikeObj(), check_dtype=False)
+
+
+def test_assert_almost_equal_strings():
+ _assert_almost_equal_both("abc", "abc")
+
+
+@pytest.mark.parametrize(
+ "a,b", [("abc", "abcd"), ("abc", "abd"), ("abc", 1), ("abc", [1])]
+)
+def test_assert_not_almost_equal_strings(a, b):
+ _assert_not_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize(
+ "a,b", [([1, 2, 3], [1, 2, 3]), (np.array([1, 2, 3]), np.array([1, 2, 3]))]
+)
+def test_assert_almost_equal_iterables(a, b):
+ _assert_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize(
+ "a,b",
+ [
+ # Class is different.
+ (np.array([1, 2, 3]), [1, 2, 3]),
+ # Dtype is different.
+ (np.array([1, 2, 3]), np.array([1.0, 2.0, 3.0])),
+ # Can't compare generators.
+ (iter([1, 2, 3]), [1, 2, 3]),
+ ([1, 2, 3], [1, 2, 4]),
+ ([1, 2, 3], [1, 2, 3, 4]),
+ ([1, 2, 3], 1),
+ ],
+)
+def test_assert_not_almost_equal_iterables(a, b):
+ _assert_not_almost_equal(a, b)
+
+
+def test_assert_almost_equal_null():
+ _assert_almost_equal_both(None, None)
+
+
+@pytest.mark.parametrize("a,b", [(None, np.NaN), (None, 0), (np.NaN, 0)])
+def test_assert_not_almost_equal_null(a, b):
+ _assert_not_almost_equal(a, b)
+
+
+@pytest.mark.parametrize(
+ "a,b",
+ [
+ (np.inf, np.inf),
+ (np.inf, float("inf")),
+ (np.array([np.inf, np.nan, -np.inf]), np.array([np.inf, np.nan, -np.inf])),
+ (
+ np.array([np.inf, None, -np.inf], dtype=np.object_),
+ np.array([np.inf, np.nan, -np.inf], dtype=np.object_),
+ ),
+ ],
+)
+def test_assert_almost_equal_inf(a, b):
+ _assert_almost_equal_both(a, b)
+
+
+def test_assert_not_almost_equal_inf():
+ _assert_not_almost_equal_both(np.inf, 0)
+
+
+@pytest.mark.parametrize(
+ "a,b",
+ [
+ (Index([1.0, 1.1]), Index([1.0, 1.100001])),
+ (Series([1.0, 1.1]), Series([1.0, 1.100001])),
+ (np.array([1.1, 2.000001]), np.array([1.1, 2.0])),
+ (DataFrame({"a": [1.0, 1.1]}), DataFrame({"a": [1.0, 1.100001]})),
+ ],
+)
+def test_assert_almost_equal_pandas(a, b):
+ _assert_almost_equal_both(a, b)
+
+
+def test_assert_almost_equal_object():
+ a = [Timestamp("2011-01-01"), Timestamp("2011-01-01")]
+ b = [Timestamp("2011-01-01"), Timestamp("2011-01-01")]
+ _assert_almost_equal_both(a, b)
+
+
+def test_assert_almost_equal_value_mismatch():
+ msg = "expected 2\\.00000 but got 1\\.00000, with rtol=1e-05, atol=1e-08"
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_almost_equal(1, 2)
+
+
+@pytest.mark.parametrize(
+ "a,b,klass1,klass2",
+ [(np.array([1]), 1, "ndarray", "int"), (1, np.array([1]), "int", "ndarray")],
+)
+def test_assert_almost_equal_class_mismatch(a, b, klass1, klass2):
+ msg = f"""numpy array are different
+
+numpy array classes are different
+\\[left\\]: {klass1}
+\\[right\\]: {klass2}"""
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_almost_equal(a, b)
+
+
+def test_assert_almost_equal_value_mismatch1():
+ msg = """numpy array are different
+
+numpy array values are different \\(66\\.66667 %\\)
+\\[left\\]: \\[nan, 2\\.0, 3\\.0\\]
+\\[right\\]: \\[1\\.0, nan, 3\\.0\\]"""
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_almost_equal(np.array([np.nan, 2, 3]), np.array([1, np.nan, 3]))
+
+
+def test_assert_almost_equal_value_mismatch2():
+ msg = """numpy array are different
+
+numpy array values are different \\(50\\.0 %\\)
+\\[left\\]: \\[1, 2\\]
+\\[right\\]: \\[1, 3\\]"""
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_almost_equal(np.array([1, 2]), np.array([1, 3]))
+
+
+def test_assert_almost_equal_value_mismatch3():
+ msg = """numpy array are different
+
+numpy array values are different \\(16\\.66667 %\\)
+\\[left\\]: \\[\\[1, 2\\], \\[3, 4\\], \\[5, 6\\]\\]
+\\[right\\]: \\[\\[1, 3\\], \\[3, 4\\], \\[5, 6\\]\\]"""
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_almost_equal(
+ np.array([[1, 2], [3, 4], [5, 6]]), np.array([[1, 3], [3, 4], [5, 6]])
+ )
+
+
+def test_assert_almost_equal_value_mismatch4():
+ msg = """numpy array are different
+
+numpy array values are different \\(25\\.0 %\\)
+\\[left\\]: \\[\\[1, 2\\], \\[3, 4\\]\\]
+\\[right\\]: \\[\\[1, 3\\], \\[3, 4\\]\\]"""
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_almost_equal(np.array([[1, 2], [3, 4]]), np.array([[1, 3], [3, 4]]))
+
+
+def test_assert_almost_equal_shape_mismatch_override():
+ msg = """Index are different
+
+Index shapes are different
+\\[left\\]: \\(2L*,\\)
+\\[right\\]: \\(3L*,\\)"""
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_almost_equal(np.array([1, 2]), np.array([3, 4, 5]), obj="Index")
+
+
+def test_assert_almost_equal_unicode():
+ # see gh-20503
+ msg = """numpy array are different
+
+numpy array values are different \\(33\\.33333 %\\)
+\\[left\\]: \\[á, à, ä\\]
+\\[right\\]: \\[á, à, å\\]"""
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_almost_equal(np.array(["á", "à", "ä"]), np.array(["á", "à", "å"]))
+
+
+def test_assert_almost_equal_timestamp():
+ a = np.array([Timestamp("2011-01-01"), Timestamp("2011-01-01")])
+ b = np.array([Timestamp("2011-01-01"), Timestamp("2011-01-02")])
+
+ msg = """numpy array are different
+
+numpy array values are different \\(50\\.0 %\\)
+\\[left\\]: \\[2011-01-01 00:00:00, 2011-01-01 00:00:00\\]
+\\[right\\]: \\[2011-01-01 00:00:00, 2011-01-02 00:00:00\\]"""
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_almost_equal(a, b)
+
+
+def test_assert_almost_equal_iterable_length_mismatch():
+ msg = """Iterable are different
+
+Iterable length are different
+\\[left\\]: 2
+\\[right\\]: 3"""
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_almost_equal([1, 2], [3, 4, 5])
+
+
+def test_assert_almost_equal_iterable_values_mismatch():
+ msg = """Iterable are different
+
+Iterable values are different \\(50\\.0 %\\)
+\\[left\\]: \\[1, 2\\]
+\\[right\\]: \\[1, 3\\]"""
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_almost_equal([1, 2], [1, 3])
+
+
+subarr = np.empty(2, dtype=object)
+subarr[:] = [np.array([None, "b"], dtype=object), np.array(["c", "d"], dtype=object)]
+
+NESTED_CASES = [
+ # nested array
+ (
+ np.array([np.array([50, 70, 90]), np.array([20, 30])], dtype=object),
+ np.array([np.array([50, 70, 90]), np.array([20, 30])], dtype=object),
+ ),
+ # >1 level of nesting
+ (
+ np.array(
+ [
+ np.array([np.array([50, 70]), np.array([90])], dtype=object),
+ np.array([np.array([20, 30])], dtype=object),
+ ],
+ dtype=object,
+ ),
+ np.array(
+ [
+ np.array([np.array([50, 70]), np.array([90])], dtype=object),
+ np.array([np.array([20, 30])], dtype=object),
+ ],
+ dtype=object,
+ ),
+ ),
+ # lists
+ (
+ np.array([[50, 70, 90], [20, 30]], dtype=object),
+ np.array([[50, 70, 90], [20, 30]], dtype=object),
+ ),
+ # mixed array/list
+ (
+ np.array([np.array([1, 2, 3]), np.array([4, 5])], dtype=object),
+ np.array([[1, 2, 3], [4, 5]], dtype=object),
+ ),
+ (
+ np.array(
+ [
+ np.array([np.array([1, 2, 3]), np.array([4, 5])], dtype=object),
+ np.array(
+ [np.array([6]), np.array([7, 8]), np.array([9])], dtype=object
+ ),
+ ],
+ dtype=object,
+ ),
+ np.array([[[1, 2, 3], [4, 5]], [[6], [7, 8], [9]]], dtype=object),
+ ),
+ # same-length lists
+ (
+ np.array([subarr, None], dtype=object),
+ np.array([list([[None, "b"], ["c", "d"]]), None], dtype=object),
+ ),
+ # dicts
+ (
+ np.array([{"f1": 1, "f2": np.array(["a", "b"], dtype=object)}], dtype=object),
+ np.array([{"f1": 1, "f2": np.array(["a", "b"], dtype=object)}], dtype=object),
+ ),
+ (
+ np.array([{"f1": 1, "f2": np.array(["a", "b"], dtype=object)}], dtype=object),
+ np.array([{"f1": 1, "f2": ["a", "b"]}], dtype=object),
+ ),
+ # array/list of dicts
+ (
+ np.array(
+ [
+ np.array(
+ [{"f1": 1, "f2": np.array(["a", "b"], dtype=object)}], dtype=object
+ ),
+ np.array([], dtype=object),
+ ],
+ dtype=object,
+ ),
+ np.array([[{"f1": 1, "f2": ["a", "b"]}], []], dtype=object),
+ ),
+]
+
+
+@pytest.mark.filterwarnings("ignore:elementwise comparison failed:DeprecationWarning")
+@pytest.mark.parametrize("a,b", NESTED_CASES)
+def test_assert_almost_equal_array_nested(a, b):
+ _assert_almost_equal_both(a, b)
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_attr_equal.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_attr_equal.py
new file mode 100644
index 0000000000000000000000000000000000000000..bbbb0bf2172b12f93c9f0f6a97751854d1566a99
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_attr_equal.py
@@ -0,0 +1,33 @@
+from types import SimpleNamespace
+
+import pytest
+
+from pandas.core.dtypes.common import is_float
+
+import pandas._testing as tm
+
+
+def test_assert_attr_equal(nulls_fixture):
+ obj = SimpleNamespace()
+ obj.na_value = nulls_fixture
+ tm.assert_attr_equal("na_value", obj, obj)
+
+
+def test_assert_attr_equal_different_nulls(nulls_fixture, nulls_fixture2):
+ obj = SimpleNamespace()
+ obj.na_value = nulls_fixture
+
+ obj2 = SimpleNamespace()
+ obj2.na_value = nulls_fixture2
+
+ if nulls_fixture is nulls_fixture2:
+ tm.assert_attr_equal("na_value", obj, obj2)
+ elif is_float(nulls_fixture) and is_float(nulls_fixture2):
+ # we consider float("nan") and np.float64("nan") to be equivalent
+ tm.assert_attr_equal("na_value", obj, obj2)
+ elif type(nulls_fixture) is type(nulls_fixture2):
+ # e.g. Decimal("NaN")
+ tm.assert_attr_equal("na_value", obj, obj2)
+ else:
+ with pytest.raises(AssertionError, match='"na_value" are different'):
+ tm.assert_attr_equal("na_value", obj, obj2)
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_categorical_equal.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_categorical_equal.py
new file mode 100644
index 0000000000000000000000000000000000000000..d07bbcbc460a19ec943c1f8727e25835803cf0e4
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_categorical_equal.py
@@ -0,0 +1,90 @@
+import pytest
+
+from pandas import Categorical
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+ "c",
+ [Categorical([1, 2, 3, 4]), Categorical([1, 2, 3, 4], categories=[1, 2, 3, 4, 5])],
+)
+def test_categorical_equal(c):
+ tm.assert_categorical_equal(c, c)
+
+
+@pytest.mark.parametrize("check_category_order", [True, False])
+def test_categorical_equal_order_mismatch(check_category_order):
+ c1 = Categorical([1, 2, 3, 4], categories=[1, 2, 3, 4])
+ c2 = Categorical([1, 2, 3, 4], categories=[4, 3, 2, 1])
+ kwargs = {"check_category_order": check_category_order}
+
+ if check_category_order:
+ msg = """Categorical\\.categories are different
+
+Categorical\\.categories values are different \\(100\\.0 %\\)
+\\[left\\]: Index\\(\\[1, 2, 3, 4\\], dtype='int64'\\)
+\\[right\\]: Index\\(\\[4, 3, 2, 1\\], dtype='int64'\\)"""
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_categorical_equal(c1, c2, **kwargs)
+ else:
+ tm.assert_categorical_equal(c1, c2, **kwargs)
+
+
+def test_categorical_equal_categories_mismatch():
+ msg = """Categorical\\.categories are different
+
+Categorical\\.categories values are different \\(25\\.0 %\\)
+\\[left\\]: Index\\(\\[1, 2, 3, 4\\], dtype='int64'\\)
+\\[right\\]: Index\\(\\[1, 2, 3, 5\\], dtype='int64'\\)"""
+
+ c1 = Categorical([1, 2, 3, 4])
+ c2 = Categorical([1, 2, 3, 5])
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_categorical_equal(c1, c2)
+
+
+def test_categorical_equal_codes_mismatch():
+ categories = [1, 2, 3, 4]
+ msg = """Categorical\\.codes are different
+
+Categorical\\.codes values are different \\(50\\.0 %\\)
+\\[left\\]: \\[0, 1, 3, 2\\]
+\\[right\\]: \\[0, 1, 2, 3\\]"""
+
+ c1 = Categorical([1, 2, 4, 3], categories=categories)
+ c2 = Categorical([1, 2, 3, 4], categories=categories)
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_categorical_equal(c1, c2)
+
+
+def test_categorical_equal_ordered_mismatch():
+ data = [1, 2, 3, 4]
+ msg = """Categorical are different
+
+Attribute "ordered" are different
+\\[left\\]: False
+\\[right\\]: True"""
+
+ c1 = Categorical(data, ordered=False)
+ c2 = Categorical(data, ordered=True)
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_categorical_equal(c1, c2)
+
+
+@pytest.mark.parametrize("obj", ["index", "foo", "pandas"])
+def test_categorical_equal_object_override(obj):
+ data = [1, 2, 3, 4]
+ msg = f"""{obj} are different
+
+Attribute "ordered" are different
+\\[left\\]: False
+\\[right\\]: True"""
+
+ c1 = Categorical(data, ordered=False)
+ c2 = Categorical(data, ordered=True)
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_categorical_equal(c1, c2, obj=obj)
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_extension_array_equal.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_extension_array_equal.py
new file mode 100644
index 0000000000000000000000000000000000000000..dec10e5b768949aff40edc70a222343eeb9d64dd
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_extension_array_equal.py
@@ -0,0 +1,113 @@
+import numpy as np
+import pytest
+
+from pandas import array
+import pandas._testing as tm
+from pandas.core.arrays.sparse import SparseArray
+
+
+@pytest.mark.parametrize(
+ "kwargs",
+ [
+ {}, # Default is check_exact=False
+ {"check_exact": False},
+ {"check_exact": True},
+ ],
+)
+def test_assert_extension_array_equal_not_exact(kwargs):
+ # see gh-23709
+ arr1 = SparseArray([-0.17387645482451206, 0.3414148016424936])
+ arr2 = SparseArray([-0.17387645482451206, 0.3414148016424937])
+
+ if kwargs.get("check_exact", False):
+ msg = """\
+ExtensionArray are different
+
+ExtensionArray values are different \\(50\\.0 %\\)
+\\[left\\]: \\[-0\\.17387645482.*, 0\\.341414801642.*\\]
+\\[right\\]: \\[-0\\.17387645482.*, 0\\.341414801642.*\\]"""
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_extension_array_equal(arr1, arr2, **kwargs)
+ else:
+ tm.assert_extension_array_equal(arr1, arr2, **kwargs)
+
+
+@pytest.mark.parametrize("decimals", range(10))
+def test_assert_extension_array_equal_less_precise(decimals):
+ rtol = 0.5 * 10**-decimals
+ arr1 = SparseArray([0.5, 0.123456])
+ arr2 = SparseArray([0.5, 0.123457])
+
+ if decimals >= 5:
+ msg = """\
+ExtensionArray are different
+
+ExtensionArray values are different \\(50\\.0 %\\)
+\\[left\\]: \\[0\\.5, 0\\.123456\\]
+\\[right\\]: \\[0\\.5, 0\\.123457\\]"""
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_extension_array_equal(arr1, arr2, rtol=rtol)
+ else:
+ tm.assert_extension_array_equal(arr1, arr2, rtol=rtol)
+
+
+def test_assert_extension_array_equal_dtype_mismatch(check_dtype):
+ end = 5
+ kwargs = {"check_dtype": check_dtype}
+
+ arr1 = SparseArray(np.arange(end, dtype="int64"))
+ arr2 = SparseArray(np.arange(end, dtype="int32"))
+
+ if check_dtype:
+ msg = """\
+ExtensionArray are different
+
+Attribute "dtype" are different
+\\[left\\]: Sparse\\[int64, 0\\]
+\\[right\\]: Sparse\\[int32, 0\\]"""
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_extension_array_equal(arr1, arr2, **kwargs)
+ else:
+ tm.assert_extension_array_equal(arr1, arr2, **kwargs)
+
+
+def test_assert_extension_array_equal_missing_values():
+ arr1 = SparseArray([np.nan, 1, 2, np.nan])
+ arr2 = SparseArray([np.nan, 1, 2, 3])
+
+ msg = """\
+ExtensionArray NA mask are different
+
+ExtensionArray NA mask values are different \\(25\\.0 %\\)
+\\[left\\]: \\[True, False, False, True\\]
+\\[right\\]: \\[True, False, False, False\\]"""
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_extension_array_equal(arr1, arr2)
+
+
+@pytest.mark.parametrize("side", ["left", "right"])
+def test_assert_extension_array_equal_non_extension_array(side):
+ numpy_array = np.arange(5)
+ extension_array = SparseArray(numpy_array)
+
+ msg = f"{side} is not an ExtensionArray"
+ args = (
+ (numpy_array, extension_array)
+ if side == "left"
+ else (extension_array, numpy_array)
+ )
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_extension_array_equal(*args)
+
+
+@pytest.mark.parametrize("right_dtype", ["Int32", "int64"])
+def test_assert_extension_array_equal_ignore_dtype_mismatch(right_dtype):
+ # https://github.com/pandas-dev/pandas/issues/35715
+ left = array([1, 2, 3], dtype="Int64")
+ right = array([1, 2, 3], dtype=right_dtype)
+ tm.assert_extension_array_equal(left, right, check_dtype=False)
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_frame_equal.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_frame_equal.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6e29e243b0c869e9676da0a91da84dd1b2c28ce
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_frame_equal.py
@@ -0,0 +1,364 @@
+import pytest
+
+import pandas as pd
+from pandas import DataFrame
+import pandas._testing as tm
+
+
+@pytest.fixture(params=[True, False])
+def by_blocks_fixture(request):
+ return request.param
+
+
+@pytest.fixture(params=["DataFrame", "Series"])
+def obj_fixture(request):
+ return request.param
+
+
+def _assert_frame_equal_both(a, b, **kwargs):
+ """
+ Check that two DataFrame equal.
+
+ This check is performed commutatively.
+
+ Parameters
+ ----------
+ a : DataFrame
+ The first DataFrame to compare.
+ b : DataFrame
+ The second DataFrame to compare.
+ kwargs : dict
+ The arguments passed to `tm.assert_frame_equal`.
+ """
+ tm.assert_frame_equal(a, b, **kwargs)
+ tm.assert_frame_equal(b, a, **kwargs)
+
+
+@pytest.mark.parametrize("check_like", [True, False])
+def test_frame_equal_row_order_mismatch(check_like, obj_fixture):
+ df1 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["a", "b", "c"])
+ df2 = DataFrame({"A": [3, 2, 1], "B": [6, 5, 4]}, index=["c", "b", "a"])
+
+ if not check_like: # Do not ignore row-column orderings.
+ msg = f"{obj_fixture}.index are different"
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_frame_equal(df1, df2, check_like=check_like, obj=obj_fixture)
+ else:
+ _assert_frame_equal_both(df1, df2, check_like=check_like, obj=obj_fixture)
+
+
+@pytest.mark.parametrize(
+ "df1,df2",
+ [
+ (DataFrame({"A": [1, 2, 3]}), DataFrame({"A": [1, 2, 3, 4]})),
+ (DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}), DataFrame({"A": [1, 2, 3]})),
+ ],
+)
+def test_frame_equal_shape_mismatch(df1, df2, obj_fixture):
+ msg = f"{obj_fixture} are different"
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_frame_equal(df1, df2, obj=obj_fixture)
+
+
+@pytest.mark.parametrize(
+ "df1,df2,msg",
+ [
+ # Index
+ (
+ DataFrame.from_records({"a": [1, 2], "c": ["l1", "l2"]}, index=["a"]),
+ DataFrame.from_records({"a": [1.0, 2.0], "c": ["l1", "l2"]}, index=["a"]),
+ "DataFrame\\.index are different",
+ ),
+ # MultiIndex
+ (
+ DataFrame.from_records(
+ {"a": [1, 2], "b": [2.1, 1.5], "c": ["l1", "l2"]}, index=["a", "b"]
+ ),
+ DataFrame.from_records(
+ {"a": [1.0, 2.0], "b": [2.1, 1.5], "c": ["l1", "l2"]}, index=["a", "b"]
+ ),
+ "MultiIndex level \\[0\\] are different",
+ ),
+ ],
+)
+def test_frame_equal_index_dtype_mismatch(df1, df2, msg, check_index_type):
+ kwargs = {"check_index_type": check_index_type}
+
+ if check_index_type:
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_frame_equal(df1, df2, **kwargs)
+ else:
+ tm.assert_frame_equal(df1, df2, **kwargs)
+
+
+def test_empty_dtypes(check_dtype):
+ columns = ["col1", "col2"]
+ df1 = DataFrame(columns=columns)
+ df2 = DataFrame(columns=columns)
+
+ kwargs = {"check_dtype": check_dtype}
+ df1["col1"] = df1["col1"].astype("int64")
+
+ if check_dtype:
+ msg = r"Attributes of DataFrame\..* are different"
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_frame_equal(df1, df2, **kwargs)
+ else:
+ tm.assert_frame_equal(df1, df2, **kwargs)
+
+
+@pytest.mark.parametrize("check_like", [True, False])
+def test_frame_equal_index_mismatch(check_like, obj_fixture):
+ msg = f"""{obj_fixture}\\.index are different
+
+{obj_fixture}\\.index values are different \\(33\\.33333 %\\)
+\\[left\\]: Index\\(\\['a', 'b', 'c'\\], dtype='object'\\)
+\\[right\\]: Index\\(\\['a', 'b', 'd'\\], dtype='object'\\)
+At positional index 2, first diff: c != d"""
+
+ df1 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["a", "b", "c"])
+ df2 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["a", "b", "d"])
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_frame_equal(df1, df2, check_like=check_like, obj=obj_fixture)
+
+
+@pytest.mark.parametrize("check_like", [True, False])
+def test_frame_equal_columns_mismatch(check_like, obj_fixture):
+ msg = f"""{obj_fixture}\\.columns are different
+
+{obj_fixture}\\.columns values are different \\(50\\.0 %\\)
+\\[left\\]: Index\\(\\['A', 'B'\\], dtype='object'\\)
+\\[right\\]: Index\\(\\['A', 'b'\\], dtype='object'\\)"""
+
+ df1 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["a", "b", "c"])
+ df2 = DataFrame({"A": [1, 2, 3], "b": [4, 5, 6]}, index=["a", "b", "c"])
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_frame_equal(df1, df2, check_like=check_like, obj=obj_fixture)
+
+
+def test_frame_equal_block_mismatch(by_blocks_fixture, obj_fixture):
+ obj = obj_fixture
+ msg = f"""{obj}\\.iloc\\[:, 1\\] \\(column name="B"\\) are different
+
+{obj}\\.iloc\\[:, 1\\] \\(column name="B"\\) values are different \\(33\\.33333 %\\)
+\\[index\\]: \\[0, 1, 2\\]
+\\[left\\]: \\[4, 5, 6\\]
+\\[right\\]: \\[4, 5, 7\\]"""
+
+ df1 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+ df2 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 7]})
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_frame_equal(df1, df2, by_blocks=by_blocks_fixture, obj=obj_fixture)
+
+
+@pytest.mark.parametrize(
+ "df1,df2,msg",
+ [
+ (
+ DataFrame({"A": ["á", "à", "ä"], "E": ["é", "è", "ë"]}),
+ DataFrame({"A": ["á", "à", "ä"], "E": ["é", "è", "e̊"]}),
+ """{obj}\\.iloc\\[:, 1\\] \\(column name="E"\\) are different
+
+{obj}\\.iloc\\[:, 1\\] \\(column name="E"\\) values are different \\(33\\.33333 %\\)
+\\[index\\]: \\[0, 1, 2\\]
+\\[left\\]: \\[é, è, ë\\]
+\\[right\\]: \\[é, è, e̊\\]""",
+ ),
+ (
+ DataFrame({"A": ["á", "à", "ä"], "E": ["é", "è", "ë"]}),
+ DataFrame({"A": ["a", "a", "a"], "E": ["e", "e", "e"]}),
+ """{obj}\\.iloc\\[:, 0\\] \\(column name="A"\\) are different
+
+{obj}\\.iloc\\[:, 0\\] \\(column name="A"\\) values are different \\(100\\.0 %\\)
+\\[index\\]: \\[0, 1, 2\\]
+\\[left\\]: \\[á, à, ä\\]
+\\[right\\]: \\[a, a, a\\]""",
+ ),
+ ],
+)
+def test_frame_equal_unicode(df1, df2, msg, by_blocks_fixture, obj_fixture):
+ # see gh-20503
+ #
+ # Test ensures that `tm.assert_frame_equals` raises the right exception
+ # when comparing DataFrames containing differing unicode objects.
+ msg = msg.format(obj=obj_fixture)
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_frame_equal(df1, df2, by_blocks=by_blocks_fixture, obj=obj_fixture)
+
+
+def test_assert_frame_equal_extension_dtype_mismatch():
+ # https://github.com/pandas-dev/pandas/issues/32747
+ left = DataFrame({"a": [1, 2, 3]}, dtype="Int64")
+ right = left.astype(int)
+
+ msg = (
+ "Attributes of DataFrame\\.iloc\\[:, 0\\] "
+ '\\(column name="a"\\) are different\n\n'
+ 'Attribute "dtype" are different\n'
+ "\\[left\\]: Int64\n"
+ "\\[right\\]: int[32|64]"
+ )
+
+ tm.assert_frame_equal(left, right, check_dtype=False)
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_frame_equal(left, right, check_dtype=True)
+
+
+def test_assert_frame_equal_interval_dtype_mismatch():
+ # https://github.com/pandas-dev/pandas/issues/32747
+ left = DataFrame({"a": [pd.Interval(0, 1)]}, dtype="interval")
+ right = left.astype(object)
+
+ msg = (
+ "Attributes of DataFrame\\.iloc\\[:, 0\\] "
+ '\\(column name="a"\\) are different\n\n'
+ 'Attribute "dtype" are different\n'
+ "\\[left\\]: interval\\[int64, right\\]\n"
+ "\\[right\\]: object"
+ )
+
+ tm.assert_frame_equal(left, right, check_dtype=False)
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_frame_equal(left, right, check_dtype=True)
+
+
+@pytest.mark.parametrize("right_dtype", ["Int32", "int64"])
+def test_assert_frame_equal_ignore_extension_dtype_mismatch(right_dtype):
+ # https://github.com/pandas-dev/pandas/issues/35715
+ left = DataFrame({"a": [1, 2, 3]}, dtype="Int64")
+ right = DataFrame({"a": [1, 2, 3]}, dtype=right_dtype)
+ tm.assert_frame_equal(left, right, check_dtype=False)
+
+
+@pytest.mark.parametrize(
+ "dtype",
+ [
+ ("timedelta64[ns]"),
+ ("datetime64[ns, UTC]"),
+ ("Period[D]"),
+ ],
+)
+def test_assert_frame_equal_datetime_like_dtype_mismatch(dtype):
+ df1 = DataFrame({"a": []}, dtype=dtype)
+ df2 = DataFrame({"a": []})
+ tm.assert_frame_equal(df1, df2, check_dtype=False)
+
+
+def test_allows_duplicate_labels():
+ left = DataFrame()
+ right = DataFrame().set_flags(allows_duplicate_labels=False)
+ tm.assert_frame_equal(left, left)
+ tm.assert_frame_equal(right, right)
+ tm.assert_frame_equal(left, right, check_flags=False)
+ tm.assert_frame_equal(right, left, check_flags=False)
+
+ with pytest.raises(AssertionError, match="\\]"""
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_numpy_array_equal(a, b)
+
+
+def test_numpy_array_equal_identical_na(nulls_fixture):
+ a = np.array([nulls_fixture], dtype=object)
+
+ tm.assert_numpy_array_equal(a, a)
+
+ # matching but not the identical object
+ if hasattr(nulls_fixture, "copy"):
+ other = nulls_fixture.copy()
+ else:
+ other = copy.copy(nulls_fixture)
+ b = np.array([other], dtype=object)
+ tm.assert_numpy_array_equal(a, b)
+
+
+def test_numpy_array_equal_different_na():
+ a = np.array([np.nan], dtype=object)
+ b = np.array([pd.NA], dtype=object)
+
+ msg = """numpy array are different
+
+numpy array values are different \\(100.0 %\\)
+\\[left\\]: \\[nan\\]
+\\[right\\]: \\[\\]"""
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_numpy_array_equal(a, b)
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_produces_warning.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_produces_warning.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c27a3ee79d4a82bce83eec56ab9d88e10dc06cd
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_produces_warning.py
@@ -0,0 +1,241 @@
+""""
+Test module for testing ``pandas._testing.assert_produces_warning``.
+"""
+import warnings
+
+import pytest
+
+from pandas.errors import (
+ DtypeWarning,
+ PerformanceWarning,
+)
+
+import pandas._testing as tm
+
+
+@pytest.fixture(
+ params=[
+ RuntimeWarning,
+ ResourceWarning,
+ UserWarning,
+ FutureWarning,
+ DeprecationWarning,
+ PerformanceWarning,
+ DtypeWarning,
+ ],
+)
+def category(request):
+ """
+ Return unique warning.
+
+ Useful for testing behavior of tm.assert_produces_warning with various categories.
+ """
+ return request.param
+
+
+@pytest.fixture(
+ params=[
+ (RuntimeWarning, UserWarning),
+ (UserWarning, FutureWarning),
+ (FutureWarning, RuntimeWarning),
+ (DeprecationWarning, PerformanceWarning),
+ (PerformanceWarning, FutureWarning),
+ (DtypeWarning, DeprecationWarning),
+ (ResourceWarning, DeprecationWarning),
+ (FutureWarning, DeprecationWarning),
+ ],
+ ids=lambda x: type(x).__name__,
+)
+def pair_different_warnings(request):
+ """
+ Return pair or different warnings.
+
+ Useful for testing how several different warnings are handled
+ in tm.assert_produces_warning.
+ """
+ return request.param
+
+
+def f():
+ warnings.warn("f1", FutureWarning)
+ warnings.warn("f2", RuntimeWarning)
+
+
+@pytest.mark.filterwarnings("ignore:f1:FutureWarning")
+def test_assert_produces_warning_honors_filter():
+ # Raise by default.
+ msg = r"Caused unexpected warning\(s\)"
+ with pytest.raises(AssertionError, match=msg):
+ with tm.assert_produces_warning(RuntimeWarning):
+ f()
+
+ with tm.assert_produces_warning(RuntimeWarning, raise_on_extra_warnings=False):
+ f()
+
+
+@pytest.mark.parametrize(
+ "message, match",
+ [
+ ("", None),
+ ("", ""),
+ ("Warning message", r".*"),
+ ("Warning message", "War"),
+ ("Warning message", r"[Ww]arning"),
+ ("Warning message", "age"),
+ ("Warning message", r"age$"),
+ ("Message 12-234 with numbers", r"\d{2}-\d{3}"),
+ ("Message 12-234 with numbers", r"^Mes.*\d{2}-\d{3}"),
+ ("Message 12-234 with numbers", r"\d{2}-\d{3}\s\S+"),
+ ("Message, which we do not match", None),
+ ],
+)
+def test_catch_warning_category_and_match(category, message, match):
+ with tm.assert_produces_warning(category, match=match):
+ warnings.warn(message, category)
+
+
+def test_fail_to_match_runtime_warning():
+ category = RuntimeWarning
+ match = "Did not see this warning"
+ unmatched = (
+ r"Did not see warning 'RuntimeWarning' matching 'Did not see this warning'. "
+ r"The emitted warning messages are "
+ r"\[RuntimeWarning\('This is not a match.'\), "
+ r"RuntimeWarning\('Another unmatched warning.'\)\]"
+ )
+ with pytest.raises(AssertionError, match=unmatched):
+ with tm.assert_produces_warning(category, match=match):
+ warnings.warn("This is not a match.", category)
+ warnings.warn("Another unmatched warning.", category)
+
+
+def test_fail_to_match_future_warning():
+ category = FutureWarning
+ match = "Warning"
+ unmatched = (
+ r"Did not see warning 'FutureWarning' matching 'Warning'. "
+ r"The emitted warning messages are "
+ r"\[FutureWarning\('This is not a match.'\), "
+ r"FutureWarning\('Another unmatched warning.'\)\]"
+ )
+ with pytest.raises(AssertionError, match=unmatched):
+ with tm.assert_produces_warning(category, match=match):
+ warnings.warn("This is not a match.", category)
+ warnings.warn("Another unmatched warning.", category)
+
+
+def test_fail_to_match_resource_warning():
+ category = ResourceWarning
+ match = r"\d+"
+ unmatched = (
+ r"Did not see warning 'ResourceWarning' matching '\\d\+'. "
+ r"The emitted warning messages are "
+ r"\[ResourceWarning\('This is not a match.'\), "
+ r"ResourceWarning\('Another unmatched warning.'\)\]"
+ )
+ with pytest.raises(AssertionError, match=unmatched):
+ with tm.assert_produces_warning(category, match=match):
+ warnings.warn("This is not a match.", category)
+ warnings.warn("Another unmatched warning.", category)
+
+
+def test_fail_to_catch_actual_warning(pair_different_warnings):
+ expected_category, actual_category = pair_different_warnings
+ match = "Did not see expected warning of class"
+ with pytest.raises(AssertionError, match=match):
+ with tm.assert_produces_warning(expected_category):
+ warnings.warn("warning message", actual_category)
+
+
+def test_ignore_extra_warning(pair_different_warnings):
+ expected_category, extra_category = pair_different_warnings
+ with tm.assert_produces_warning(expected_category, raise_on_extra_warnings=False):
+ warnings.warn("Expected warning", expected_category)
+ warnings.warn("Unexpected warning OK", extra_category)
+
+
+def test_raise_on_extra_warning(pair_different_warnings):
+ expected_category, extra_category = pair_different_warnings
+ match = r"Caused unexpected warning\(s\)"
+ with pytest.raises(AssertionError, match=match):
+ with tm.assert_produces_warning(expected_category):
+ warnings.warn("Expected warning", expected_category)
+ warnings.warn("Unexpected warning NOT OK", extra_category)
+
+
+def test_same_category_different_messages_first_match():
+ category = UserWarning
+ with tm.assert_produces_warning(category, match=r"^Match this"):
+ warnings.warn("Match this", category)
+ warnings.warn("Do not match that", category)
+ warnings.warn("Do not match that either", category)
+
+
+def test_same_category_different_messages_last_match():
+ category = DeprecationWarning
+ with tm.assert_produces_warning(category, match=r"^Match this"):
+ warnings.warn("Do not match that", category)
+ warnings.warn("Do not match that either", category)
+ warnings.warn("Match this", category)
+
+
+def test_match_multiple_warnings():
+ # https://github.com/pandas-dev/pandas/issues/47829
+ category = (FutureWarning, UserWarning)
+ with tm.assert_produces_warning(category, match=r"^Match this"):
+ warnings.warn("Match this", FutureWarning)
+ warnings.warn("Match this too", UserWarning)
+
+
+def test_right_category_wrong_match_raises(pair_different_warnings):
+ target_category, other_category = pair_different_warnings
+ with pytest.raises(AssertionError, match="Did not see warning.*matching"):
+ with tm.assert_produces_warning(target_category, match=r"^Match this"):
+ warnings.warn("Do not match it", target_category)
+ warnings.warn("Match this", other_category)
+
+
+@pytest.mark.parametrize("false_or_none", [False, None])
+class TestFalseOrNoneExpectedWarning:
+ def test_raise_on_warning(self, false_or_none):
+ msg = r"Caused unexpected warning\(s\)"
+ with pytest.raises(AssertionError, match=msg):
+ with tm.assert_produces_warning(false_or_none):
+ f()
+
+ def test_no_raise_without_warning(self, false_or_none):
+ with tm.assert_produces_warning(false_or_none):
+ pass
+
+ def test_no_raise_with_false_raise_on_extra(self, false_or_none):
+ with tm.assert_produces_warning(false_or_none, raise_on_extra_warnings=False):
+ f()
+
+
+def test_raises_during_exception():
+ msg = "Did not see expected warning of class 'UserWarning'"
+ with pytest.raises(AssertionError, match=msg):
+ with tm.assert_produces_warning(UserWarning):
+ raise ValueError
+
+ with pytest.raises(AssertionError, match=msg):
+ with tm.assert_produces_warning(UserWarning):
+ warnings.warn("FutureWarning", FutureWarning)
+ raise IndexError
+
+ msg = "Caused unexpected warning"
+ with pytest.raises(AssertionError, match=msg):
+ with tm.assert_produces_warning(None):
+ warnings.warn("FutureWarning", FutureWarning)
+ raise SystemError
+
+
+def test_passes_during_exception():
+ with pytest.raises(SyntaxError, match="Error"):
+ with tm.assert_produces_warning(None):
+ raise SyntaxError("Error")
+
+ with pytest.raises(ValueError, match="Error"):
+ with tm.assert_produces_warning(FutureWarning, match="FutureWarning"):
+ warnings.warn("FutureWarning", FutureWarning)
+ raise ValueError("Error")
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_series_equal.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_series_equal.py
new file mode 100644
index 0000000000000000000000000000000000000000..82f5b2fcc6ae78194a857cab10716f0f4bad4392
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_assert_series_equal.py
@@ -0,0 +1,424 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+ Categorical,
+ DataFrame,
+ Series,
+)
+import pandas._testing as tm
+
+
+def _assert_series_equal_both(a, b, **kwargs):
+ """
+ Check that two Series equal.
+
+ This check is performed commutatively.
+
+ Parameters
+ ----------
+ a : Series
+ The first Series to compare.
+ b : Series
+ The second Series to compare.
+ kwargs : dict
+ The arguments passed to `tm.assert_series_equal`.
+ """
+ tm.assert_series_equal(a, b, **kwargs)
+ tm.assert_series_equal(b, a, **kwargs)
+
+
+def _assert_not_series_equal(a, b, **kwargs):
+ """
+ Check that two Series are not equal.
+
+ Parameters
+ ----------
+ a : Series
+ The first Series to compare.
+ b : Series
+ The second Series to compare.
+ kwargs : dict
+ The arguments passed to `tm.assert_series_equal`.
+ """
+ try:
+ tm.assert_series_equal(a, b, **kwargs)
+ msg = "The two Series were equal when they shouldn't have been"
+
+ pytest.fail(msg=msg)
+ except AssertionError:
+ pass
+
+
+def _assert_not_series_equal_both(a, b, **kwargs):
+ """
+ Check that two Series are not equal.
+
+ This check is performed commutatively.
+
+ Parameters
+ ----------
+ a : Series
+ The first Series to compare.
+ b : Series
+ The second Series to compare.
+ kwargs : dict
+ The arguments passed to `tm.assert_series_equal`.
+ """
+ _assert_not_series_equal(a, b, **kwargs)
+ _assert_not_series_equal(b, a, **kwargs)
+
+
+@pytest.mark.parametrize("data", [range(3), list("abc"), list("áàä")])
+def test_series_equal(data):
+ _assert_series_equal_both(Series(data), Series(data))
+
+
+@pytest.mark.parametrize(
+ "data1,data2",
+ [
+ (range(3), range(1, 4)),
+ (list("abc"), list("xyz")),
+ (list("áàä"), list("éèë")),
+ (list("áàä"), list(b"aaa")),
+ (range(3), range(4)),
+ ],
+)
+def test_series_not_equal_value_mismatch(data1, data2):
+ _assert_not_series_equal_both(Series(data1), Series(data2))
+
+
+@pytest.mark.parametrize(
+ "kwargs",
+ [
+ {"dtype": "float64"}, # dtype mismatch
+ {"index": [1, 2, 4]}, # index mismatch
+ {"name": "foo"}, # name mismatch
+ ],
+)
+def test_series_not_equal_metadata_mismatch(kwargs):
+ data = range(3)
+ s1 = Series(data)
+
+ s2 = Series(data, **kwargs)
+ _assert_not_series_equal_both(s1, s2)
+
+
+@pytest.mark.parametrize("data1,data2", [(0.12345, 0.12346), (0.1235, 0.1236)])
+@pytest.mark.parametrize("dtype", ["float32", "float64", "Float32"])
+@pytest.mark.parametrize("decimals", [0, 1, 2, 3, 5, 10])
+def test_less_precise(data1, data2, dtype, decimals):
+ rtol = 10**-decimals
+ s1 = Series([data1], dtype=dtype)
+ s2 = Series([data2], dtype=dtype)
+
+ if decimals in (5, 10) or (decimals >= 3 and abs(data1 - data2) >= 0.0005):
+ msg = "Series values are different"
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_series_equal(s1, s2, rtol=rtol)
+ else:
+ _assert_series_equal_both(s1, s2, rtol=rtol)
+
+
+@pytest.mark.parametrize(
+ "s1,s2,msg",
+ [
+ # Index
+ (
+ Series(["l1", "l2"], index=[1, 2]),
+ Series(["l1", "l2"], index=[1.0, 2.0]),
+ "Series\\.index are different",
+ ),
+ # MultiIndex
+ (
+ DataFrame.from_records(
+ {"a": [1, 2], "b": [2.1, 1.5], "c": ["l1", "l2"]}, index=["a", "b"]
+ ).c,
+ DataFrame.from_records(
+ {"a": [1.0, 2.0], "b": [2.1, 1.5], "c": ["l1", "l2"]}, index=["a", "b"]
+ ).c,
+ "MultiIndex level \\[0\\] are different",
+ ),
+ ],
+)
+def test_series_equal_index_dtype(s1, s2, msg, check_index_type):
+ kwargs = {"check_index_type": check_index_type}
+
+ if check_index_type:
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_series_equal(s1, s2, **kwargs)
+ else:
+ tm.assert_series_equal(s1, s2, **kwargs)
+
+
+@pytest.mark.parametrize("check_like", [True, False])
+def test_series_equal_order_mismatch(check_like):
+ s1 = Series([1, 2, 3], index=["a", "b", "c"])
+ s2 = Series([3, 2, 1], index=["c", "b", "a"])
+
+ if not check_like: # Do not ignore index ordering.
+ with pytest.raises(AssertionError, match="Series.index are different"):
+ tm.assert_series_equal(s1, s2, check_like=check_like)
+ else:
+ _assert_series_equal_both(s1, s2, check_like=check_like)
+
+
+@pytest.mark.parametrize("check_index", [True, False])
+def test_series_equal_index_mismatch(check_index):
+ s1 = Series([1, 2, 3], index=["a", "b", "c"])
+ s2 = Series([1, 2, 3], index=["c", "b", "a"])
+
+ if check_index: # Do not ignore index.
+ with pytest.raises(AssertionError, match="Series.index are different"):
+ tm.assert_series_equal(s1, s2, check_index=check_index)
+ else:
+ _assert_series_equal_both(s1, s2, check_index=check_index)
+
+
+def test_series_invalid_param_combination():
+ left = Series(dtype=object)
+ right = Series(dtype=object)
+ with pytest.raises(
+ ValueError, match="check_like must be False if check_index is False"
+ ):
+ tm.assert_series_equal(left, right, check_index=False, check_like=True)
+
+
+def test_series_equal_length_mismatch(rtol):
+ msg = """Series are different
+
+Series length are different
+\\[left\\]: 3, RangeIndex\\(start=0, stop=3, step=1\\)
+\\[right\\]: 4, RangeIndex\\(start=0, stop=4, step=1\\)"""
+
+ s1 = Series([1, 2, 3])
+ s2 = Series([1, 2, 3, 4])
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_series_equal(s1, s2, rtol=rtol)
+
+
+def test_series_equal_numeric_values_mismatch(rtol):
+ msg = """Series are different
+
+Series values are different \\(33\\.33333 %\\)
+\\[index\\]: \\[0, 1, 2\\]
+\\[left\\]: \\[1, 2, 3\\]
+\\[right\\]: \\[1, 2, 4\\]"""
+
+ s1 = Series([1, 2, 3])
+ s2 = Series([1, 2, 4])
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_series_equal(s1, s2, rtol=rtol)
+
+
+def test_series_equal_categorical_values_mismatch(rtol):
+ msg = """Series are different
+
+Series values are different \\(66\\.66667 %\\)
+\\[index\\]: \\[0, 1, 2\\]
+\\[left\\]: \\['a', 'b', 'c'\\]
+Categories \\(3, object\\): \\['a', 'b', 'c'\\]
+\\[right\\]: \\['a', 'c', 'b'\\]
+Categories \\(3, object\\): \\['a', 'b', 'c'\\]"""
+
+ s1 = Series(Categorical(["a", "b", "c"]))
+ s2 = Series(Categorical(["a", "c", "b"]))
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_series_equal(s1, s2, rtol=rtol)
+
+
+def test_series_equal_datetime_values_mismatch(rtol):
+ msg = """Series are different
+
+Series values are different \\(100.0 %\\)
+\\[index\\]: \\[0, 1, 2\\]
+\\[left\\]: \\[1514764800000000000, 1514851200000000000, 1514937600000000000\\]
+\\[right\\]: \\[1549065600000000000, 1549152000000000000, 1549238400000000000\\]"""
+
+ s1 = Series(pd.date_range("2018-01-01", periods=3, freq="D"))
+ s2 = Series(pd.date_range("2019-02-02", periods=3, freq="D"))
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_series_equal(s1, s2, rtol=rtol)
+
+
+def test_series_equal_categorical_mismatch(check_categorical):
+ msg = """Attributes of Series are different
+
+Attribute "dtype" are different
+\\[left\\]: CategoricalDtype\\(categories=\\['a', 'b'\\], ordered=False\\)
+\\[right\\]: CategoricalDtype\\(categories=\\['a', 'b', 'c'\\], \
+ordered=False\\)"""
+
+ s1 = Series(Categorical(["a", "b"]))
+ s2 = Series(Categorical(["a", "b"], categories=list("abc")))
+
+ if check_categorical:
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_series_equal(s1, s2, check_categorical=check_categorical)
+ else:
+ _assert_series_equal_both(s1, s2, check_categorical=check_categorical)
+
+
+def test_assert_series_equal_extension_dtype_mismatch():
+ # https://github.com/pandas-dev/pandas/issues/32747
+ left = Series(pd.array([1, 2, 3], dtype="Int64"))
+ right = left.astype(int)
+
+ msg = """Attributes of Series are different
+
+Attribute "dtype" are different
+\\[left\\]: Int64
+\\[right\\]: int[32|64]"""
+
+ tm.assert_series_equal(left, right, check_dtype=False)
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_series_equal(left, right, check_dtype=True)
+
+
+def test_assert_series_equal_interval_dtype_mismatch():
+ # https://github.com/pandas-dev/pandas/issues/32747
+ left = Series([pd.Interval(0, 1)], dtype="interval")
+ right = left.astype(object)
+
+ msg = """Attributes of Series are different
+
+Attribute "dtype" are different
+\\[left\\]: interval\\[int64, right\\]
+\\[right\\]: object"""
+
+ tm.assert_series_equal(left, right, check_dtype=False)
+
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_series_equal(left, right, check_dtype=True)
+
+
+def test_series_equal_series_type():
+ class MySeries(Series):
+ pass
+
+ s1 = Series([1, 2])
+ s2 = Series([1, 2])
+ s3 = MySeries([1, 2])
+
+ tm.assert_series_equal(s1, s2, check_series_type=False)
+ tm.assert_series_equal(s1, s2, check_series_type=True)
+
+ tm.assert_series_equal(s1, s3, check_series_type=False)
+ tm.assert_series_equal(s3, s1, check_series_type=False)
+
+ with pytest.raises(AssertionError, match="Series classes are different"):
+ tm.assert_series_equal(s1, s3, check_series_type=True)
+
+ with pytest.raises(AssertionError, match="Series classes are different"):
+ tm.assert_series_equal(s3, s1, check_series_type=True)
+
+
+def test_series_equal_exact_for_nonnumeric():
+ # https://github.com/pandas-dev/pandas/issues/35446
+ s1 = Series(["a", "b"])
+ s2 = Series(["a", "b"])
+ s3 = Series(["b", "a"])
+
+ tm.assert_series_equal(s1, s2, check_exact=True)
+ tm.assert_series_equal(s2, s1, check_exact=True)
+
+ msg = """Series are different
+
+Series values are different \\(100\\.0 %\\)
+\\[index\\]: \\[0, 1\\]
+\\[left\\]: \\[a, b\\]
+\\[right\\]: \\[b, a\\]"""
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_series_equal(s1, s3, check_exact=True)
+
+ msg = """Series are different
+
+Series values are different \\(100\\.0 %\\)
+\\[index\\]: \\[0, 1\\]
+\\[left\\]: \\[b, a\\]
+\\[right\\]: \\[a, b\\]"""
+ with pytest.raises(AssertionError, match=msg):
+ tm.assert_series_equal(s3, s1, check_exact=True)
+
+
+@pytest.mark.parametrize("right_dtype", ["Int32", "int64"])
+def test_assert_series_equal_ignore_extension_dtype_mismatch(right_dtype):
+ # https://github.com/pandas-dev/pandas/issues/35715
+ left = Series([1, 2, 3], dtype="Int64")
+ right = Series([1, 2, 3], dtype=right_dtype)
+ tm.assert_series_equal(left, right, check_dtype=False)
+
+
+def test_allows_duplicate_labels():
+ left = Series([1])
+ right = Series([1]).set_flags(allows_duplicate_labels=False)
+ tm.assert_series_equal(left, left)
+ tm.assert_series_equal(right, right)
+ tm.assert_series_equal(left, right, check_flags=False)
+ tm.assert_series_equal(right, left, check_flags=False)
+
+ with pytest.raises(AssertionError, match=">> cumavg([1, 2, 3])
+ 2
+ """
+ ),
+ method="cumavg",
+ operation="average",
+)
+def cumavg(whatever):
+ pass
+
+
+@doc(cumsum, method="cummax", operation="maximum")
+def cummax(whatever):
+ pass
+
+
+@doc(cummax, method="cummin", operation="minimum")
+def cummin(whatever):
+ pass
+
+
+def test_docstring_formatting():
+ docstr = dedent(
+ """
+ This is the cumsum method.
+
+ It computes the cumulative sum.
+ """
+ )
+ assert cumsum.__doc__ == docstr
+
+
+def test_docstring_appending():
+ docstr = dedent(
+ """
+ This is the cumavg method.
+
+ It computes the cumulative average.
+
+ Examples
+ --------
+
+ >>> cumavg([1, 2, 3])
+ 2
+ """
+ )
+ assert cumavg.__doc__ == docstr
+
+
+def test_doc_template_from_func():
+ docstr = dedent(
+ """
+ This is the cummax method.
+
+ It computes the cumulative maximum.
+ """
+ )
+ assert cummax.__doc__ == docstr
+
+
+def test_inherit_doc_template():
+ docstr = dedent(
+ """
+ This is the cummin method.
+
+ It computes the cumulative minimum.
+ """
+ )
+ assert cummin.__doc__ == docstr
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_hashing.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_hashing.py
new file mode 100644
index 0000000000000000000000000000000000000000..c2977b81a9b4a41d280221e105ce6442a8a10a7e
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_hashing.py
@@ -0,0 +1,401 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+ DataFrame,
+ Index,
+ MultiIndex,
+ Series,
+)
+import pandas._testing as tm
+from pandas.core.util.hashing import hash_tuples
+from pandas.util import (
+ hash_array,
+ hash_pandas_object,
+)
+
+
+@pytest.fixture(
+ params=[
+ Series([1, 2, 3] * 3, dtype="int32"),
+ Series([None, 2.5, 3.5] * 3, dtype="float32"),
+ Series(["a", "b", "c"] * 3, dtype="category"),
+ Series(["d", "e", "f"] * 3),
+ Series([True, False, True] * 3),
+ Series(pd.date_range("20130101", periods=9)),
+ Series(pd.date_range("20130101", periods=9, tz="US/Eastern")),
+ Series(pd.timedelta_range("2000", periods=9)),
+ ]
+)
+def series(request):
+ return request.param
+
+
+@pytest.fixture(params=[True, False])
+def index(request):
+ return request.param
+
+
+def test_consistency():
+ # Check that our hash doesn't change because of a mistake
+ # in the actual code; this is the ground truth.
+ result = hash_pandas_object(Index(["foo", "bar", "baz"]))
+ expected = Series(
+ np.array(
+ [3600424527151052760, 1374399572096150070, 477881037637427054],
+ dtype="uint64",
+ ),
+ index=["foo", "bar", "baz"],
+ )
+ tm.assert_series_equal(result, expected)
+
+
+def test_hash_array(series):
+ arr = series.values
+ tm.assert_numpy_array_equal(hash_array(arr), hash_array(arr))
+
+
+@pytest.mark.parametrize("dtype", ["U", object])
+def test_hash_array_mixed(dtype):
+ result1 = hash_array(np.array(["3", "4", "All"]))
+ result2 = hash_array(np.array([3, 4, "All"], dtype=dtype))
+
+ tm.assert_numpy_array_equal(result1, result2)
+
+
+@pytest.mark.parametrize("val", [5, "foo", pd.Timestamp("20130101")])
+def test_hash_array_errors(val):
+ msg = "must pass a ndarray-like"
+ with pytest.raises(TypeError, match=msg):
+ hash_array(val)
+
+
+def test_hash_array_index_exception():
+ # GH42003 TypeError instead of AttributeError
+ obj = pd.DatetimeIndex(["2018-10-28 01:20:00"], tz="Europe/Berlin")
+
+ msg = "Use hash_pandas_object instead"
+ with pytest.raises(TypeError, match=msg):
+ hash_array(obj)
+
+
+def test_hash_tuples():
+ tuples = [(1, "one"), (1, "two"), (2, "one")]
+ result = hash_tuples(tuples)
+
+ expected = hash_pandas_object(MultiIndex.from_tuples(tuples)).values
+ tm.assert_numpy_array_equal(result, expected)
+
+ # We only need to support MultiIndex and list-of-tuples
+ msg = "|".join(["object is not iterable", "zip argument #1 must support iteration"])
+ with pytest.raises(TypeError, match=msg):
+ hash_tuples(tuples[0])
+
+
+@pytest.mark.parametrize("val", [5, "foo", pd.Timestamp("20130101")])
+def test_hash_tuples_err(val):
+ msg = "must be convertible to a list-of-tuples"
+ with pytest.raises(TypeError, match=msg):
+ hash_tuples(val)
+
+
+def test_multiindex_unique():
+ mi = MultiIndex.from_tuples([(118, 472), (236, 118), (51, 204), (102, 51)])
+ assert mi.is_unique is True
+
+ result = hash_pandas_object(mi)
+ assert result.is_unique is True
+
+
+def test_multiindex_objects():
+ mi = MultiIndex(
+ levels=[["b", "d", "a"], [1, 2, 3]],
+ codes=[[0, 1, 0, 2], [2, 0, 0, 1]],
+ names=["col1", "col2"],
+ )
+ recons = mi._sort_levels_monotonic()
+
+ # These are equal.
+ assert mi.equals(recons)
+ assert Index(mi.values).equals(Index(recons.values))
+
+
+@pytest.mark.parametrize(
+ "obj",
+ [
+ Series([1, 2, 3]),
+ Series([1.0, 1.5, 3.2]),
+ Series([1.0, 1.5, np.nan]),
+ Series([1.0, 1.5, 3.2], index=[1.5, 1.1, 3.3]),
+ Series(["a", "b", "c"]),
+ Series(["a", np.nan, "c"]),
+ Series(["a", None, "c"]),
+ Series([True, False, True]),
+ Series(dtype=object),
+ DataFrame({"x": ["a", "b", "c"], "y": [1, 2, 3]}),
+ DataFrame(),
+ tm.makeMissingDataframe(),
+ tm.makeMixedDataFrame(),
+ tm.makeTimeDataFrame(),
+ tm.makeTimeSeries(),
+ Series(tm.makePeriodIndex()),
+ Series(pd.date_range("20130101", periods=3, tz="US/Eastern")),
+ ],
+)
+def test_hash_pandas_object(obj, index):
+ a = hash_pandas_object(obj, index=index)
+ b = hash_pandas_object(obj, index=index)
+ tm.assert_series_equal(a, b)
+
+
+@pytest.mark.parametrize(
+ "obj",
+ [
+ Series([1, 2, 3]),
+ Series([1.0, 1.5, 3.2]),
+ Series([1.0, 1.5, np.nan]),
+ Series([1.0, 1.5, 3.2], index=[1.5, 1.1, 3.3]),
+ Series(["a", "b", "c"]),
+ Series(["a", np.nan, "c"]),
+ Series(["a", None, "c"]),
+ Series([True, False, True]),
+ DataFrame({"x": ["a", "b", "c"], "y": [1, 2, 3]}),
+ tm.makeMissingDataframe(),
+ tm.makeMixedDataFrame(),
+ tm.makeTimeDataFrame(),
+ tm.makeTimeSeries(),
+ Series(tm.makePeriodIndex()),
+ Series(pd.date_range("20130101", periods=3, tz="US/Eastern")),
+ ],
+)
+def test_hash_pandas_object_diff_index_non_empty(obj):
+ a = hash_pandas_object(obj, index=True)
+ b = hash_pandas_object(obj, index=False)
+ assert not (a == b).all()
+
+
+@pytest.mark.parametrize(
+ "obj",
+ [
+ Index([1, 2, 3]),
+ Index([True, False, True]),
+ tm.makeTimedeltaIndex(),
+ tm.makePeriodIndex(),
+ MultiIndex.from_product(
+ [range(5), ["foo", "bar", "baz"], pd.date_range("20130101", periods=2)]
+ ),
+ MultiIndex.from_product([pd.CategoricalIndex(list("aabc")), range(3)]),
+ ],
+)
+def test_hash_pandas_index(obj, index):
+ a = hash_pandas_object(obj, index=index)
+ b = hash_pandas_object(obj, index=index)
+ tm.assert_series_equal(a, b)
+
+
+def test_hash_pandas_series(series, index):
+ a = hash_pandas_object(series, index=index)
+ b = hash_pandas_object(series, index=index)
+ tm.assert_series_equal(a, b)
+
+
+def test_hash_pandas_series_diff_index(series):
+ a = hash_pandas_object(series, index=True)
+ b = hash_pandas_object(series, index=False)
+ assert not (a == b).all()
+
+
+@pytest.mark.parametrize(
+ "obj", [Series([], dtype="float64"), Series([], dtype="object"), Index([])]
+)
+def test_hash_pandas_empty_object(obj, index):
+ # These are by-definition the same with
+ # or without the index as the data is empty.
+ a = hash_pandas_object(obj, index=index)
+ b = hash_pandas_object(obj, index=index)
+ tm.assert_series_equal(a, b)
+
+
+@pytest.mark.parametrize(
+ "s1",
+ [
+ Series(["a", "b", "c", "d"]),
+ Series([1000, 2000, 3000, 4000]),
+ Series(pd.date_range(0, periods=4)),
+ ],
+)
+@pytest.mark.parametrize("categorize", [True, False])
+def test_categorical_consistency(s1, categorize):
+ # see gh-15143
+ #
+ # Check that categoricals hash consistent with their values,
+ # not codes. This should work for categoricals of any dtype.
+ s2 = s1.astype("category").cat.set_categories(s1)
+ s3 = s2.cat.set_categories(list(reversed(s1)))
+
+ # These should all hash identically.
+ h1 = hash_pandas_object(s1, categorize=categorize)
+ h2 = hash_pandas_object(s2, categorize=categorize)
+ h3 = hash_pandas_object(s3, categorize=categorize)
+
+ tm.assert_series_equal(h1, h2)
+ tm.assert_series_equal(h1, h3)
+
+
+def test_categorical_with_nan_consistency():
+ c = pd.Categorical.from_codes(
+ [-1, 0, 1, 2, 3, 4], categories=pd.date_range("2012-01-01", periods=5, name="B")
+ )
+ expected = hash_array(c, categorize=False)
+
+ c = pd.Categorical.from_codes([-1, 0], categories=[pd.Timestamp("2012-01-01")])
+ result = hash_array(c, categorize=False)
+
+ assert result[0] in expected
+ assert result[1] in expected
+
+
+def test_pandas_errors():
+ msg = "Unexpected type for hashing"
+ with pytest.raises(TypeError, match=msg):
+ hash_pandas_object(pd.Timestamp("20130101"))
+
+
+def test_hash_keys():
+ # Using different hash keys, should have
+ # different hashes for the same data.
+ #
+ # This only matters for object dtypes.
+ obj = Series(list("abc"))
+
+ a = hash_pandas_object(obj, hash_key="9876543210123456")
+ b = hash_pandas_object(obj, hash_key="9876543210123465")
+
+ assert (a != b).all()
+
+
+def test_df_hash_keys():
+ # DataFrame version of the test_hash_keys.
+ # https://github.com/pandas-dev/pandas/issues/41404
+ obj = DataFrame({"x": np.arange(3), "y": list("abc")})
+
+ a = hash_pandas_object(obj, hash_key="9876543210123456")
+ b = hash_pandas_object(obj, hash_key="9876543210123465")
+
+ assert (a != b).all()
+
+
+def test_df_encoding():
+ # Check that DataFrame recognizes optional encoding.
+ # https://github.com/pandas-dev/pandas/issues/41404
+ # https://github.com/pandas-dev/pandas/pull/42049
+ obj = DataFrame({"x": np.arange(3), "y": list("a+c")})
+
+ a = hash_pandas_object(obj, encoding="utf8")
+ b = hash_pandas_object(obj, encoding="utf7")
+
+ # Note that the "+" is encoded as "+-" in utf-7.
+ assert a[0] == b[0]
+ assert a[1] != b[1]
+ assert a[2] == b[2]
+
+
+def test_invalid_key():
+ # This only matters for object dtypes.
+ msg = "key should be a 16-byte string encoded"
+
+ with pytest.raises(ValueError, match=msg):
+ hash_pandas_object(Series(list("abc")), hash_key="foo")
+
+
+def test_already_encoded(index):
+ # If already encoded, then ok.
+ obj = Series(list("abc")).str.encode("utf8")
+ a = hash_pandas_object(obj, index=index)
+ b = hash_pandas_object(obj, index=index)
+ tm.assert_series_equal(a, b)
+
+
+def test_alternate_encoding(index):
+ obj = Series(list("abc"))
+ a = hash_pandas_object(obj, index=index)
+ b = hash_pandas_object(obj, index=index)
+ tm.assert_series_equal(a, b)
+
+
+@pytest.mark.parametrize("l_exp", range(8))
+@pytest.mark.parametrize("l_add", [0, 1])
+def test_same_len_hash_collisions(l_exp, l_add):
+ length = 2 ** (l_exp + 8) + l_add
+ s = tm.rands_array(length, 2)
+
+ result = hash_array(s, "utf8")
+ assert not result[0] == result[1]
+
+
+def test_hash_collisions():
+ # Hash collisions are bad.
+ #
+ # https://github.com/pandas-dev/pandas/issues/14711#issuecomment-264885726
+ hashes = [
+ "Ingrid-9Z9fKIZmkO7i7Cn51Li34pJm44fgX6DYGBNj3VPlOH50m7HnBlPxfIwFMrcNJNMP6PSgLmwWnInciMWrCSAlLEvt7JkJl4IxiMrVbXSa8ZQoVaq5xoQPjltuJEfwdNlO6jo8qRRHvD8sBEBMQASrRa6TsdaPTPCBo3nwIBpE7YzzmyH0vMBhjQZLx1aCT7faSEx7PgFxQhHdKFWROcysamgy9iVj8DO2Fmwg1NNl93rIAqC3mdqfrCxrzfvIY8aJdzin2cHVzy3QUJxZgHvtUtOLxoqnUHsYbNTeq0xcLXpTZEZCxD4PGubIuCNf32c33M7HFsnjWSEjE2yVdWKhmSVodyF8hFYVmhYnMCztQnJrt3O8ZvVRXd5IKwlLexiSp4h888w7SzAIcKgc3g5XQJf6MlSMftDXm9lIsE1mJNiJEv6uY6pgvC3fUPhatlR5JPpVAHNSbSEE73MBzJrhCAbOLXQumyOXigZuPoME7QgJcBalliQol7YZ9", # noqa: E501
+ "Tim-b9MddTxOWW2AT1Py6vtVbZwGAmYCjbp89p8mxsiFoVX4FyDOF3wFiAkyQTUgwg9sVqVYOZo09Dh1AzhFHbgij52ylF0SEwgzjzHH8TGY8Lypart4p4onnDoDvVMBa0kdthVGKl6K0BDVGzyOXPXKpmnMF1H6rJzqHJ0HywfwS4XYpVwlAkoeNsiicHkJUFdUAhG229INzvIAiJuAHeJDUoyO4DCBqtoZ5TDend6TK7Y914yHlfH3g1WZu5LksKv68VQHJriWFYusW5e6ZZ6dKaMjTwEGuRgdT66iU5nqWTHRH8WSzpXoCFwGcTOwyuqPSe0fTe21DVtJn1FKj9F9nEnR9xOvJUO7E0piCIF4Ad9yAIDY4DBimpsTfKXCu1vdHpKYerzbndfuFe5AhfMduLYZJi5iAw8qKSwR5h86ttXV0Mc0QmXz8dsRvDgxjXSmupPxBggdlqUlC828hXiTPD7am0yETBV0F3bEtvPiNJfremszcV8NcqAoARMe", # noqa: E501
+ ]
+
+ # These should be different.
+ result1 = hash_array(np.asarray(hashes[0:1], dtype=object), "utf8")
+ expected1 = np.array([14963968704024874985], dtype=np.uint64)
+ tm.assert_numpy_array_equal(result1, expected1)
+
+ result2 = hash_array(np.asarray(hashes[1:2], dtype=object), "utf8")
+ expected2 = np.array([16428432627716348016], dtype=np.uint64)
+ tm.assert_numpy_array_equal(result2, expected2)
+
+ result = hash_array(np.asarray(hashes, dtype=object), "utf8")
+ tm.assert_numpy_array_equal(result, np.concatenate([expected1, expected2], axis=0))
+
+
+@pytest.mark.parametrize(
+ "data, result_data",
+ [
+ [[tuple("1"), tuple("2")], [10345501319357378243, 8331063931016360761]],
+ [[(1,), (2,)], [9408946347443669104, 3278256261030523334]],
+ ],
+)
+def test_hash_with_tuple(data, result_data):
+ # GH#28969 array containing a tuple raises on call to arr.astype(str)
+ # apparently a numpy bug github.com/numpy/numpy/issues/9441
+
+ df = DataFrame({"data": data})
+ result = hash_pandas_object(df)
+ expected = Series(result_data, dtype=np.uint64)
+ tm.assert_series_equal(result, expected)
+
+
+def test_hashable_tuple_args():
+ # require that the elements of such tuples are themselves hashable
+
+ df3 = DataFrame(
+ {
+ "data": [
+ (
+ 1,
+ [],
+ ),
+ (
+ 2,
+ {},
+ ),
+ ]
+ }
+ )
+ with pytest.raises(TypeError, match="unhashable type: 'list'"):
+ hash_pandas_object(df3)
+
+
+def test_hash_object_none_key():
+ # https://github.com/pandas-dev/pandas/issues/30887
+ result = pd.util.hash_pandas_object(Series(["a", "b"]), hash_key=None)
+ expected = Series([4578374827886788867, 17338122309987883691], dtype="uint64")
+ tm.assert_series_equal(result, expected)
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_make_objects.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_make_objects.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f5f2d3924e1f762dd730bbfcd0f9d6ca0f62ff7
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_make_objects.py
@@ -0,0 +1,15 @@
+"""
+Tests for tm.makeFoo functions.
+"""
+
+
+import numpy as np
+
+import pandas._testing as tm
+
+
+def test_make_multiindex_respects_k():
+ # GH#38795 respect 'k' arg
+ N = np.random.randint(0, 100)
+ mi = tm.makeMultiIndex(k=N)
+ assert len(mi) == N
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_numba.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_numba.py
new file mode 100644
index 0000000000000000000000000000000000000000..27b68ff0f60447e6695d786de9a72ecbb59f7884
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_numba.py
@@ -0,0 +1,12 @@
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import option_context
+
+
+@td.skip_if_installed("numba")
+def test_numba_not_installed_option_context():
+ with pytest.raises(ImportError, match="Missing optional"):
+ with option_context("compute.use_numba", True):
+ pass
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_rewrite_warning.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_rewrite_warning.py
new file mode 100644
index 0000000000000000000000000000000000000000..f847a06d8ea8d7fa75aac1de9025a5bd29bedf37
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_rewrite_warning.py
@@ -0,0 +1,39 @@
+import warnings
+
+import pytest
+
+from pandas.util._exceptions import rewrite_warning
+
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+ "target_category, target_message, hit",
+ [
+ (FutureWarning, "Target message", True),
+ (FutureWarning, "Target", True),
+ (FutureWarning, "get mess", True),
+ (FutureWarning, "Missed message", False),
+ (DeprecationWarning, "Target message", False),
+ ],
+)
+@pytest.mark.parametrize(
+ "new_category",
+ [
+ None,
+ DeprecationWarning,
+ ],
+)
+def test_rewrite_warning(target_category, target_message, hit, new_category):
+ new_message = "Rewritten message"
+ if hit:
+ expected_category = new_category if new_category else target_category
+ expected_message = new_message
+ else:
+ expected_category = FutureWarning
+ expected_message = "Target message"
+ with tm.assert_produces_warning(expected_category, match=expected_message):
+ with rewrite_warning(
+ target_message, target_category, new_message, new_category
+ ):
+ warnings.warn(message="Target message", category=FutureWarning)
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_safe_import.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_safe_import.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd07bea934ed3b78741a40ac01261c423ea335a8
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_safe_import.py
@@ -0,0 +1,39 @@
+import sys
+import types
+
+import pytest
+
+import pandas.util._test_decorators as td
+
+
+@pytest.mark.parametrize("name", ["foo", "hello123"])
+def test_safe_import_non_existent(name):
+ assert not td.safe_import(name)
+
+
+def test_safe_import_exists():
+ assert td.safe_import("pandas")
+
+
+@pytest.mark.parametrize("min_version,valid", [("0.0.0", True), ("99.99.99", False)])
+def test_safe_import_versions(min_version, valid):
+ result = td.safe_import("pandas", min_version=min_version)
+ result = result if valid else not result
+ assert result
+
+
+@pytest.mark.parametrize(
+ "min_version,valid", [(None, False), ("1.0", True), ("2.0", False)]
+)
+def test_safe_import_dummy(monkeypatch, min_version, valid):
+ mod_name = "hello123"
+
+ mod = types.ModuleType(mod_name)
+ mod.__version__ = "1.5"
+
+ if min_version is not None:
+ monkeypatch.setitem(sys.modules, mod_name, mod)
+
+ result = td.safe_import(mod_name, min_version=min_version)
+ result = result if valid else not result
+ assert result
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_shares_memory.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_shares_memory.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed8227a5c4307f3d31afb66fe67d7cc8a9b438fc
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_shares_memory.py
@@ -0,0 +1,13 @@
+import pandas as pd
+import pandas._testing as tm
+
+
+def test_shares_memory_interval():
+ obj = pd.interval_range(1, 5)
+
+ assert tm.shares_memory(obj, obj)
+ assert tm.shares_memory(obj, obj._data)
+ assert tm.shares_memory(obj, obj[::-1])
+ assert tm.shares_memory(obj, obj[:2])
+
+ assert not tm.shares_memory(obj, obj._data.copy())
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_show_versions.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_show_versions.py
new file mode 100644
index 0000000000000000000000000000000000000000..714588d179aef1b6940db6e698a75a4ee07cca88
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_show_versions.py
@@ -0,0 +1,81 @@
+import json
+import os
+import re
+
+from pandas.util._print_versions import (
+ _get_dependency_info,
+ _get_sys_info,
+)
+
+import pandas as pd
+
+
+def test_show_versions(tmpdir):
+ # GH39701
+ as_json = os.path.join(tmpdir, "test_output.json")
+
+ pd.show_versions(as_json=as_json)
+
+ with open(as_json) as fd:
+ # check if file output is valid JSON, will raise an exception if not
+ result = json.load(fd)
+
+ # Basic check that each version element is found in output
+ expected = {
+ "system": _get_sys_info(),
+ "dependencies": _get_dependency_info(),
+ }
+
+ assert result == expected
+
+
+def test_show_versions_console_json(capsys):
+ # GH39701
+ pd.show_versions(as_json=True)
+ stdout = capsys.readouterr().out
+
+ # check valid json is printed to the console if as_json is True
+ result = json.loads(stdout)
+
+ # Basic check that each version element is found in output
+ expected = {
+ "system": _get_sys_info(),
+ "dependencies": _get_dependency_info(),
+ }
+
+ assert result == expected
+
+
+def test_show_versions_console(capsys):
+ # gh-32041
+ # gh-32041
+ pd.show_versions(as_json=False)
+ result = capsys.readouterr().out
+
+ # check header
+ assert "INSTALLED VERSIONS" in result
+
+ # check full commit hash
+ assert re.search(r"commit\s*:\s[0-9a-f]{40}\n", result)
+
+ # check required dependency
+ # 2020-12-09 npdev has "dirty" in the tag
+ # 2022-05-25 npdev released with RC wo/ "dirty".
+ # Just ensure we match [0-9]+\..* since npdev version is variable
+ assert re.search(r"numpy\s*:\s[0-9]+\..*\n", result)
+
+ # check optional dependency
+ assert re.search(r"pyarrow\s*:\s([0-9]+.*|None)\n", result)
+
+
+def test_json_output_match(capsys, tmpdir):
+ # GH39701
+ pd.show_versions(as_json=True)
+ result_console = capsys.readouterr().out
+
+ out_path = os.path.join(tmpdir, "test_json.json")
+ pd.show_versions(as_json=out_path)
+ with open(out_path) as out_fd:
+ result_file = out_fd.read()
+
+ assert result_console == result_file
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_str_methods.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_str_methods.py
new file mode 100644
index 0000000000000000000000000000000000000000..c07730f58982482d09da80696d97e479d0ee0dc9
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_str_methods.py
@@ -0,0 +1,47 @@
+import sys
+
+import pytest
+
+if sys.version_info < (3, 9):
+ from pandas.util._str_methods import (
+ removeprefix,
+ removesuffix,
+ )
+
+ @pytest.mark.parametrize(
+ "string, prefix, expected",
+ (
+ ("wildcat", "wild", "cat"),
+ ("blackbird", "black", "bird"),
+ ("housefly", "house", "fly"),
+ ("ladybug", "lady", "bug"),
+ ("rattlesnake", "rattle", "snake"),
+ ("baboon", "badger", "baboon"),
+ ("quetzal", "elk", "quetzal"),
+ ),
+ )
+ def test_remove_prefix(string, prefix, expected):
+ result = removeprefix(string, prefix)
+ assert result == expected
+
+ @pytest.mark.parametrize(
+ "string, suffix, expected",
+ (
+ ("wildcat", "cat", "wild"),
+ ("blackbird", "bird", "black"),
+ ("housefly", "fly", "house"),
+ ("ladybug", "bug", "lady"),
+ ("rattlesnake", "snake", "rattle"),
+ ("seahorse", "horse", "sea"),
+ ("baboon", "badger", "baboon"),
+ ("quetzal", "elk", "quetzal"),
+ ),
+ )
+ def test_remove_suffix(string, suffix, expected):
+ result = removesuffix(string, suffix)
+ assert result == expected
+
+else:
+ # NOTE: remove this file when pyupgrade --py39-plus removes
+ # the above block
+ pass
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_util.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..802be634192a34bcdd925984a798b03f830315e2
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_util.py
@@ -0,0 +1,63 @@
+import os
+
+import pytest
+
+from pandas import compat
+import pandas._testing as tm
+
+
+def test_rands():
+ r = tm.rands(10)
+ assert len(r) == 10
+
+
+def test_rands_array_1d():
+ arr = tm.rands_array(5, size=10)
+ assert arr.shape == (10,)
+ assert len(arr[0]) == 5
+
+
+def test_rands_array_2d():
+ arr = tm.rands_array(7, size=(10, 10))
+ assert arr.shape == (10, 10)
+ assert len(arr[1, 1]) == 7
+
+
+def test_numpy_err_state_is_default():
+ expected = {"over": "warn", "divide": "warn", "invalid": "warn", "under": "ignore"}
+ import numpy as np
+
+ # The error state should be unchanged after that import.
+ assert np.geterr() == expected
+
+
+def test_convert_rows_list_to_csv_str():
+ rows_list = ["aaa", "bbb", "ccc"]
+ ret = tm.convert_rows_list_to_csv_str(rows_list)
+
+ if compat.is_platform_windows():
+ expected = "aaa\r\nbbb\r\nccc\r\n"
+ else:
+ expected = "aaa\nbbb\nccc\n"
+
+ assert ret == expected
+
+
+@pytest.mark.parametrize("strict_data_files", [True, False])
+def test_datapath_missing(datapath):
+ with pytest.raises(ValueError, match="Could not find file"):
+ datapath("not_a_file")
+
+
+def test_datapath(datapath):
+ args = ("io", "data", "csv", "iris.csv")
+
+ result = datapath(*args)
+ expected = os.path.join(os.path.dirname(os.path.dirname(__file__)), *args)
+
+ assert result == expected
+
+
+def test_external_error_raised():
+ with tm.external_error_raised(TypeError):
+ raise TypeError("Should not check this error message, so it will pass")
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_validate_args.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_validate_args.py
new file mode 100644
index 0000000000000000000000000000000000000000..77e6b01ba1180dd699389bb2fd4f64510200704e
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_validate_args.py
@@ -0,0 +1,67 @@
+import pytest
+
+from pandas.util._validators import validate_args
+
+_fname = "func"
+
+
+def test_bad_min_fname_arg_count():
+ msg = "'max_fname_arg_count' must be non-negative"
+
+ with pytest.raises(ValueError, match=msg):
+ validate_args(_fname, (None,), -1, "foo")
+
+
+def test_bad_arg_length_max_value_single():
+ args = (None, None)
+ compat_args = ("foo",)
+
+ min_fname_arg_count = 0
+ max_length = len(compat_args) + min_fname_arg_count
+ actual_length = len(args) + min_fname_arg_count
+ msg = (
+ rf"{_fname}\(\) takes at most {max_length} "
+ rf"argument \({actual_length} given\)"
+ )
+
+ with pytest.raises(TypeError, match=msg):
+ validate_args(_fname, args, min_fname_arg_count, compat_args)
+
+
+def test_bad_arg_length_max_value_multiple():
+ args = (None, None)
+ compat_args = {"foo": None}
+
+ min_fname_arg_count = 2
+ max_length = len(compat_args) + min_fname_arg_count
+ actual_length = len(args) + min_fname_arg_count
+ msg = (
+ rf"{_fname}\(\) takes at most {max_length} "
+ rf"arguments \({actual_length} given\)"
+ )
+
+ with pytest.raises(TypeError, match=msg):
+ validate_args(_fname, args, min_fname_arg_count, compat_args)
+
+
+@pytest.mark.parametrize("i", range(1, 3))
+def test_not_all_defaults(i):
+ bad_arg = "foo"
+ msg = (
+ f"the '{bad_arg}' parameter is not supported "
+ rf"in the pandas implementation of {_fname}\(\)"
+ )
+
+ compat_args = {"foo": 2, "bar": -1, "baz": 3}
+ arg_vals = (1, -1, 3)
+
+ with pytest.raises(ValueError, match=msg):
+ validate_args(_fname, arg_vals[:i], 2, compat_args)
+
+
+def test_validation():
+ # No exceptions should be raised.
+ validate_args(_fname, (None,), 2, {"out": None})
+
+ compat_args = {"axis": 1, "out": None}
+ validate_args(_fname, (1, None), 2, compat_args)
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_validate_args_and_kwargs.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_validate_args_and_kwargs.py
new file mode 100644
index 0000000000000000000000000000000000000000..54d94d21949094bd997e2574569cb13bddd0934c
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_validate_args_and_kwargs.py
@@ -0,0 +1,81 @@
+import pytest
+
+from pandas.util._validators import validate_args_and_kwargs
+
+_fname = "func"
+
+
+def test_invalid_total_length_max_length_one():
+ compat_args = ("foo",)
+ kwargs = {"foo": "FOO"}
+ args = ("FoO", "BaZ")
+
+ min_fname_arg_count = 0
+ max_length = len(compat_args) + min_fname_arg_count
+ actual_length = len(kwargs) + len(args) + min_fname_arg_count
+
+ msg = (
+ rf"{_fname}\(\) takes at most {max_length} "
+ rf"argument \({actual_length} given\)"
+ )
+
+ with pytest.raises(TypeError, match=msg):
+ validate_args_and_kwargs(_fname, args, kwargs, min_fname_arg_count, compat_args)
+
+
+def test_invalid_total_length_max_length_multiple():
+ compat_args = ("foo", "bar", "baz")
+ kwargs = {"foo": "FOO", "bar": "BAR"}
+ args = ("FoO", "BaZ")
+
+ min_fname_arg_count = 2
+ max_length = len(compat_args) + min_fname_arg_count
+ actual_length = len(kwargs) + len(args) + min_fname_arg_count
+
+ msg = (
+ rf"{_fname}\(\) takes at most {max_length} "
+ rf"arguments \({actual_length} given\)"
+ )
+
+ with pytest.raises(TypeError, match=msg):
+ validate_args_and_kwargs(_fname, args, kwargs, min_fname_arg_count, compat_args)
+
+
+@pytest.mark.parametrize("args,kwargs", [((), {"foo": -5, "bar": 2}), ((-5, 2), {})])
+def test_missing_args_or_kwargs(args, kwargs):
+ bad_arg = "bar"
+ min_fname_arg_count = 2
+
+ compat_args = {"foo": -5, bad_arg: 1}
+
+ msg = (
+ rf"the '{bad_arg}' parameter is not supported "
+ rf"in the pandas implementation of {_fname}\(\)"
+ )
+
+ with pytest.raises(ValueError, match=msg):
+ validate_args_and_kwargs(_fname, args, kwargs, min_fname_arg_count, compat_args)
+
+
+def test_duplicate_argument():
+ min_fname_arg_count = 2
+
+ compat_args = {"foo": None, "bar": None, "baz": None}
+ kwargs = {"foo": None, "bar": None}
+ args = (None,) # duplicate value for "foo"
+
+ msg = rf"{_fname}\(\) got multiple values for keyword argument 'foo'"
+
+ with pytest.raises(TypeError, match=msg):
+ validate_args_and_kwargs(_fname, args, kwargs, min_fname_arg_count, compat_args)
+
+
+def test_validation():
+ # No exceptions should be raised.
+ compat_args = {"foo": 1, "bar": None, "baz": -2}
+ kwargs = {"baz": -2}
+
+ args = (1, None)
+ min_fname_arg_count = 2
+
+ validate_args_and_kwargs(_fname, args, kwargs, min_fname_arg_count, compat_args)
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_validate_inclusive.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_validate_inclusive.py
new file mode 100644
index 0000000000000000000000000000000000000000..c1254c614ab305c447090b148ea6a036569f76e6
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_validate_inclusive.py
@@ -0,0 +1,40 @@
+import numpy as np
+import pytest
+
+from pandas.util._validators import validate_inclusive
+
+import pandas as pd
+
+
+@pytest.mark.parametrize(
+ "invalid_inclusive",
+ (
+ "ccc",
+ 2,
+ object(),
+ None,
+ np.nan,
+ pd.NA,
+ pd.DataFrame(),
+ ),
+)
+def test_invalid_inclusive(invalid_inclusive):
+ with pytest.raises(
+ ValueError,
+ match="Inclusive has to be either 'both', 'neither', 'left' or 'right'",
+ ):
+ validate_inclusive(invalid_inclusive)
+
+
+@pytest.mark.parametrize(
+ "valid_inclusive, expected_tuple",
+ (
+ ("left", (True, False)),
+ ("right", (False, True)),
+ ("both", (True, True)),
+ ("neither", (False, False)),
+ ),
+)
+def test_valid_inclusive(valid_inclusive, expected_tuple):
+ resultant_tuple = validate_inclusive(valid_inclusive)
+ assert expected_tuple == resultant_tuple
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_validate_kwargs.py b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_validate_kwargs.py
new file mode 100644
index 0000000000000000000000000000000000000000..de49cdd5e247d69671229e1813a7b15a1feb4286
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/util/test_validate_kwargs.py
@@ -0,0 +1,66 @@
+import pytest
+
+from pandas.util._validators import (
+ validate_bool_kwarg,
+ validate_kwargs,
+)
+
+_fname = "func"
+
+
+def test_bad_kwarg():
+ good_arg = "f"
+ bad_arg = good_arg + "o"
+
+ compat_args = {good_arg: "foo", bad_arg + "o": "bar"}
+ kwargs = {good_arg: "foo", bad_arg: "bar"}
+
+ msg = rf"{_fname}\(\) got an unexpected keyword argument '{bad_arg}'"
+
+ with pytest.raises(TypeError, match=msg):
+ validate_kwargs(_fname, kwargs, compat_args)
+
+
+@pytest.mark.parametrize("i", range(1, 3))
+def test_not_all_none(i):
+ bad_arg = "foo"
+ msg = (
+ rf"the '{bad_arg}' parameter is not supported "
+ rf"in the pandas implementation of {_fname}\(\)"
+ )
+
+ compat_args = {"foo": 1, "bar": "s", "baz": None}
+
+ kwarg_keys = ("foo", "bar", "baz")
+ kwarg_vals = (2, "s", None)
+
+ kwargs = dict(zip(kwarg_keys[:i], kwarg_vals[:i]))
+
+ with pytest.raises(ValueError, match=msg):
+ validate_kwargs(_fname, kwargs, compat_args)
+
+
+def test_validation():
+ # No exceptions should be raised.
+ compat_args = {"f": None, "b": 1, "ba": "s"}
+
+ kwargs = {"f": None, "b": 1}
+ validate_kwargs(_fname, kwargs, compat_args)
+
+
+@pytest.mark.parametrize("name", ["inplace", "copy"])
+@pytest.mark.parametrize("value", [1, "True", [1, 2, 3], 5.0])
+def test_validate_bool_kwarg_fail(name, value):
+ msg = (
+ f'For argument "{name}" expected type bool, '
+ f"received type {type(value).__name__}"
+ )
+
+ with pytest.raises(ValueError, match=msg):
+ validate_bool_kwarg(value, name)
+
+
+@pytest.mark.parametrize("name", ["inplace", "copy"])
+@pytest.mark.parametrize("value", [True, False, None])
+def test_validate_bool_kwarg(name, value):
+ assert validate_bool_kwarg(value, name) == value