diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/indexing/__init__.py b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/indexing/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/__init__.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a7ff4ff41301bdabb43b19459652386f03e10243
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/__init__.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_add_prefix_suffix.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_add_prefix_suffix.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4b75bed5df72a9c415285d13227ff76022f1c3fb
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_add_prefix_suffix.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_align.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_align.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7c64abd4135dfb7e671532304a3fd0c0c26aaadb
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_align.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_asfreq.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_asfreq.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0e842172bac6c56723927c460db9f76c8f986f41
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_asfreq.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_asof.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_asof.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c6ca5895884321db321356ca6590123491d5f1ab
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_asof.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_assign.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_assign.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9e990d03c1d09853f1475f9c36c16ab32c97a40b
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_assign.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_astype.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_astype.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dfd5c88ff73ead4bc4150af28933020c4c5b0986
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_astype.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_at_time.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_at_time.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..208f0fc4ae86f5286faedf050c7a66ef5447eacb
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_at_time.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_between_time.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_between_time.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bd47a39c6a52d0ccbebbc0862c919636ece38b03
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_between_time.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_clip.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_clip.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eb2e087c3db819116940ac58ddf67374cc850baf
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_clip.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_combine.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_combine.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..71f36bef9d546bd48b067f763bc2153085368945
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_combine.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_combine_first.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_combine_first.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..54ec1558c464edbc386ea581f5109b2789f9c2a0
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_combine_first.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_copy.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_copy.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1912c48450a6713ab6a1280447ad0bfcb807c8dd
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_copy.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_count.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_count.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..830cf8b0ee07f659a61f0bbac53ffa3d029640ed
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_count.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_cov_corr.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_cov_corr.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..69113467dc9a9f055983c9ce8b991e150ddefa0c
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_cov_corr.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_describe.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_describe.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4e16ac40e2657623ed44032189edf22fecae38cd
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_describe.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_diff.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_diff.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c5a5441f00f481e448ae3e97e72a2e54ea4f140a
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_diff.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_dot.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_dot.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0fed5a5054c45f50bbcec1afa5683a3c6b256ac5
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_dot.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_drop.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_drop.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..751e7c32e489b8b09b6cd15cc0902856744a12fc
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_drop.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_droplevel.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_droplevel.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6e6ffdd922d76da572685d36d920e883395c7475
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_droplevel.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_dropna.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_dropna.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ca0ea9a78cadc6c76c80124176156250fb7be13d
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_dropna.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_dtypes.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_dtypes.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..afd7f2eaaaab5db364e09c28f6ac42d427aa7917
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_dtypes.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_equals.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_equals.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..58f7ef43a84aa3d3c233e76729a4c2434fd4ad6e
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_equals.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_explode.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_explode.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..209ffedee96b2989dad18cdfb6bed1070f9c8d3b
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_explode.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_fillna.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_fillna.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bf10fd3c190837a31abf3f300a9a45dffb6f3540
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_fillna.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_filter.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_filter.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..873177714ef47f77365fa199e238472e02d9dbf4
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_filter.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_first_and_last.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_first_and_last.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4daff149509630a7cf3b5d01d7c6f76c26f935ff
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_first_and_last.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_first_valid_index.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_first_valid_index.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c3a1132c5ecddabb9e448dd4bc13b12951c7b43d
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_first_valid_index.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_get_numeric_data.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_get_numeric_data.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6c64ecbc082ba06c19ba9ddddff0e9ea4f77a5b4
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_get_numeric_data.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_interpolate.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_interpolate.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..287c02638158a06eb85b06c309f28d235b37aa0d
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_interpolate.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_is_homogeneous_dtype.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_is_homogeneous_dtype.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4f6bf76c9e5897d6b818e008f2175ef3cfc734de
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_is_homogeneous_dtype.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_isetitem.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_isetitem.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f7f1d52802469a16746187dfc3067cdba008e5f9
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_isetitem.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_isin.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_isin.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7b76cfe3c2481fe9d1124728be294effe8f6201b
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_isin.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_matmul.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_matmul.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ff10083958806f6aa0ebadbb28d4b16d1d77d924
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_matmul.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_pct_change.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_pct_change.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..23e6b19cce74e2068bf12285254e0b4b696a0b1b
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_pct_change.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_pipe.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_pipe.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..196b75019b50597bfc8f907940a65e6811d845be
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_pipe.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_rank.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_rank.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0d8c101464d5ce7dd2e9ab97e50c27dfc92d6c68
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_rank.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_reindex_like.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_reindex_like.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4964537ce11ee4fc47a0f6dcf2bfd6873fe9e52c
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_reindex_like.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_rename.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_rename.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..27f47d8825fc18476e7526990d4a3c5b8d9e22e1
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_rename.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_rename_axis.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_rename_axis.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..907c3f1dbd22617832ca0e442ffcdf0ed059bb3f
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_rename_axis.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_replace.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_replace.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0cecfdd185ce99f010ca5f0906a726ec898a721f
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_replace.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_reset_index.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_reset_index.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..688e7075b69d240659e9ecf59409b68093a10e77
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_reset_index.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_round.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_round.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c52a638e77b7053fee4c31abbbdb5ddbd071c42f
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_round.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_sample.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_sample.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0367c88418566f90d73ac6b4c5c1a97b596bdad9
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_sample.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_select_dtypes.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_select_dtypes.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a273bc415a5387e3815f6ad369924f92e5194e00
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_select_dtypes.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_set_index.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_set_index.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..49951a1ffc52ac18287dc0954256226fb264abba
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_set_index.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_shift.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_shift.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cdb2def062702cd6f17b2fe668948c5834ca23eb
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_shift.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_sort_index.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_sort_index.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4480e40f089ffdd64668a524562b2e4f3d991299
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_sort_index.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_sort_values.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_sort_values.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..212cffe63f27e1f5051e98ef57132619c978073b
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_sort_values.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_swapaxes.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_swapaxes.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..efc5845cf51a91c5395f625e5289906469466db7
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_swapaxes.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_swaplevel.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_swaplevel.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c8faa9373a6b20f1afbca091eff651244187b8df
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_swaplevel.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_csv.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_csv.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8589f46dbec38fa8f15c16bc9129417e1abbad5d
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_csv.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_dict.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_dict.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5bd0d1b85da897f5209080323eb6471d5ebf6eb8
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_dict.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_dict_of_blocks.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_dict_of_blocks.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..893e15d843fae5b3fbf7a36dc417e6011e046660
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_dict_of_blocks.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_numpy.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_numpy.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dd9325d539f61168964c3bd58eb1d79c87aa58ad
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_numpy.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_period.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_period.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..42a08523e367558c6e757cf280bc5146e33e3881
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_period.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_records.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_records.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b5e44534f6f403dec7b741e6a8752a10bcfb93d9
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_records.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_timestamp.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_timestamp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..45dbf1fb644fef5cc6e47773f27758ad0f27394e
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_to_timestamp.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_transpose.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_transpose.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9b84986d0f211766afc345b3de856bd4e09d8084
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_transpose.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_tz_convert.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_tz_convert.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..252a250c732dff56fb6995199da3573f66b53c4a
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_tz_convert.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_tz_localize.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_tz_localize.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..579fff3605977c97c86bbec52586bd5b46dfbf06
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_tz_localize.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_update.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_update.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b11f09d3a8d02b8f77d1399b70d2952e379cc0ba
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_update.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_value_counts.cpython-310.pyc b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_value_counts.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1fa942044990f4e162e4471e2b66e240a5d84cdc
Binary files /dev/null and b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/__pycache__/test_value_counts.cpython-310.pyc differ
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_astype.py b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_astype.py
new file mode 100644
index 0000000000000000000000000000000000000000..08546f03cee699d23f362734c4c7f3ee115150d9
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_astype.py
@@ -0,0 +1,889 @@
+import re
+
+import numpy as np
+import pytest
+
+from pandas.compat import pa_version_under7p0
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    CategoricalDtype,
+    DataFrame,
+    DatetimeTZDtype,
+    Index,
+    Interval,
+    IntervalDtype,
+    NaT,
+    Series,
+    Timedelta,
+    Timestamp,
+    concat,
+    date_range,
+    option_context,
+)
+import pandas._testing as tm
+
+
+def _check_cast(df, v):
+    """
+    Check if all dtypes of df are equal to v
+    """
+    assert all(s.dtype.name == v for _, s in df.items())
+
+
+class TestAstype:
+    def test_astype_float(self, float_frame):
+        casted = float_frame.astype(int)
+        expected = DataFrame(
+            float_frame.values.astype(int),
+            index=float_frame.index,
+            columns=float_frame.columns,
+        )
+        tm.assert_frame_equal(casted, expected)
+
+        casted = float_frame.astype(np.int32)
+        expected = DataFrame(
+            float_frame.values.astype(np.int32),
+            index=float_frame.index,
+            columns=float_frame.columns,
+        )
+        tm.assert_frame_equal(casted, expected)
+
+        float_frame["foo"] = "5"
+        casted = float_frame.astype(int)
+        expected = DataFrame(
+            float_frame.values.astype(int),
+            index=float_frame.index,
+            columns=float_frame.columns,
+        )
+        tm.assert_frame_equal(casted, expected)
+
+    def test_astype_mixed_float(self, mixed_float_frame):
+        # mixed casting
+        casted = mixed_float_frame.reindex(columns=["A", "B"]).astype("float32")
+        _check_cast(casted, "float32")
+
+        casted = mixed_float_frame.reindex(columns=["A", "B"]).astype("float16")
+        _check_cast(casted, "float16")
+
+    def test_astype_mixed_type(self, mixed_type_frame):
+        # mixed casting
+        mn = mixed_type_frame._get_numeric_data().copy()
+        mn["little_float"] = np.array(12345.0, dtype="float16")
+        mn["big_float"] = np.array(123456789101112.0, dtype="float64")
+
+        casted = mn.astype("float64")
+        _check_cast(casted, "float64")
+
+        casted = mn.astype("int64")
+        _check_cast(casted, "int64")
+
+        casted = mn.reindex(columns=["little_float"]).astype("float16")
+        _check_cast(casted, "float16")
+
+        casted = mn.astype("float32")
+        _check_cast(casted, "float32")
+
+        casted = mn.astype("int32")
+        _check_cast(casted, "int32")
+
+        # to object
+        casted = mn.astype("O")
+        _check_cast(casted, "object")
+
+    def test_astype_with_exclude_string(self, float_frame):
+        df = float_frame.copy()
+        expected = float_frame.astype(int)
+        df["string"] = "foo"
+        casted = df.astype(int, errors="ignore")
+
+        expected["string"] = "foo"
+        tm.assert_frame_equal(casted, expected)
+
+        df = float_frame.copy()
+        expected = float_frame.astype(np.int32)
+        df["string"] = "foo"
+        casted = df.astype(np.int32, errors="ignore")
+
+        expected["string"] = "foo"
+        tm.assert_frame_equal(casted, expected)
+
+    def test_astype_with_view_float(self, float_frame):
+        # this is the only real reason to do it this way
+        tf = np.round(float_frame).astype(np.int32)
+        casted = tf.astype(np.float32, copy=False)
+
+        # TODO(wesm): verification?
+        tf = float_frame.astype(np.float64)
+        casted = tf.astype(np.int64, copy=False)  # noqa
+
+    def test_astype_with_view_mixed_float(self, mixed_float_frame):
+        tf = mixed_float_frame.reindex(columns=["A", "B", "C"])
+
+        casted = tf.astype(np.int64)
+        casted = tf.astype(np.float32)  # noqa
+
+    @pytest.mark.parametrize("dtype", [np.int32, np.int64])
+    @pytest.mark.parametrize("val", [np.nan, np.inf])
+    def test_astype_cast_nan_inf_int(self, val, dtype):
+        # see GH#14265
+        #
+        # Check NaN and inf --> raise error when converting to int.
+        msg = "Cannot convert non-finite values \\(NA or inf\\) to integer"
+        df = DataFrame([val])
+
+        with pytest.raises(ValueError, match=msg):
+            df.astype(dtype)
+
+    def test_astype_str(self):
+        # see GH#9757
+        a = Series(date_range("2010-01-04", periods=5))
+        b = Series(date_range("3/6/2012 00:00", periods=5, tz="US/Eastern"))
+        c = Series([Timedelta(x, unit="d") for x in range(5)])
+        d = Series(range(5))
+        e = Series([0.0, 0.2, 0.4, 0.6, 0.8])
+
+        df = DataFrame({"a": a, "b": b, "c": c, "d": d, "e": e})
+
+        # Datetime-like
+        result = df.astype(str)
+
+        expected = DataFrame(
+            {
+                "a": list(map(str, map(lambda x: Timestamp(x)._date_repr, a._values))),
+                "b": list(map(str, map(Timestamp, b._values))),
+                "c": list(map(lambda x: Timedelta(x)._repr_base(), c._values)),
+                "d": list(map(str, d._values)),
+                "e": list(map(str, e._values)),
+            }
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_astype_str_float(self):
+        # see GH#11302
+        result = DataFrame([np.NaN]).astype(str)
+        expected = DataFrame(["nan"])
+
+        tm.assert_frame_equal(result, expected)
+        result = DataFrame([1.12345678901234567890]).astype(str)
+
+        val = "1.1234567890123457"
+        expected = DataFrame([val])
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype_class", [dict, Series])
+    def test_astype_dict_like(self, dtype_class):
+        # GH7271 & GH16717
+        a = Series(date_range("2010-01-04", periods=5))
+        b = Series(range(5))
+        c = Series([0.0, 0.2, 0.4, 0.6, 0.8])
+        d = Series(["1.0", "2", "3.14", "4", "5.4"])
+        df = DataFrame({"a": a, "b": b, "c": c, "d": d})
+        original = df.copy(deep=True)
+
+        # change type of a subset of columns
+        dt1 = dtype_class({"b": "str", "d": "float32"})
+        result = df.astype(dt1)
+        expected = DataFrame(
+            {
+                "a": a,
+                "b": Series(["0", "1", "2", "3", "4"]),
+                "c": c,
+                "d": Series([1.0, 2.0, 3.14, 4.0, 5.4], dtype="float32"),
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(df, original)
+
+        dt2 = dtype_class({"b": np.float32, "c": "float32", "d": np.float64})
+        result = df.astype(dt2)
+        expected = DataFrame(
+            {
+                "a": a,
+                "b": Series([0.0, 1.0, 2.0, 3.0, 4.0], dtype="float32"),
+                "c": Series([0.0, 0.2, 0.4, 0.6, 0.8], dtype="float32"),
+                "d": Series([1.0, 2.0, 3.14, 4.0, 5.4], dtype="float64"),
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(df, original)
+
+        # change all columns
+        dt3 = dtype_class({"a": str, "b": str, "c": str, "d": str})
+        tm.assert_frame_equal(df.astype(dt3), df.astype(str))
+        tm.assert_frame_equal(df, original)
+
+        # error should be raised when using something other than column labels
+        # in the keys of the dtype dict
+        dt4 = dtype_class({"b": str, 2: str})
+        dt5 = dtype_class({"e": str})
+        msg_frame = (
+            "Only a column name can be used for the key in a dtype mappings argument. "
+            "'{}' not found in columns."
+        )
+        with pytest.raises(KeyError, match=msg_frame.format(2)):
+            df.astype(dt4)
+        with pytest.raises(KeyError, match=msg_frame.format("e")):
+            df.astype(dt5)
+        tm.assert_frame_equal(df, original)
+
+        # if the dtypes provided are the same as the original dtypes, the
+        # resulting DataFrame should be the same as the original DataFrame
+        dt6 = dtype_class({col: df[col].dtype for col in df.columns})
+        equiv = df.astype(dt6)
+        tm.assert_frame_equal(df, equiv)
+        tm.assert_frame_equal(df, original)
+
+        # GH#16717
+        # if dtypes provided is empty, the resulting DataFrame
+        # should be the same as the original DataFrame
+        dt7 = dtype_class({}) if dtype_class is dict else dtype_class({}, dtype=object)
+        equiv = df.astype(dt7)
+        tm.assert_frame_equal(df, equiv)
+        tm.assert_frame_equal(df, original)
+
+    def test_astype_duplicate_col(self):
+        a1 = Series([1, 2, 3, 4, 5], name="a")
+        b = Series([0.1, 0.2, 0.4, 0.6, 0.8], name="b")
+        a2 = Series([0, 1, 2, 3, 4], name="a")
+        df = concat([a1, b, a2], axis=1)
+
+        result = df.astype(str)
+        a1_str = Series(["1", "2", "3", "4", "5"], dtype="str", name="a")
+        b_str = Series(["0.1", "0.2", "0.4", "0.6", "0.8"], dtype=str, name="b")
+        a2_str = Series(["0", "1", "2", "3", "4"], dtype="str", name="a")
+        expected = concat([a1_str, b_str, a2_str], axis=1)
+        tm.assert_frame_equal(result, expected)
+
+        result = df.astype({"a": "str"})
+        expected = concat([a1_str, b, a2_str], axis=1)
+        tm.assert_frame_equal(result, expected)
+
+    def test_astype_duplicate_col_series_arg(self):
+        # GH#44417
+        vals = np.random.randn(3, 4)
+        df = DataFrame(vals, columns=["A", "B", "C", "A"])
+        dtypes = df.dtypes
+        dtypes.iloc[0] = str
+        dtypes.iloc[2] = "Float64"
+
+        result = df.astype(dtypes)
+        expected = DataFrame(
+            {
+                0: vals[:, 0].astype(str),
+                1: vals[:, 1],
+                2: pd.array(vals[:, 2], dtype="Float64"),
+                3: vals[:, 3],
+            }
+        )
+        expected.columns = df.columns
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype",
+        [
+            "category",
+            CategoricalDtype(),
+            CategoricalDtype(ordered=True),
+            CategoricalDtype(ordered=False),
+            CategoricalDtype(categories=list("abcdef")),
+            CategoricalDtype(categories=list("edba"), ordered=False),
+            CategoricalDtype(categories=list("edcb"), ordered=True),
+        ],
+        ids=repr,
+    )
+    def test_astype_categorical(self, dtype):
+        # GH#18099
+        d = {"A": list("abbc"), "B": list("bccd"), "C": list("cdde")}
+        df = DataFrame(d)
+        result = df.astype(dtype)
+        expected = DataFrame({k: Categorical(v, dtype=dtype) for k, v in d.items()})
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("cls", [CategoricalDtype, DatetimeTZDtype, IntervalDtype])
+    def test_astype_categoricaldtype_class_raises(self, cls):
+        df = DataFrame({"A": ["a", "a", "b", "c"]})
+        xpr = f"Expected an instance of {cls.__name__}"
+        with pytest.raises(TypeError, match=xpr):
+            df.astype({"A": cls})
+
+        with pytest.raises(TypeError, match=xpr):
+            df["A"].astype(cls)
+
+    @pytest.mark.parametrize("dtype", ["Int64", "Int32", "Int16"])
+    def test_astype_extension_dtypes(self, dtype):
+        # GH#22578
+        df = DataFrame([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], columns=["a", "b"])
+
+        expected1 = DataFrame(
+            {
+                "a": pd.array([1, 3, 5], dtype=dtype),
+                "b": pd.array([2, 4, 6], dtype=dtype),
+            }
+        )
+        tm.assert_frame_equal(df.astype(dtype), expected1)
+        tm.assert_frame_equal(df.astype("int64").astype(dtype), expected1)
+        tm.assert_frame_equal(df.astype(dtype).astype("float64"), df)
+
+        df = DataFrame([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], columns=["a", "b"])
+        df["b"] = df["b"].astype(dtype)
+        expected2 = DataFrame(
+            {"a": [1.0, 3.0, 5.0], "b": pd.array([2, 4, 6], dtype=dtype)}
+        )
+        tm.assert_frame_equal(df, expected2)
+
+        tm.assert_frame_equal(df.astype(dtype), expected1)
+        tm.assert_frame_equal(df.astype("int64").astype(dtype), expected1)
+
+    @pytest.mark.parametrize("dtype", ["Int64", "Int32", "Int16"])
+    def test_astype_extension_dtypes_1d(self, dtype):
+        # GH#22578
+        df = DataFrame({"a": [1.0, 2.0, 3.0]})
+
+        expected1 = DataFrame({"a": pd.array([1, 2, 3], dtype=dtype)})
+        tm.assert_frame_equal(df.astype(dtype), expected1)
+        tm.assert_frame_equal(df.astype("int64").astype(dtype), expected1)
+
+        df = DataFrame({"a": [1.0, 2.0, 3.0]})
+        df["a"] = df["a"].astype(dtype)
+        expected2 = DataFrame({"a": pd.array([1, 2, 3], dtype=dtype)})
+        tm.assert_frame_equal(df, expected2)
+
+        tm.assert_frame_equal(df.astype(dtype), expected1)
+        tm.assert_frame_equal(df.astype("int64").astype(dtype), expected1)
+
+    @pytest.mark.parametrize("dtype", ["category", "Int64"])
+    def test_astype_extension_dtypes_duplicate_col(self, dtype):
+        # GH#24704
+        a1 = Series([0, np.nan, 4], name="a")
+        a2 = Series([np.nan, 3, 5], name="a")
+        df = concat([a1, a2], axis=1)
+
+        result = df.astype(dtype)
+        expected = concat([a1.astype(dtype), a2.astype(dtype)], axis=1)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype", [{100: "float64", 200: "uint64"}, "category", "float64"]
+    )
+    def test_astype_column_metadata(self, dtype):
+        # GH#19920
+        columns = Index([100, 200, 300], dtype=np.uint64, name="foo")
+        df = DataFrame(np.arange(15).reshape(5, 3), columns=columns)
+        df = df.astype(dtype)
+        tm.assert_index_equal(df.columns, columns)
+
+    @pytest.mark.parametrize("unit", ["Y", "M", "W", "D", "h", "m"])
+    def test_astype_from_object_to_datetime_unit(self, unit):
+        vals = [
+            ["2015-01-01", "2015-01-02", "2015-01-03"],
+            ["2017-01-01", "2017-01-02", "2017-02-03"],
+        ]
+        df = DataFrame(vals, dtype=object)
+        with pytest.raises(TypeError, match="Cannot cast"):
+            df.astype(f"M8[{unit}]")
+
+    @pytest.mark.parametrize("unit", ["Y", "M", "W", "D", "h", "m"])
+    def test_astype_from_object_to_timedelta_unit(self, unit):
+        vals = [
+            ["1 Day", "2 Days", "3 Days"],
+            ["4 Days", "5 Days", "6 Days"],
+        ]
+        df = DataFrame(vals, dtype=object)
+        msg = (
+            r"Cannot convert from timedelta64\[ns\] to timedelta64\[.*\]. "
+            "Supported resolutions are 's', 'ms', 'us', 'ns'"
+        )
+        with pytest.raises(ValueError, match=msg):
+            # TODO: this is ValueError while for DatetimeArray it is TypeError;
+            #  get these consistent
+            df.astype(f"m8[{unit}]")
+
+    @pytest.mark.parametrize("dtype", ["M8", "m8"])
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s", "h", "m", "D"])
+    def test_astype_from_datetimelike_to_object(self, dtype, unit):
+        # tests astype to object dtype
+        # GH#19223 / GH#12425
+        dtype = f"{dtype}[{unit}]"
+        arr = np.array([[1, 2, 3]], dtype=dtype)
+        df = DataFrame(arr)
+        result = df.astype(object)
+        assert (result.dtypes == object).all()
+
+        if dtype.startswith("M8"):
+            assert result.iloc[0, 0] == Timestamp(1, unit=unit)
+        else:
+            assert result.iloc[0, 0] == Timedelta(1, unit=unit)
+
+    @pytest.mark.parametrize("arr_dtype", [np.int64, np.float64])
+    @pytest.mark.parametrize("dtype", ["M8", "m8"])
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s", "h", "m", "D"])
+    def test_astype_to_datetimelike_unit(self, arr_dtype, dtype, unit):
+        # tests all units from numeric origination
+        # GH#19223 / GH#12425
+        dtype = f"{dtype}[{unit}]"
+        arr = np.array([[1, 2, 3]], dtype=arr_dtype)
+        df = DataFrame(arr)
+        result = df.astype(dtype)
+        expected = DataFrame(arr.astype(dtype))
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s", "h", "m", "D"])
+    def test_astype_to_datetime_unit(self, unit):
+        # tests all units from datetime origination
+        # GH#19223
+        dtype = f"M8[{unit}]"
+        arr = np.array([[1, 2, 3]], dtype=dtype)
+        df = DataFrame(arr)
+        ser = df.iloc[:, 0]
+        idx = Index(ser)
+        dta = ser._values
+
+        if unit in ["ns", "us", "ms", "s"]:
+            # GH#48928
+            result = df.astype(dtype)
+        else:
+            # we use the nearest supported dtype (i.e. M8[s])
+            msg = rf"Cannot cast DatetimeArray to dtype datetime64\[{unit}\]"
+            with pytest.raises(TypeError, match=msg):
+                df.astype(dtype)
+
+            with pytest.raises(TypeError, match=msg):
+                ser.astype(dtype)
+
+            with pytest.raises(TypeError, match=msg.replace("Array", "Index")):
+                idx.astype(dtype)
+
+            with pytest.raises(TypeError, match=msg):
+                dta.astype(dtype)
+
+            return
+
+        exp_df = DataFrame(arr.astype(dtype))
+        assert (exp_df.dtypes == dtype).all()
+        tm.assert_frame_equal(result, exp_df)
+
+        res_ser = ser.astype(dtype)
+        exp_ser = exp_df.iloc[:, 0]
+        assert exp_ser.dtype == dtype
+        tm.assert_series_equal(res_ser, exp_ser)
+
+        exp_dta = exp_ser._values
+
+        res_index = idx.astype(dtype)
+        exp_index = Index(exp_ser)
+        assert exp_index.dtype == dtype
+        tm.assert_index_equal(res_index, exp_index)
+
+        res_dta = dta.astype(dtype)
+        assert exp_dta.dtype == dtype
+        tm.assert_extension_array_equal(res_dta, exp_dta)
+
+    @pytest.mark.parametrize("unit", ["ns"])
+    def test_astype_to_timedelta_unit_ns(self, unit):
+        # preserver the timedelta conversion
+        # GH#19223
+        dtype = f"m8[{unit}]"
+        arr = np.array([[1, 2, 3]], dtype=dtype)
+        df = DataFrame(arr)
+        result = df.astype(dtype)
+        expected = DataFrame(arr.astype(dtype))
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("unit", ["us", "ms", "s", "h", "m", "D"])
+    def test_astype_to_timedelta_unit(self, unit):
+        # coerce to float
+        # GH#19223 until 2.0 used to coerce to float
+        dtype = f"m8[{unit}]"
+        arr = np.array([[1, 2, 3]], dtype=dtype)
+        df = DataFrame(arr)
+        ser = df.iloc[:, 0]
+        tdi = Index(ser)
+        tda = tdi._values
+
+        if unit in ["us", "ms", "s"]:
+            assert (df.dtypes == dtype).all()
+            result = df.astype(dtype)
+        else:
+            # We get the nearest supported unit, i.e. "s"
+            assert (df.dtypes == "m8[s]").all()
+
+            msg = (
+                rf"Cannot convert from timedelta64\[s\] to timedelta64\[{unit}\]. "
+                "Supported resolutions are 's', 'ms', 'us', 'ns'"
+            )
+            with pytest.raises(ValueError, match=msg):
+                df.astype(dtype)
+            with pytest.raises(ValueError, match=msg):
+                ser.astype(dtype)
+            with pytest.raises(ValueError, match=msg):
+                tdi.astype(dtype)
+            with pytest.raises(ValueError, match=msg):
+                tda.astype(dtype)
+
+            return
+
+        result = df.astype(dtype)
+        # The conversion is a no-op, so we just get a copy
+        expected = df
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s", "h", "m", "D"])
+    def test_astype_to_incorrect_datetimelike(self, unit):
+        # trying to astype a m to a M, or vice-versa
+        # GH#19224
+        dtype = f"M8[{unit}]"
+        other = f"m8[{unit}]"
+
+        df = DataFrame(np.array([[1, 2, 3]], dtype=dtype))
+        msg = "|".join(
+            [
+                # BlockManager path
+                rf"Cannot cast DatetimeArray to dtype timedelta64\[{unit}\]",
+                # ArrayManager path
+                "cannot astype a datetimelike from "
+                rf"\[datetime64\[ns\]\] to \[timedelta64\[{unit}\]\]",
+            ]
+        )
+        with pytest.raises(TypeError, match=msg):
+            df.astype(other)
+
+        msg = "|".join(
+            [
+                # BlockManager path
+                rf"Cannot cast TimedeltaArray to dtype datetime64\[{unit}\]",
+                # ArrayManager path
+                "cannot astype a timedelta from "
+                rf"\[timedelta64\[ns\]\] to \[datetime64\[{unit}\]\]",
+            ]
+        )
+        df = DataFrame(np.array([[1, 2, 3]], dtype=other))
+        with pytest.raises(TypeError, match=msg):
+            df.astype(dtype)
+
+    def test_astype_arg_for_errors(self):
+        # GH#14878
+
+        df = DataFrame([1, 2, 3])
+
+        msg = (
+            "Expected value of kwarg 'errors' to be one of "
+            "['raise', 'ignore']. Supplied value is 'True'"
+        )
+        with pytest.raises(ValueError, match=re.escape(msg)):
+            df.astype(np.float64, errors=True)
+
+        df.astype(np.int8, errors="ignore")
+
+    def test_astype_invalid_conversion(self):
+        # GH#47571
+        df = DataFrame({"a": [1, 2, "text"], "b": [1, 2, 3]})
+
+        msg = (
+            "invalid literal for int() with base 10: 'text': "
+            "Error while type casting for column 'a'"
+        )
+
+        with pytest.raises(ValueError, match=re.escape(msg)):
+            df.astype({"a": int})
+
+    def test_astype_arg_for_errors_dictlist(self):
+        # GH#25905
+        df = DataFrame(
+            [
+                {"a": "1", "b": "16.5%", "c": "test"},
+                {"a": "2.2", "b": "15.3", "c": "another_test"},
+            ]
+        )
+        expected = DataFrame(
+            [
+                {"a": 1.0, "b": "16.5%", "c": "test"},
+                {"a": 2.2, "b": "15.3", "c": "another_test"},
+            ]
+        )
+        type_dict = {"a": "float64", "b": "float64", "c": "object"}
+
+        result = df.astype(dtype=type_dict, errors="ignore")
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_astype_dt64tz(self, timezone_frame):
+        # astype
+        expected = np.array(
+            [
+                [
+                    Timestamp("2013-01-01 00:00:00"),
+                    Timestamp("2013-01-02 00:00:00"),
+                    Timestamp("2013-01-03 00:00:00"),
+                ],
+                [
+                    Timestamp("2013-01-01 00:00:00-0500", tz="US/Eastern"),
+                    NaT,
+                    Timestamp("2013-01-03 00:00:00-0500", tz="US/Eastern"),
+                ],
+                [
+                    Timestamp("2013-01-01 00:00:00+0100", tz="CET"),
+                    NaT,
+                    Timestamp("2013-01-03 00:00:00+0100", tz="CET"),
+                ],
+            ],
+            dtype=object,
+        ).T
+        expected = DataFrame(
+            expected,
+            index=timezone_frame.index,
+            columns=timezone_frame.columns,
+            dtype=object,
+        )
+        result = timezone_frame.astype(object)
+        tm.assert_frame_equal(result, expected)
+
+        msg = "Cannot use .astype to convert from timezone-aware dtype to timezone-"
+        with pytest.raises(TypeError, match=msg):
+            # dt64tz->dt64 deprecated
+            timezone_frame.astype("datetime64[ns]")
+
+    def test_astype_dt64tz_to_str(self, timezone_frame):
+        # str formatting
+        result = timezone_frame.astype(str)
+        expected = DataFrame(
+            [
+                [
+                    "2013-01-01",
+                    "2013-01-01 00:00:00-05:00",
+                    "2013-01-01 00:00:00+01:00",
+                ],
+                ["2013-01-02", "NaT", "NaT"],
+                [
+                    "2013-01-03",
+                    "2013-01-03 00:00:00-05:00",
+                    "2013-01-03 00:00:00+01:00",
+                ],
+            ],
+            columns=timezone_frame.columns,
+        )
+        tm.assert_frame_equal(result, expected)
+
+        with option_context("display.max_columns", 20):
+            result = str(timezone_frame)
+            assert (
+                "0 2013-01-01 2013-01-01 00:00:00-05:00 2013-01-01 00:00:00+01:00"
+            ) in result
+            assert (
+                "1 2013-01-02                       NaT                       NaT"
+            ) in result
+            assert (
+                "2 2013-01-03 2013-01-03 00:00:00-05:00 2013-01-03 00:00:00+01:00"
+            ) in result
+
+    def test_astype_empty_dtype_dict(self):
+        # issue mentioned further down in the following issue's thread
+        # https://github.com/pandas-dev/pandas/issues/33113
+        df = DataFrame()
+        result = df.astype({})
+        tm.assert_frame_equal(result, df)
+        assert result is not df
+
+    @pytest.mark.parametrize(
+        "data, dtype",
+        [
+            (["x", "y", "z"], "string[python]"),
+            pytest.param(
+                ["x", "y", "z"],
+                "string[pyarrow]",
+                marks=td.skip_if_no("pyarrow"),
+            ),
+            (["x", "y", "z"], "category"),
+            (3 * [Timestamp("2020-01-01", tz="UTC")], None),
+            (3 * [Interval(0, 1)], None),
+        ],
+    )
+    @pytest.mark.parametrize("errors", ["raise", "ignore"])
+    def test_astype_ignores_errors_for_extension_dtypes(self, data, dtype, errors):
+        # https://github.com/pandas-dev/pandas/issues/35471
+        df = DataFrame(Series(data, dtype=dtype))
+        if errors == "ignore":
+            expected = df
+            result = df.astype(float, errors=errors)
+            tm.assert_frame_equal(result, expected)
+        else:
+            msg = "(Cannot cast)|(could not convert)"
+            with pytest.raises((ValueError, TypeError), match=msg):
+                df.astype(float, errors=errors)
+
+    def test_astype_tz_conversion(self):
+        # GH 35973
+        val = {"tz": date_range("2020-08-30", freq="d", periods=2, tz="Europe/London")}
+        df = DataFrame(val)
+        result = df.astype({"tz": "datetime64[ns, Europe/Berlin]"})
+
+        expected = df
+        expected["tz"] = expected["tz"].dt.tz_convert("Europe/Berlin")
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", ["UTC", "Europe/Berlin"])
+    def test_astype_tz_object_conversion(self, tz):
+        # GH 35973
+        val = {"tz": date_range("2020-08-30", freq="d", periods=2, tz="Europe/London")}
+        expected = DataFrame(val)
+
+        # convert expected to object dtype from other tz str (independently tested)
+        result = expected.astype({"tz": f"datetime64[ns, {tz}]"})
+        result = result.astype({"tz": "object"})
+
+        # do real test: object dtype to a specified tz, different from construction tz.
+        result = result.astype({"tz": "datetime64[ns, Europe/London]"})
+        tm.assert_frame_equal(result, expected)
+
+    def test_astype_dt64_to_string(self, frame_or_series, tz_naive_fixture):
+        # GH#41409
+        tz = tz_naive_fixture
+
+        dti = date_range("2016-01-01", periods=3, tz=tz)
+        dta = dti._data
+        dta[0] = NaT
+
+        obj = frame_or_series(dta)
+        result = obj.astype("string")
+
+        # Check that Series/DataFrame.astype matches DatetimeArray.astype
+        expected = frame_or_series(dta.astype("string"))
+        tm.assert_equal(result, expected)
+
+        item = result.iloc[0]
+        if frame_or_series is DataFrame:
+            item = item.iloc[0]
+        assert item is pd.NA
+
+        # For non-NA values, we should match what we get for non-EA str
+        alt = obj.astype(str)
+        assert np.all(alt.iloc[1:] == result.iloc[1:])
+
+    def test_astype_td64_to_string(self, frame_or_series):
+        # GH#41409
+        tdi = pd.timedelta_range("1 Day", periods=3)
+        obj = frame_or_series(tdi)
+
+        expected = frame_or_series(["1 days", "2 days", "3 days"], dtype="string")
+        result = obj.astype("string")
+        tm.assert_equal(result, expected)
+
+    def test_astype_bytes(self):
+        # GH#39474
+        result = DataFrame(["foo", "bar", "baz"]).astype(bytes)
+        assert result.dtypes[0] == np.dtype("S3")
+
+    @pytest.mark.parametrize(
+        "index_slice",
+        [
+            np.s_[:2, :2],
+            np.s_[:1, :2],
+            np.s_[:2, :1],
+            np.s_[::2, ::2],
+            np.s_[::1, ::2],
+            np.s_[::2, ::1],
+        ],
+    )
+    def test_astype_noncontiguous(self, index_slice):
+        # GH#42396
+        data = np.arange(16).reshape(4, 4)
+        df = DataFrame(data)
+
+        result = df.iloc[index_slice].astype("int16")
+        expected = df.iloc[index_slice]
+        tm.assert_frame_equal(result, expected, check_dtype=False)
+
+    def test_astype_retain_attrs(self, any_numpy_dtype):
+        # GH#44414
+        df = DataFrame({"a": [0, 1, 2], "b": [3, 4, 5]})
+        df.attrs["Location"] = "Michigan"
+
+        result = df.astype({"a": any_numpy_dtype}).attrs
+        expected = df.attrs
+
+        tm.assert_dict_equal(expected, result)
+
+
+class TestAstypeCategorical:
+    def test_astype_from_categorical3(self):
+        df = DataFrame({"cats": [1, 2, 3, 4, 5, 6], "vals": [1, 2, 3, 4, 5, 6]})
+        cats = Categorical([1, 2, 3, 4, 5, 6])
+        exp_df = DataFrame({"cats": cats, "vals": [1, 2, 3, 4, 5, 6]})
+        df["cats"] = df["cats"].astype("category")
+        tm.assert_frame_equal(exp_df, df)
+
+    def test_astype_from_categorical4(self):
+        df = DataFrame(
+            {"cats": ["a", "b", "b", "a", "a", "d"], "vals": [1, 2, 3, 4, 5, 6]}
+        )
+        cats = Categorical(["a", "b", "b", "a", "a", "d"])
+        exp_df = DataFrame({"cats": cats, "vals": [1, 2, 3, 4, 5, 6]})
+        df["cats"] = df["cats"].astype("category")
+        tm.assert_frame_equal(exp_df, df)
+
+    def test_categorical_astype_to_int(self, any_int_dtype):
+        # GH#39402
+
+        df = DataFrame(data={"col1": pd.array([2.0, 1.0, 3.0])})
+        df.col1 = df.col1.astype("category")
+        df.col1 = df.col1.astype(any_int_dtype)
+        expected = DataFrame({"col1": pd.array([2, 1, 3], dtype=any_int_dtype)})
+        tm.assert_frame_equal(df, expected)
+
+    def test_astype_categorical_to_string_missing(self):
+        # https://github.com/pandas-dev/pandas/issues/41797
+        df = DataFrame(["a", "b", np.nan])
+        expected = df.astype(str)
+        cat = df.astype("category")
+        result = cat.astype(str)
+        tm.assert_frame_equal(result, expected)
+
+
+class IntegerArrayNoCopy(pd.core.arrays.IntegerArray):
+    # GH 42501
+
+    def copy(self):
+        assert False
+
+
+class Int16DtypeNoCopy(pd.Int16Dtype):
+    # GH 42501
+
+    @classmethod
+    def construct_array_type(cls):
+        return IntegerArrayNoCopy
+
+
+def test_frame_astype_no_copy():
+    # GH 42501
+    df = DataFrame({"a": [1, 4, None, 5], "b": [6, 7, 8, 9]}, dtype=object)
+    result = df.astype({"a": Int16DtypeNoCopy()}, copy=False)
+
+    assert result.a.dtype == pd.Int16Dtype()
+    assert np.shares_memory(df.b.values, result.b.values)
+
+
+@pytest.mark.skipif(pa_version_under7p0, reason="pyarrow is required for this test")
+@pytest.mark.parametrize("dtype", ["int64", "Int64"])
+def test_astype_copies(dtype):
+    # GH#50984
+    df = DataFrame({"a": [1, 2, 3]}, dtype=dtype)
+    result = df.astype("int64[pyarrow]", copy=True)
+    df.iloc[0, 0] = 100
+    expected = DataFrame({"a": [1, 2, 3]}, dtype="int64[pyarrow]")
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("val", [None, 1, 1.5, np.nan, NaT])
+def test_astype_to_string_not_modifying_input(string_storage, val):
+    # GH#51073
+    df = DataFrame({"a": ["a", "b", val]})
+    expected = df.copy()
+    with option_context("mode.string_storage", string_storage):
+        df.astype("string", copy=False)
+    tm.assert_frame_equal(df, expected)
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_clip.py b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_clip.py
new file mode 100644
index 0000000000000000000000000000000000000000..f8d9adf44dbc284b119454deba7285dc5513a6ff
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_clip.py
@@ -0,0 +1,166 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameClip:
+    def test_clip(self, float_frame):
+        median = float_frame.median().median()
+        original = float_frame.copy()
+
+        double = float_frame.clip(upper=median, lower=median)
+        assert not (double.values != median).any()
+
+        # Verify that float_frame was not changed inplace
+        assert (float_frame.values == original.values).all()
+
+    def test_inplace_clip(self, float_frame):
+        # GH#15388
+        median = float_frame.median().median()
+        frame_copy = float_frame.copy()
+
+        return_value = frame_copy.clip(upper=median, lower=median, inplace=True)
+        assert return_value is None
+        assert not (frame_copy.values != median).any()
+
+    def test_dataframe_clip(self):
+        # GH#2747
+        df = DataFrame(np.random.randn(1000, 2))
+
+        for lb, ub in [(-1, 1), (1, -1)]:
+            clipped_df = df.clip(lb, ub)
+
+            lb, ub = min(lb, ub), max(ub, lb)
+            lb_mask = df.values <= lb
+            ub_mask = df.values >= ub
+            mask = ~lb_mask & ~ub_mask
+            assert (clipped_df.values[lb_mask] == lb).all()
+            assert (clipped_df.values[ub_mask] == ub).all()
+            assert (clipped_df.values[mask] == df.values[mask]).all()
+
+    def test_clip_mixed_numeric(self):
+        # clip on mixed integer or floats
+        # GH#24162, clipping now preserves numeric types per column
+        df = DataFrame({"A": [1, 2, 3], "B": [1.0, np.nan, 3.0]})
+        result = df.clip(1, 2)
+        expected = DataFrame({"A": [1, 2, 2], "B": [1.0, np.nan, 2.0]})
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame([[1, 2, 3.4], [3, 4, 5.6]], columns=["foo", "bar", "baz"])
+        expected = df.dtypes
+        result = df.clip(upper=3).dtypes
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    def test_clip_against_series(self, inplace):
+        # GH#6966
+
+        df = DataFrame(np.random.randn(1000, 2))
+        lb = Series(np.random.randn(1000))
+        ub = lb + 1
+
+        original = df.copy()
+        clipped_df = df.clip(lb, ub, axis=0, inplace=inplace)
+
+        if inplace:
+            clipped_df = df
+
+        for i in range(2):
+            lb_mask = original.iloc[:, i] <= lb
+            ub_mask = original.iloc[:, i] >= ub
+            mask = ~lb_mask & ~ub_mask
+
+            result = clipped_df.loc[lb_mask, i]
+            tm.assert_series_equal(result, lb[lb_mask], check_names=False)
+            assert result.name == i
+
+            result = clipped_df.loc[ub_mask, i]
+            tm.assert_series_equal(result, ub[ub_mask], check_names=False)
+            assert result.name == i
+
+            tm.assert_series_equal(clipped_df.loc[mask, i], df.loc[mask, i])
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    @pytest.mark.parametrize("lower", [[2, 3, 4], np.asarray([2, 3, 4])])
+    @pytest.mark.parametrize(
+        "axis,res",
+        [
+            (0, [[2.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 7.0, 7.0]]),
+            (1, [[2.0, 3.0, 4.0], [4.0, 5.0, 6.0], [5.0, 6.0, 7.0]]),
+        ],
+    )
+    def test_clip_against_list_like(self, simple_frame, inplace, lower, axis, res):
+        # GH#15390
+        original = simple_frame.copy(deep=True)
+
+        result = original.clip(lower=lower, upper=[5, 6, 7], axis=axis, inplace=inplace)
+
+        expected = DataFrame(res, columns=original.columns, index=original.index)
+        if inplace:
+            result = original
+        tm.assert_frame_equal(result, expected, check_exact=True)
+
+    @pytest.mark.parametrize("axis", [0, 1, None])
+    def test_clip_against_frame(self, axis):
+        df = DataFrame(np.random.randn(1000, 2))
+        lb = DataFrame(np.random.randn(1000, 2))
+        ub = lb + 1
+
+        clipped_df = df.clip(lb, ub, axis=axis)
+
+        lb_mask = df <= lb
+        ub_mask = df >= ub
+        mask = ~lb_mask & ~ub_mask
+
+        tm.assert_frame_equal(clipped_df[lb_mask], lb[lb_mask])
+        tm.assert_frame_equal(clipped_df[ub_mask], ub[ub_mask])
+        tm.assert_frame_equal(clipped_df[mask], df[mask])
+
+    def test_clip_against_unordered_columns(self):
+        # GH#20911
+        df1 = DataFrame(np.random.randn(1000, 4), columns=["A", "B", "C", "D"])
+        df2 = DataFrame(np.random.randn(1000, 4), columns=["D", "A", "B", "C"])
+        df3 = DataFrame(df2.values - 1, columns=["B", "D", "C", "A"])
+        result_upper = df1.clip(lower=0, upper=df2)
+        expected_upper = df1.clip(lower=0, upper=df2[df1.columns])
+        result_lower = df1.clip(lower=df3, upper=3)
+        expected_lower = df1.clip(lower=df3[df1.columns], upper=3)
+        result_lower_upper = df1.clip(lower=df3, upper=df2)
+        expected_lower_upper = df1.clip(lower=df3[df1.columns], upper=df2[df1.columns])
+        tm.assert_frame_equal(result_upper, expected_upper)
+        tm.assert_frame_equal(result_lower, expected_lower)
+        tm.assert_frame_equal(result_lower_upper, expected_lower_upper)
+
+    def test_clip_with_na_args(self, float_frame):
+        """Should process np.nan argument as None"""
+        # GH#17276
+        tm.assert_frame_equal(float_frame.clip(np.nan), float_frame)
+        tm.assert_frame_equal(float_frame.clip(upper=np.nan, lower=np.nan), float_frame)
+
+        # GH#19992 and adjusted in GH#40420
+        df = DataFrame({"col_0": [1, 2, 3], "col_1": [4, 5, 6], "col_2": [7, 8, 9]})
+
+        result = df.clip(lower=[4, 5, np.nan], axis=0)
+        expected = DataFrame(
+            {"col_0": [4, 5, 3], "col_1": [4, 5, 6], "col_2": [7, 8, 9]}
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = df.clip(lower=[4, 5, np.nan], axis=1)
+        expected = DataFrame(
+            {"col_0": [4, 4, 4], "col_1": [5, 5, 6], "col_2": [7, 8, 9]}
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # GH#40420
+        data = {"col_0": [9, -3, 0, -1, 5], "col_1": [-2, -7, 6, 8, -5]}
+        df = DataFrame(data)
+        t = Series([2, -4, np.NaN, 6, 3])
+        result = df.clip(lower=t, axis=0)
+        expected = DataFrame({"col_0": [9, -3, 0, 6, 5], "col_1": [2, -4, 6, 8, 3]})
+        tm.assert_frame_equal(result, expected)
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_compare.py b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_compare.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f9fc4a7bd8cc112861b707862f55c8adb6a17f0
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_compare.py
@@ -0,0 +1,301 @@
+import numpy as np
+import pytest
+
+from pandas.compat.numpy import np_version_gte1p25
+
+import pandas as pd
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize("align_axis", [0, 1, "index", "columns"])
+def test_compare_axis(align_axis):
+    # GH#30429
+    df = pd.DataFrame(
+        {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]},
+        columns=["col1", "col2", "col3"],
+    )
+    df2 = df.copy()
+    df2.loc[0, "col1"] = "c"
+    df2.loc[2, "col3"] = 4.0
+
+    result = df.compare(df2, align_axis=align_axis)
+
+    if align_axis in (1, "columns"):
+        indices = pd.Index([0, 2])
+        columns = pd.MultiIndex.from_product([["col1", "col3"], ["self", "other"]])
+        expected = pd.DataFrame(
+            [["a", "c", np.nan, np.nan], [np.nan, np.nan, 3.0, 4.0]],
+            index=indices,
+            columns=columns,
+        )
+    else:
+        indices = pd.MultiIndex.from_product([[0, 2], ["self", "other"]])
+        columns = pd.Index(["col1", "col3"])
+        expected = pd.DataFrame(
+            [["a", np.nan], ["c", np.nan], [np.nan, 3.0], [np.nan, 4.0]],
+            index=indices,
+            columns=columns,
+        )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "keep_shape, keep_equal",
+    [
+        (True, False),
+        (False, True),
+        (True, True),
+        # False, False case is already covered in test_compare_axis
+    ],
+)
+def test_compare_various_formats(keep_shape, keep_equal):
+    df = pd.DataFrame(
+        {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]},
+        columns=["col1", "col2", "col3"],
+    )
+    df2 = df.copy()
+    df2.loc[0, "col1"] = "c"
+    df2.loc[2, "col3"] = 4.0
+
+    result = df.compare(df2, keep_shape=keep_shape, keep_equal=keep_equal)
+
+    if keep_shape:
+        indices = pd.Index([0, 1, 2])
+        columns = pd.MultiIndex.from_product(
+            [["col1", "col2", "col3"], ["self", "other"]]
+        )
+        if keep_equal:
+            expected = pd.DataFrame(
+                [
+                    ["a", "c", 1.0, 1.0, 1.0, 1.0],
+                    ["b", "b", 2.0, 2.0, 2.0, 2.0],
+                    ["c", "c", np.nan, np.nan, 3.0, 4.0],
+                ],
+                index=indices,
+                columns=columns,
+            )
+        else:
+            expected = pd.DataFrame(
+                [
+                    ["a", "c", np.nan, np.nan, np.nan, np.nan],
+                    [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
+                    [np.nan, np.nan, np.nan, np.nan, 3.0, 4.0],
+                ],
+                index=indices,
+                columns=columns,
+            )
+    else:
+        indices = pd.Index([0, 2])
+        columns = pd.MultiIndex.from_product([["col1", "col3"], ["self", "other"]])
+        expected = pd.DataFrame(
+            [["a", "c", 1.0, 1.0], ["c", "c", 3.0, 4.0]], index=indices, columns=columns
+        )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_compare_with_equal_nulls():
+    # We want to make sure two NaNs are considered the same
+    # and dropped where applicable
+    df = pd.DataFrame(
+        {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]},
+        columns=["col1", "col2", "col3"],
+    )
+    df2 = df.copy()
+    df2.loc[0, "col1"] = "c"
+
+    result = df.compare(df2)
+    indices = pd.Index([0])
+    columns = pd.MultiIndex.from_product([["col1"], ["self", "other"]])
+    expected = pd.DataFrame([["a", "c"]], index=indices, columns=columns)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_compare_with_non_equal_nulls():
+    # We want to make sure the relevant NaNs do not get dropped
+    # even if the entire row or column are NaNs
+    df = pd.DataFrame(
+        {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]},
+        columns=["col1", "col2", "col3"],
+    )
+    df2 = df.copy()
+    df2.loc[0, "col1"] = "c"
+    df2.loc[2, "col3"] = np.nan
+
+    result = df.compare(df2)
+
+    indices = pd.Index([0, 2])
+    columns = pd.MultiIndex.from_product([["col1", "col3"], ["self", "other"]])
+    expected = pd.DataFrame(
+        [["a", "c", np.nan, np.nan], [np.nan, np.nan, 3.0, np.nan]],
+        index=indices,
+        columns=columns,
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("align_axis", [0, 1])
+def test_compare_multi_index(align_axis):
+    df = pd.DataFrame(
+        {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]}
+    )
+    df.columns = pd.MultiIndex.from_arrays([["a", "a", "b"], ["col1", "col2", "col3"]])
+    df.index = pd.MultiIndex.from_arrays([["x", "x", "y"], [0, 1, 2]])
+
+    df2 = df.copy()
+    df2.iloc[0, 0] = "c"
+    df2.iloc[2, 2] = 4.0
+
+    result = df.compare(df2, align_axis=align_axis)
+
+    if align_axis == 0:
+        indices = pd.MultiIndex.from_arrays(
+            [["x", "x", "y", "y"], [0, 0, 2, 2], ["self", "other", "self", "other"]]
+        )
+        columns = pd.MultiIndex.from_arrays([["a", "b"], ["col1", "col3"]])
+        data = [["a", np.nan], ["c", np.nan], [np.nan, 3.0], [np.nan, 4.0]]
+    else:
+        indices = pd.MultiIndex.from_arrays([["x", "y"], [0, 2]])
+        columns = pd.MultiIndex.from_arrays(
+            [
+                ["a", "a", "b", "b"],
+                ["col1", "col1", "col3", "col3"],
+                ["self", "other", "self", "other"],
+            ]
+        )
+        data = [["a", "c", np.nan, np.nan], [np.nan, np.nan, 3.0, 4.0]]
+
+    expected = pd.DataFrame(data=data, index=indices, columns=columns)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_compare_unaligned_objects():
+    # test DataFrames with different indices
+    msg = (
+        r"Can only compare identically-labeled \(both index and columns\) DataFrame "
+        "objects"
+    )
+    with pytest.raises(ValueError, match=msg):
+        df1 = pd.DataFrame([1, 2, 3], index=["a", "b", "c"])
+        df2 = pd.DataFrame([1, 2, 3], index=["a", "b", "d"])
+        df1.compare(df2)
+
+    # test DataFrames with different shapes
+    msg = (
+        r"Can only compare identically-labeled \(both index and columns\) DataFrame "
+        "objects"
+    )
+    with pytest.raises(ValueError, match=msg):
+        df1 = pd.DataFrame(np.ones((3, 3)))
+        df2 = pd.DataFrame(np.zeros((2, 1)))
+        df1.compare(df2)
+
+
+def test_compare_result_names():
+    # GH 44354
+    df1 = pd.DataFrame(
+        {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]},
+    )
+    df2 = pd.DataFrame(
+        {
+            "col1": ["c", "b", "c"],
+            "col2": [1.0, 2.0, np.nan],
+            "col3": [1.0, 2.0, np.nan],
+        },
+    )
+    result = df1.compare(df2, result_names=("left", "right"))
+    expected = pd.DataFrame(
+        {
+            ("col1", "left"): {0: "a", 2: np.nan},
+            ("col1", "right"): {0: "c", 2: np.nan},
+            ("col3", "left"): {0: np.nan, 2: 3.0},
+            ("col3", "right"): {0: np.nan, 2: np.nan},
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "result_names",
+    [
+        [1, 2],
+        "HK",
+        {"2": 2, "3": 3},
+        3,
+        3.0,
+    ],
+)
+def test_invalid_input_result_names(result_names):
+    # GH 44354
+    df1 = pd.DataFrame(
+        {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]},
+    )
+    df2 = pd.DataFrame(
+        {
+            "col1": ["c", "b", "c"],
+            "col2": [1.0, 2.0, np.nan],
+            "col3": [1.0, 2.0, np.nan],
+        },
+    )
+    with pytest.raises(
+        TypeError,
+        match=(
+            f"Passing 'result_names' as a {type(result_names)} is not "
+            "supported. Provide 'result_names' as a tuple instead."
+        ),
+    ):
+        df1.compare(df2, result_names=result_names)
+
+
+@pytest.mark.parametrize(
+    "val1,val2",
+    [(4, pd.NA), (pd.NA, pd.NA), (pd.NA, 4)],
+)
+def test_compare_ea_and_np_dtype(val1, val2):
+    # GH 48966
+    arr = [4.0, val1]
+    ser = pd.Series([1, val2], dtype="Int64")
+
+    df1 = pd.DataFrame({"a": arr, "b": [1.0, 2]})
+    df2 = pd.DataFrame({"a": ser, "b": [1.0, 2]})
+    expected = pd.DataFrame(
+        {
+            ("a", "self"): arr,
+            ("a", "other"): ser,
+            ("b", "self"): np.nan,
+            ("b", "other"): np.nan,
+        }
+    )
+    if val1 is pd.NA and np_version_gte1p25:
+        # can't compare with numpy array if it contains pd.NA
+        with pytest.raises(TypeError, match="boolean value of NA is ambiguous"):
+            result = df1.compare(df2, keep_shape=True)
+    else:
+        result = df1.compare(df2, keep_shape=True)
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "df1_val,df2_val,diff_self,diff_other",
+    [
+        (4, 3, 4, 3),
+        (4, 4, pd.NA, pd.NA),
+        (4, pd.NA, 4, pd.NA),
+        (pd.NA, pd.NA, pd.NA, pd.NA),
+    ],
+)
+def test_compare_nullable_int64_dtype(df1_val, df2_val, diff_self, diff_other):
+    # GH 48966
+    df1 = pd.DataFrame({"a": pd.Series([df1_val, pd.NA], dtype="Int64"), "b": [1.0, 2]})
+    df2 = df1.copy()
+    df2.loc[0, "a"] = df2_val
+
+    expected = pd.DataFrame(
+        {
+            ("a", "self"): pd.Series([diff_self, pd.NA], dtype="Int64"),
+            ("a", "other"): pd.Series([diff_other, pd.NA], dtype="Int64"),
+            ("b", "self"): np.nan,
+            ("b", "other"): np.nan,
+        }
+    )
+    result = df1.compare(df2, keep_shape=True)
+    tm.assert_frame_equal(result, expected)
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_describe.py b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_describe.py
new file mode 100644
index 0000000000000000000000000000000000000000..fbe6ff356499fb62bf473a3162186f111a9060a3
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_describe.py
@@ -0,0 +1,417 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    DataFrame,
+    Series,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameDescribe:
+    def test_describe_bool_in_mixed_frame(self):
+        df = DataFrame(
+            {
+                "string_data": ["a", "b", "c", "d", "e"],
+                "bool_data": [True, True, False, False, False],
+                "int_data": [10, 20, 30, 40, 50],
+            }
+        )
+
+        # Integer data are included in .describe() output,
+        # Boolean and string data are not.
+        result = df.describe()
+        expected = DataFrame(
+            {"int_data": [5, 30, df.int_data.std(), 10, 20, 30, 40, 50]},
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # Top value is a boolean value that is False
+        result = df.describe(include=["bool"])
+
+        expected = DataFrame(
+            {"bool_data": [5, 2, False, 3]}, index=["count", "unique", "top", "freq"]
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_describe_empty_object(self):
+        # GH#27183
+        df = DataFrame({"A": [None, None]}, dtype=object)
+        result = df.describe()
+        expected = DataFrame(
+            {"A": [0, 0, np.nan, np.nan]},
+            dtype=object,
+            index=["count", "unique", "top", "freq"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = df.iloc[:0].describe()
+        tm.assert_frame_equal(result, expected)
+
+    def test_describe_bool_frame(self):
+        # GH#13891
+        df = DataFrame(
+            {
+                "bool_data_1": [False, False, True, True],
+                "bool_data_2": [False, True, True, True],
+            }
+        )
+        result = df.describe()
+        expected = DataFrame(
+            {"bool_data_1": [4, 2, False, 2], "bool_data_2": [4, 2, True, 3]},
+            index=["count", "unique", "top", "freq"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame(
+            {
+                "bool_data": [False, False, True, True, False],
+                "int_data": [0, 1, 2, 3, 4],
+            }
+        )
+        result = df.describe()
+        expected = DataFrame(
+            {"int_data": [5, 2, df.int_data.std(), 0, 1, 2, 3, 4]},
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame(
+            {"bool_data": [False, False, True, True], "str_data": ["a", "b", "c", "a"]}
+        )
+        result = df.describe()
+        expected = DataFrame(
+            {"bool_data": [4, 2, False, 2], "str_data": [4, 3, "a", 2]},
+            index=["count", "unique", "top", "freq"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_describe_categorical(self):
+        df = DataFrame({"value": np.random.randint(0, 10000, 100)})
+        labels = [f"{i} - {i + 499}" for i in range(0, 10000, 500)]
+        cat_labels = Categorical(labels, labels)
+
+        df = df.sort_values(by=["value"], ascending=True)
+        df["value_group"] = pd.cut(
+            df.value, range(0, 10500, 500), right=False, labels=cat_labels
+        )
+        cat = df
+
+        # Categoricals should not show up together with numerical columns
+        result = cat.describe()
+        assert len(result.columns) == 1
+
+        # In a frame, describe() for the cat should be the same as for string
+        # arrays (count, unique, top, freq)
+
+        cat = Categorical(
+            ["a", "b", "b", "b"], categories=["a", "b", "c"], ordered=True
+        )
+        s = Series(cat)
+        result = s.describe()
+        expected = Series([4, 2, "b", 3], index=["count", "unique", "top", "freq"])
+        tm.assert_series_equal(result, expected)
+
+        cat = Series(Categorical(["a", "b", "c", "c"]))
+        df3 = DataFrame({"cat": cat, "s": ["a", "b", "c", "c"]})
+        result = df3.describe()
+        tm.assert_numpy_array_equal(result["cat"].values, result["s"].values)
+
+    def test_describe_empty_categorical_column(self):
+        # GH#26397
+        # Ensure the index of an empty categorical DataFrame column
+        # also contains (count, unique, top, freq)
+        df = DataFrame({"empty_col": Categorical([])})
+        result = df.describe()
+        expected = DataFrame(
+            {"empty_col": [0, 0, np.nan, np.nan]},
+            index=["count", "unique", "top", "freq"],
+            dtype="object",
+        )
+        tm.assert_frame_equal(result, expected)
+        # ensure NaN, not None
+        assert np.isnan(result.iloc[2, 0])
+        assert np.isnan(result.iloc[3, 0])
+
+    def test_describe_categorical_columns(self):
+        # GH#11558
+        columns = pd.CategoricalIndex(["int1", "int2", "obj"], ordered=True, name="XXX")
+        df = DataFrame(
+            {
+                "int1": [10, 20, 30, 40, 50],
+                "int2": [10, 20, 30, 40, 50],
+                "obj": ["A", 0, None, "X", 1],
+            },
+            columns=columns,
+        )
+        result = df.describe()
+
+        exp_columns = pd.CategoricalIndex(
+            ["int1", "int2"],
+            categories=["int1", "int2", "obj"],
+            ordered=True,
+            name="XXX",
+        )
+        expected = DataFrame(
+            {
+                "int1": [5, 30, df.int1.std(), 10, 20, 30, 40, 50],
+                "int2": [5, 30, df.int2.std(), 10, 20, 30, 40, 50],
+            },
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+            columns=exp_columns,
+        )
+
+        tm.assert_frame_equal(result, expected)
+        tm.assert_categorical_equal(result.columns.values, expected.columns.values)
+
+    def test_describe_datetime_columns(self):
+        columns = pd.DatetimeIndex(
+            ["2011-01-01", "2011-02-01", "2011-03-01"],
+            freq="MS",
+            tz="US/Eastern",
+            name="XXX",
+        )
+        df = DataFrame(
+            {
+                0: [10, 20, 30, 40, 50],
+                1: [10, 20, 30, 40, 50],
+                2: ["A", 0, None, "X", 1],
+            }
+        )
+        df.columns = columns
+        result = df.describe()
+
+        exp_columns = pd.DatetimeIndex(
+            ["2011-01-01", "2011-02-01"], freq="MS", tz="US/Eastern", name="XXX"
+        )
+        expected = DataFrame(
+            {
+                0: [5, 30, df.iloc[:, 0].std(), 10, 20, 30, 40, 50],
+                1: [5, 30, df.iloc[:, 1].std(), 10, 20, 30, 40, 50],
+            },
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+        )
+        expected.columns = exp_columns
+        tm.assert_frame_equal(result, expected)
+        assert result.columns.freq == "MS"
+        assert result.columns.tz == expected.columns.tz
+
+    def test_describe_timedelta_values(self):
+        # GH#6145
+        t1 = pd.timedelta_range("1 days", freq="D", periods=5)
+        t2 = pd.timedelta_range("1 hours", freq="H", periods=5)
+        df = DataFrame({"t1": t1, "t2": t2})
+
+        expected = DataFrame(
+            {
+                "t1": [
+                    5,
+                    pd.Timedelta("3 days"),
+                    df.iloc[:, 0].std(),
+                    pd.Timedelta("1 days"),
+                    pd.Timedelta("2 days"),
+                    pd.Timedelta("3 days"),
+                    pd.Timedelta("4 days"),
+                    pd.Timedelta("5 days"),
+                ],
+                "t2": [
+                    5,
+                    pd.Timedelta("3 hours"),
+                    df.iloc[:, 1].std(),
+                    pd.Timedelta("1 hours"),
+                    pd.Timedelta("2 hours"),
+                    pd.Timedelta("3 hours"),
+                    pd.Timedelta("4 hours"),
+                    pd.Timedelta("5 hours"),
+                ],
+            },
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+        )
+
+        result = df.describe()
+        tm.assert_frame_equal(result, expected)
+
+        exp_repr = (
+            "                              t1                         t2\n"
+            "count                          5                          5\n"
+            "mean             3 days 00:00:00            0 days 03:00:00\n"
+            "std    1 days 13:56:50.394919273  0 days 01:34:52.099788303\n"
+            "min              1 days 00:00:00            0 days 01:00:00\n"
+            "25%              2 days 00:00:00            0 days 02:00:00\n"
+            "50%              3 days 00:00:00            0 days 03:00:00\n"
+            "75%              4 days 00:00:00            0 days 04:00:00\n"
+            "max              5 days 00:00:00            0 days 05:00:00"
+        )
+        assert repr(result) == exp_repr
+
+    def test_describe_tz_values(self, tz_naive_fixture):
+        # GH#21332
+        tz = tz_naive_fixture
+        s1 = Series(range(5))
+        start = Timestamp(2018, 1, 1)
+        end = Timestamp(2018, 1, 5)
+        s2 = Series(date_range(start, end, tz=tz))
+        df = DataFrame({"s1": s1, "s2": s2})
+
+        expected = DataFrame(
+            {
+                "s1": [5, 2, 0, 1, 2, 3, 4, 1.581139],
+                "s2": [
+                    5,
+                    Timestamp(2018, 1, 3).tz_localize(tz),
+                    start.tz_localize(tz),
+                    s2[1],
+                    s2[2],
+                    s2[3],
+                    end.tz_localize(tz),
+                    np.nan,
+                ],
+            },
+            index=["count", "mean", "min", "25%", "50%", "75%", "max", "std"],
+        )
+        result = df.describe(include="all")
+        tm.assert_frame_equal(result, expected)
+
+    def test_datetime_is_numeric_includes_datetime(self):
+        df = DataFrame({"a": date_range("2012", periods=3), "b": [1, 2, 3]})
+        result = df.describe()
+        expected = DataFrame(
+            {
+                "a": [
+                    3,
+                    Timestamp("2012-01-02"),
+                    Timestamp("2012-01-01"),
+                    Timestamp("2012-01-01T12:00:00"),
+                    Timestamp("2012-01-02"),
+                    Timestamp("2012-01-02T12:00:00"),
+                    Timestamp("2012-01-03"),
+                    np.nan,
+                ],
+                "b": [3, 2, 1, 1.5, 2, 2.5, 3, 1],
+            },
+            index=["count", "mean", "min", "25%", "50%", "75%", "max", "std"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_describe_tz_values2(self):
+        tz = "CET"
+        s1 = Series(range(5))
+        start = Timestamp(2018, 1, 1)
+        end = Timestamp(2018, 1, 5)
+        s2 = Series(date_range(start, end, tz=tz))
+        df = DataFrame({"s1": s1, "s2": s2})
+
+        s1_ = s1.describe()
+        s2_ = s2.describe()
+        idx = [
+            "count",
+            "mean",
+            "min",
+            "25%",
+            "50%",
+            "75%",
+            "max",
+            "std",
+        ]
+        expected = pd.concat([s1_, s2_], axis=1, keys=["s1", "s2"]).reindex(
+            idx, copy=False
+        )
+
+        result = df.describe(include="all")
+        tm.assert_frame_equal(result, expected)
+
+    def test_describe_percentiles_integer_idx(self):
+        # GH#26660
+        df = DataFrame({"x": [1]})
+        pct = np.linspace(0, 1, 10 + 1)
+        result = df.describe(percentiles=pct)
+
+        expected = DataFrame(
+            {"x": [1.0, 1.0, np.NaN, 1.0, *(1.0 for _ in pct), 1.0]},
+            index=[
+                "count",
+                "mean",
+                "std",
+                "min",
+                "0%",
+                "10%",
+                "20%",
+                "30%",
+                "40%",
+                "50%",
+                "60%",
+                "70%",
+                "80%",
+                "90%",
+                "100%",
+                "max",
+            ],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_describe_does_not_raise_error_for_dictlike_elements(self):
+        # GH#32409
+        df = DataFrame([{"test": {"a": "1"}}, {"test": {"a": "2"}}])
+        expected = DataFrame(
+            {"test": [2, 2, {"a": "1"}, 1]}, index=["count", "unique", "top", "freq"]
+        )
+        result = df.describe()
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("exclude", ["x", "y", ["x", "y"], ["x", "z"]])
+    def test_describe_when_include_all_exclude_not_allowed(self, exclude):
+        """
+        When include is 'all', then setting exclude != None is not allowed.
+        """
+        df = DataFrame({"x": [1], "y": [2], "z": [3]})
+        msg = "exclude must be None when include is 'all'"
+        with pytest.raises(ValueError, match=msg):
+            df.describe(include="all", exclude=exclude)
+
+    def test_describe_with_duplicate_columns(self):
+        df = DataFrame(
+            [[1, 1, 1], [2, 2, 2], [3, 3, 3]],
+            columns=["bar", "a", "a"],
+            dtype="float64",
+        )
+        result = df.describe()
+        ser = df.iloc[:, 0].describe()
+        expected = pd.concat([ser, ser, ser], keys=df.columns, axis=1)
+        tm.assert_frame_equal(result, expected)
+
+    def test_ea_with_na(self, any_numeric_ea_dtype):
+        # GH#48778
+
+        df = DataFrame({"a": [1, pd.NA, pd.NA], "b": pd.NA}, dtype=any_numeric_ea_dtype)
+        result = df.describe()
+        expected = DataFrame(
+            {"a": [1.0, 1.0, pd.NA] + [1.0] * 5, "b": [0.0] + [pd.NA] * 7},
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+            dtype="Float64",
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_describe_exclude_pa_dtype(self):
+        # GH#52570
+        pa = pytest.importorskip("pyarrow")
+        df = DataFrame(
+            {
+                "a": Series([1, 2, 3], dtype=pd.ArrowDtype(pa.int8())),
+                "b": Series([1, 2, 3], dtype=pd.ArrowDtype(pa.int16())),
+                "c": Series([1, 2, 3], dtype=pd.ArrowDtype(pa.int32())),
+            }
+        )
+        result = df.describe(
+            include=pd.ArrowDtype(pa.int8()), exclude=pd.ArrowDtype(pa.int32())
+        )
+        expected = DataFrame(
+            {"a": [3, 2, 1, 1, 1.5, 2, 2.5, 3]},
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+            dtype=pd.ArrowDtype(pa.float64()),
+        )
+        tm.assert_frame_equal(result, expected)
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_isin.py b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_isin.py
new file mode 100644
index 0000000000000000000000000000000000000000..e924963f588f3ee658326706c8efa71171094d35
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_isin.py
@@ -0,0 +1,219 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameIsIn:
+    def test_isin(self):
+        # GH#4211
+        df = DataFrame(
+            {
+                "vals": [1, 2, 3, 4],
+                "ids": ["a", "b", "f", "n"],
+                "ids2": ["a", "n", "c", "n"],
+            },
+            index=["foo", "bar", "baz", "qux"],
+        )
+        other = ["a", "b", "c"]
+
+        result = df.isin(other)
+        expected = DataFrame([df.loc[s].isin(other) for s in df.index])
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("empty", [[], Series(dtype=object), np.array([])])
+    def test_isin_empty(self, empty):
+        # GH#16991
+        df = DataFrame({"A": ["a", "b", "c"], "B": ["a", "e", "f"]})
+        expected = DataFrame(False, df.index, df.columns)
+
+        result = df.isin(empty)
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_dict(self):
+        df = DataFrame({"A": ["a", "b", "c"], "B": ["a", "e", "f"]})
+        d = {"A": ["a"]}
+
+        expected = DataFrame(False, df.index, df.columns)
+        expected.loc[0, "A"] = True
+
+        result = df.isin(d)
+        tm.assert_frame_equal(result, expected)
+
+        # non unique columns
+        df = DataFrame({"A": ["a", "b", "c"], "B": ["a", "e", "f"]})
+        df.columns = ["A", "A"]
+        expected = DataFrame(False, df.index, df.columns)
+        expected.loc[0, "A"] = True
+        result = df.isin(d)
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_with_string_scalar(self):
+        # GH#4763
+        df = DataFrame(
+            {
+                "vals": [1, 2, 3, 4],
+                "ids": ["a", "b", "f", "n"],
+                "ids2": ["a", "n", "c", "n"],
+            },
+            index=["foo", "bar", "baz", "qux"],
+        )
+        msg = (
+            r"only list-like or dict-like objects are allowed "
+            r"to be passed to DataFrame.isin\(\), you passed a 'str'"
+        )
+        with pytest.raises(TypeError, match=msg):
+            df.isin("a")
+
+        with pytest.raises(TypeError, match=msg):
+            df.isin("aaa")
+
+    def test_isin_df(self):
+        df1 = DataFrame({"A": [1, 2, 3, 4], "B": [2, np.nan, 4, 4]})
+        df2 = DataFrame({"A": [0, 2, 12, 4], "B": [2, np.nan, 4, 5]})
+        expected = DataFrame(False, df1.index, df1.columns)
+        result = df1.isin(df2)
+        expected.loc[[1, 3], "A"] = True
+        expected.loc[[0, 2], "B"] = True
+        tm.assert_frame_equal(result, expected)
+
+        # partial overlapping columns
+        df2.columns = ["A", "C"]
+        result = df1.isin(df2)
+        expected["B"] = False
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_tuples(self):
+        # GH#16394
+        df = DataFrame({"A": [1, 2, 3], "B": ["a", "b", "f"]})
+        df["C"] = list(zip(df["A"], df["B"]))
+        result = df["C"].isin([(1, "a")])
+        tm.assert_series_equal(result, Series([True, False, False], name="C"))
+
+    def test_isin_df_dupe_values(self):
+        df1 = DataFrame({"A": [1, 2, 3, 4], "B": [2, np.nan, 4, 4]})
+        # just cols duped
+        df2 = DataFrame([[0, 2], [12, 4], [2, np.nan], [4, 5]], columns=["B", "B"])
+        msg = r"cannot compute isin with a duplicate axis\."
+        with pytest.raises(ValueError, match=msg):
+            df1.isin(df2)
+
+        # just index duped
+        df2 = DataFrame(
+            [[0, 2], [12, 4], [2, np.nan], [4, 5]],
+            columns=["A", "B"],
+            index=[0, 0, 1, 1],
+        )
+        with pytest.raises(ValueError, match=msg):
+            df1.isin(df2)
+
+        # cols and index:
+        df2.columns = ["B", "B"]
+        with pytest.raises(ValueError, match=msg):
+            df1.isin(df2)
+
+    def test_isin_dupe_self(self):
+        other = DataFrame({"A": [1, 0, 1, 0], "B": [1, 1, 0, 0]})
+        df = DataFrame([[1, 1], [1, 0], [0, 0]], columns=["A", "A"])
+        result = df.isin(other)
+        expected = DataFrame(False, index=df.index, columns=df.columns)
+        expected.loc[0] = True
+        expected.iloc[1, 1] = True
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_against_series(self):
+        df = DataFrame(
+            {"A": [1, 2, 3, 4], "B": [2, np.nan, 4, 4]}, index=["a", "b", "c", "d"]
+        )
+        s = Series([1, 3, 11, 4], index=["a", "b", "c", "d"])
+        expected = DataFrame(False, index=df.index, columns=df.columns)
+        expected.loc["a", "A"] = True
+        expected.loc["d"] = True
+        result = df.isin(s)
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_multiIndex(self):
+        idx = MultiIndex.from_tuples(
+            [
+                (0, "a", "foo"),
+                (0, "a", "bar"),
+                (0, "b", "bar"),
+                (0, "b", "baz"),
+                (2, "a", "foo"),
+                (2, "a", "bar"),
+                (2, "c", "bar"),
+                (2, "c", "baz"),
+                (1, "b", "foo"),
+                (1, "b", "bar"),
+                (1, "c", "bar"),
+                (1, "c", "baz"),
+            ]
+        )
+        df1 = DataFrame({"A": np.ones(12), "B": np.zeros(12)}, index=idx)
+        df2 = DataFrame(
+            {
+                "A": [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],
+                "B": [1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1],
+            }
+        )
+        # against regular index
+        expected = DataFrame(False, index=df1.index, columns=df1.columns)
+        result = df1.isin(df2)
+        tm.assert_frame_equal(result, expected)
+
+        df2.index = idx
+        expected = df2.values.astype(bool)
+        expected[:, 1] = ~expected[:, 1]
+        expected = DataFrame(expected, columns=["A", "B"], index=idx)
+
+        result = df1.isin(df2)
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_empty_datetimelike(self):
+        # GH#15473
+        df1_ts = DataFrame({"date": pd.to_datetime(["2014-01-01", "2014-01-02"])})
+        df1_td = DataFrame({"date": [pd.Timedelta(1, "s"), pd.Timedelta(2, "s")]})
+        df2 = DataFrame({"date": []})
+        df3 = DataFrame()
+
+        expected = DataFrame({"date": [False, False]})
+
+        result = df1_ts.isin(df2)
+        tm.assert_frame_equal(result, expected)
+        result = df1_ts.isin(df3)
+        tm.assert_frame_equal(result, expected)
+
+        result = df1_td.isin(df2)
+        tm.assert_frame_equal(result, expected)
+        result = df1_td.isin(df3)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "values",
+        [
+            DataFrame({"a": [1, 2, 3]}, dtype="category"),
+            Series([1, 2, 3], dtype="category"),
+        ],
+    )
+    def test_isin_category_frame(self, values):
+        # GH#34256
+        df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        expected = DataFrame({"a": [True, True, True], "b": [False, False, False]})
+
+        result = df.isin(values)
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_read_only(self):
+        # https://github.com/pandas-dev/pandas/issues/37174
+        arr = np.array([1, 2, 3])
+        arr.setflags(write=False)
+        df = DataFrame([1, 2, 3])
+        result = df.isin(arr)
+        expected = DataFrame([True, True, True])
+        tm.assert_frame_equal(result, expected)
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_nlargest.py b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_nlargest.py
new file mode 100644
index 0000000000000000000000000000000000000000..17dea51263222242a5545aaeda891aedb07fb551
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_nlargest.py
@@ -0,0 +1,250 @@
+"""
+Note: for naming purposes, most tests are title with as e.g. "test_nlargest_foo"
+but are implicitly also testing nsmallest_foo.
+"""
+from string import ascii_lowercase
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.util.version import Version
+
+
+@pytest.fixture
+def df_duplicates():
+    return pd.DataFrame(
+        {"a": [1, 2, 3, 4, 4], "b": [1, 1, 1, 1, 1], "c": [0, 1, 2, 5, 4]},
+        index=[0, 0, 1, 1, 1],
+    )
+
+
+@pytest.fixture
+def df_strings():
+    return pd.DataFrame(
+        {
+            "a": np.random.permutation(10),
+            "b": list(ascii_lowercase[:10]),
+            "c": np.random.permutation(10).astype("float64"),
+        }
+    )
+
+
+@pytest.fixture
+def df_main_dtypes():
+    return pd.DataFrame(
+        {
+            "group": [1, 1, 2],
+            "int": [1, 2, 3],
+            "float": [4.0, 5.0, 6.0],
+            "string": list("abc"),
+            "category_string": pd.Series(list("abc")).astype("category"),
+            "category_int": [7, 8, 9],
+            "datetime": pd.date_range("20130101", periods=3),
+            "datetimetz": pd.date_range("20130101", periods=3, tz="US/Eastern"),
+            "timedelta": pd.timedelta_range("1 s", periods=3, freq="s"),
+        },
+        columns=[
+            "group",
+            "int",
+            "float",
+            "string",
+            "category_string",
+            "category_int",
+            "datetime",
+            "datetimetz",
+            "timedelta",
+        ],
+    )
+
+
+class TestNLargestNSmallest:
+    # ----------------------------------------------------------------------
+    # Top / bottom
+    @pytest.mark.parametrize(
+        "order",
+        [
+            ["a"],
+            ["c"],
+            ["a", "b"],
+            ["a", "c"],
+            ["b", "a"],
+            ["b", "c"],
+            ["a", "b", "c"],
+            ["c", "a", "b"],
+            ["c", "b", "a"],
+            ["b", "c", "a"],
+            ["b", "a", "c"],
+            # dups!
+            ["b", "c", "c"],
+        ],
+    )
+    @pytest.mark.parametrize("n", range(1, 11))
+    def test_nlargest_n(self, df_strings, nselect_method, n, order):
+        # GH#10393
+        df = df_strings
+        if "b" in order:
+            error_msg = (
+                f"Column 'b' has dtype object, "
+                f"cannot use method '{nselect_method}' with this dtype"
+            )
+            with pytest.raises(TypeError, match=error_msg):
+                getattr(df, nselect_method)(n, order)
+        else:
+            ascending = nselect_method == "nsmallest"
+            result = getattr(df, nselect_method)(n, order)
+            expected = df.sort_values(order, ascending=ascending).head(n)
+            tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "columns", [["group", "category_string"], ["group", "string"]]
+    )
+    def test_nlargest_error(self, df_main_dtypes, nselect_method, columns):
+        df = df_main_dtypes
+        col = columns[1]
+        error_msg = (
+            f"Column '{col}' has dtype {df[col].dtype}, "
+            f"cannot use method '{nselect_method}' with this dtype"
+        )
+        # escape some characters that may be in the repr
+        error_msg = (
+            error_msg.replace("(", "\\(")
+            .replace(")", "\\)")
+            .replace("[", "\\[")
+            .replace("]", "\\]")
+        )
+        with pytest.raises(TypeError, match=error_msg):
+            getattr(df, nselect_method)(2, columns)
+
+    def test_nlargest_all_dtypes(self, df_main_dtypes):
+        df = df_main_dtypes
+        df.nsmallest(2, list(set(df) - {"category_string", "string"}))
+        df.nlargest(2, list(set(df) - {"category_string", "string"}))
+
+    def test_nlargest_duplicates_on_starter_columns(self):
+        # regression test for GH#22752
+
+        df = pd.DataFrame({"a": [2, 2, 2, 1, 1, 1], "b": [1, 2, 3, 3, 2, 1]})
+
+        result = df.nlargest(4, columns=["a", "b"])
+        expected = pd.DataFrame(
+            {"a": [2, 2, 2, 1], "b": [3, 2, 1, 3]}, index=[2, 1, 0, 3]
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = df.nsmallest(4, columns=["a", "b"])
+        expected = pd.DataFrame(
+            {"a": [1, 1, 1, 2], "b": [1, 2, 3, 1]}, index=[5, 4, 3, 0]
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_nlargest_n_identical_values(self):
+        # GH#15297
+        df = pd.DataFrame({"a": [1] * 5, "b": [1, 2, 3, 4, 5]})
+
+        result = df.nlargest(3, "a")
+        expected = pd.DataFrame({"a": [1] * 3, "b": [1, 2, 3]}, index=[0, 1, 2])
+        tm.assert_frame_equal(result, expected)
+
+        result = df.nsmallest(3, "a")
+        expected = pd.DataFrame({"a": [1] * 3, "b": [1, 2, 3]})
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "order",
+        [["a", "b", "c"], ["c", "b", "a"], ["a"], ["b"], ["a", "b"], ["c", "b"]],
+    )
+    @pytest.mark.parametrize("n", range(1, 6))
+    def test_nlargest_n_duplicate_index(self, df_duplicates, n, order, request):
+        # GH#13412
+
+        df = df_duplicates
+        result = df.nsmallest(n, order)
+        expected = df.sort_values(order).head(n)
+        tm.assert_frame_equal(result, expected)
+
+        result = df.nlargest(n, order)
+        expected = df.sort_values(order, ascending=False).head(n)
+        if Version(np.__version__) >= Version("1.25") and (
+            (order == ["a"] and n in (1, 2, 3, 4)) or (order == ["a", "b"]) and n == 5
+        ):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(
+                        "pandas default unstable sorting of duplicates"
+                        "issue with numpy>=1.25 with AVX instructions"
+                    ),
+                    strict=False,
+                )
+            )
+        tm.assert_frame_equal(result, expected)
+
+    def test_nlargest_duplicate_keep_all_ties(self):
+        # GH#16818
+        df = pd.DataFrame(
+            {"a": [5, 4, 4, 2, 3, 3, 3, 3], "b": [10, 9, 8, 7, 5, 50, 10, 20]}
+        )
+        result = df.nlargest(4, "a", keep="all")
+        expected = pd.DataFrame(
+            {
+                "a": {0: 5, 1: 4, 2: 4, 4: 3, 5: 3, 6: 3, 7: 3},
+                "b": {0: 10, 1: 9, 2: 8, 4: 5, 5: 50, 6: 10, 7: 20},
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = df.nsmallest(2, "a", keep="all")
+        expected = pd.DataFrame(
+            {
+                "a": {3: 2, 4: 3, 5: 3, 6: 3, 7: 3},
+                "b": {3: 7, 4: 5, 5: 50, 6: 10, 7: 20},
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_nlargest_multiindex_column_lookup(self):
+        # Check whether tuples are correctly treated as multi-level lookups.
+        # GH#23033
+        df = pd.DataFrame(
+            columns=pd.MultiIndex.from_product([["x"], ["a", "b"]]),
+            data=[[0.33, 0.13], [0.86, 0.25], [0.25, 0.70], [0.85, 0.91]],
+        )
+
+        # nsmallest
+        result = df.nsmallest(3, ("x", "a"))
+        expected = df.iloc[[2, 0, 3]]
+        tm.assert_frame_equal(result, expected)
+
+        # nlargest
+        result = df.nlargest(3, ("x", "b"))
+        expected = df.iloc[[3, 2, 1]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_nlargest_nan(self):
+        # GH#43060
+        df = pd.DataFrame([np.nan, np.nan, 0, 1, 2, 3])
+        result = df.nlargest(5, 0)
+        expected = df.sort_values(0, ascending=False).head(5)
+        tm.assert_frame_equal(result, expected)
+
+    def test_nsmallest_nan_after_n_element(self):
+        # GH#46589
+        df = pd.DataFrame(
+            {
+                "a": [1, 2, 3, 4, 5, None, 7],
+                "b": [7, 6, 5, 4, 3, 2, 1],
+                "c": [1, 1, 2, 2, 3, 3, 3],
+            },
+            index=range(7),
+        )
+        result = df.nsmallest(5, columns=["a", "b"])
+        expected = pd.DataFrame(
+            {
+                "a": [1, 2, 3, 4, 5],
+                "b": [7, 6, 5, 4, 3],
+                "c": [1, 1, 2, 2, 3],
+            },
+            index=range(5),
+        ).astype({"a": "float"})
+        tm.assert_frame_equal(result, expected)
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_reset_index.py b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_reset_index.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a11a59cdcb58469145c5784f8251200546ecace
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_reset_index.py
@@ -0,0 +1,775 @@
+from datetime import datetime
+from itertools import product
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.common import (
+    is_float_dtype,
+    is_integer_dtype,
+)
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    CategoricalIndex,
+    DataFrame,
+    Index,
+    Interval,
+    IntervalIndex,
+    MultiIndex,
+    RangeIndex,
+    Series,
+    Timestamp,
+    cut,
+    date_range,
+)
+import pandas._testing as tm
+
+
+@pytest.fixture()
+def multiindex_df():
+    levels = [["A", ""], ["B", "b"]]
+    return DataFrame([[0, 2], [1, 3]], columns=MultiIndex.from_tuples(levels))
+
+
+class TestResetIndex:
+    def test_reset_index_empty_rangeindex(self):
+        # GH#45230
+        df = DataFrame(
+            columns=["brand"], dtype=np.int64, index=RangeIndex(0, 0, 1, name="foo")
+        )
+
+        df2 = df.set_index([df.index, "brand"])
+
+        result = df2.reset_index([1], drop=True)
+        tm.assert_frame_equal(result, df[[]], check_index_type=True)
+
+    def test_set_reset(self):
+        idx = Index([2**63, 2**63 + 5, 2**63 + 10], name="foo")
+
+        # set/reset
+        df = DataFrame({"A": [0, 1, 2]}, index=idx)
+        result = df.reset_index()
+        assert result["foo"].dtype == np.dtype("uint64")
+
+        df = result.set_index("foo")
+        tm.assert_index_equal(df.index, idx)
+
+    def test_set_index_reset_index_dt64tz(self):
+        idx = Index(date_range("20130101", periods=3, tz="US/Eastern"), name="foo")
+
+        # set/reset
+        df = DataFrame({"A": [0, 1, 2]}, index=idx)
+        result = df.reset_index()
+        assert result["foo"].dtype == "datetime64[ns, US/Eastern]"
+
+        df = result.set_index("foo")
+        tm.assert_index_equal(df.index, idx)
+
+    def test_reset_index_tz(self, tz_aware_fixture):
+        # GH 3950
+        # reset_index with single level
+        tz = tz_aware_fixture
+        idx = date_range("1/1/2011", periods=5, freq="D", tz=tz, name="idx")
+        df = DataFrame({"a": range(5), "b": ["A", "B", "C", "D", "E"]}, index=idx)
+
+        expected = DataFrame(
+            {
+                "idx": [
+                    datetime(2011, 1, 1),
+                    datetime(2011, 1, 2),
+                    datetime(2011, 1, 3),
+                    datetime(2011, 1, 4),
+                    datetime(2011, 1, 5),
+                ],
+                "a": range(5),
+                "b": ["A", "B", "C", "D", "E"],
+            },
+            columns=["idx", "a", "b"],
+        )
+        expected["idx"] = expected["idx"].apply(lambda d: Timestamp(d, tz=tz))
+        tm.assert_frame_equal(df.reset_index(), expected)
+
+    @pytest.mark.parametrize("tz", ["US/Eastern", "dateutil/US/Eastern"])
+    def test_frame_reset_index_tzaware_index(self, tz):
+        dr = date_range("2012-06-02", periods=10, tz=tz)
+        df = DataFrame(np.random.randn(len(dr)), dr)
+        roundtripped = df.reset_index().set_index("index")
+        xp = df.index.tz
+        rs = roundtripped.index.tz
+        assert xp == rs
+
+    def test_reset_index_with_intervals(self):
+        idx = IntervalIndex.from_breaks(np.arange(11), name="x")
+        original = DataFrame({"x": idx, "y": np.arange(10)})[["x", "y"]]
+
+        result = original.set_index("x")
+        expected = DataFrame({"y": np.arange(10)}, index=idx)
+        tm.assert_frame_equal(result, expected)
+
+        result2 = result.reset_index()
+        tm.assert_frame_equal(result2, original)
+
+    def test_reset_index(self, float_frame):
+        stacked = float_frame.stack()[::2]
+        stacked = DataFrame({"foo": stacked, "bar": stacked})
+
+        names = ["first", "second"]
+        stacked.index.names = names
+        deleveled = stacked.reset_index()
+        for i, (lev, level_codes) in enumerate(
+            zip(stacked.index.levels, stacked.index.codes)
+        ):
+            values = lev.take(level_codes)
+            name = names[i]
+            tm.assert_index_equal(values, Index(deleveled[name]))
+
+        stacked.index.names = [None, None]
+        deleveled2 = stacked.reset_index()
+        tm.assert_series_equal(
+            deleveled["first"], deleveled2["level_0"], check_names=False
+        )
+        tm.assert_series_equal(
+            deleveled["second"], deleveled2["level_1"], check_names=False
+        )
+
+        # default name assigned
+        rdf = float_frame.reset_index()
+        exp = Series(float_frame.index.values, name="index")
+        tm.assert_series_equal(rdf["index"], exp)
+
+        # default name assigned, corner case
+        df = float_frame.copy()
+        df["index"] = "foo"
+        rdf = df.reset_index()
+        exp = Series(float_frame.index.values, name="level_0")
+        tm.assert_series_equal(rdf["level_0"], exp)
+
+        # but this is ok
+        float_frame.index.name = "index"
+        deleveled = float_frame.reset_index()
+        tm.assert_series_equal(deleveled["index"], Series(float_frame.index))
+        tm.assert_index_equal(deleveled.index, Index(range(len(deleveled))), exact=True)
+
+        # preserve column names
+        float_frame.columns.name = "columns"
+        reset = float_frame.reset_index()
+        assert reset.columns.name == "columns"
+
+        # only remove certain columns
+        df = float_frame.reset_index().set_index(["index", "A", "B"])
+        rs = df.reset_index(["A", "B"])
+
+        tm.assert_frame_equal(rs, float_frame)
+
+        rs = df.reset_index(["index", "A", "B"])
+        tm.assert_frame_equal(rs, float_frame.reset_index())
+
+        rs = df.reset_index(["index", "A", "B"])
+        tm.assert_frame_equal(rs, float_frame.reset_index())
+
+        rs = df.reset_index("A")
+        xp = float_frame.reset_index().set_index(["index", "B"])
+        tm.assert_frame_equal(rs, xp)
+
+        # test resetting in place
+        df = float_frame.copy()
+        reset = float_frame.reset_index()
+        return_value = df.reset_index(inplace=True)
+        assert return_value is None
+        tm.assert_frame_equal(df, reset)
+
+        df = float_frame.reset_index().set_index(["index", "A", "B"])
+        rs = df.reset_index("A", drop=True)
+        xp = float_frame.copy()
+        del xp["A"]
+        xp = xp.set_index(["B"], append=True)
+        tm.assert_frame_equal(rs, xp)
+
+    def test_reset_index_name(self):
+        df = DataFrame(
+            [[1, 2, 3, 4], [5, 6, 7, 8]],
+            columns=["A", "B", "C", "D"],
+            index=Index(range(2), name="x"),
+        )
+        assert df.reset_index().index.name is None
+        assert df.reset_index(drop=True).index.name is None
+        return_value = df.reset_index(inplace=True)
+        assert return_value is None
+        assert df.index.name is None
+
+    @pytest.mark.parametrize("levels", [["A", "B"], [0, 1]])
+    def test_reset_index_level(self, levels):
+        df = DataFrame([[1, 2, 3, 4], [5, 6, 7, 8]], columns=["A", "B", "C", "D"])
+
+        # With MultiIndex
+        result = df.set_index(["A", "B"]).reset_index(level=levels[0])
+        tm.assert_frame_equal(result, df.set_index("B"))
+
+        result = df.set_index(["A", "B"]).reset_index(level=levels[:1])
+        tm.assert_frame_equal(result, df.set_index("B"))
+
+        result = df.set_index(["A", "B"]).reset_index(level=levels)
+        tm.assert_frame_equal(result, df)
+
+        result = df.set_index(["A", "B"]).reset_index(level=levels, drop=True)
+        tm.assert_frame_equal(result, df[["C", "D"]])
+
+        # With single-level Index (GH 16263)
+        result = df.set_index("A").reset_index(level=levels[0])
+        tm.assert_frame_equal(result, df)
+
+        result = df.set_index("A").reset_index(level=levels[:1])
+        tm.assert_frame_equal(result, df)
+
+        result = df.set_index(["A"]).reset_index(level=levels[0], drop=True)
+        tm.assert_frame_equal(result, df[["B", "C", "D"]])
+
+    @pytest.mark.parametrize("idx_lev", [["A", "B"], ["A"]])
+    def test_reset_index_level_missing(self, idx_lev):
+        # Missing levels - for both MultiIndex and single-level Index:
+        df = DataFrame([[1, 2, 3, 4], [5, 6, 7, 8]], columns=["A", "B", "C", "D"])
+
+        with pytest.raises(KeyError, match=r"(L|l)evel \(?E\)?"):
+            df.set_index(idx_lev).reset_index(level=["A", "E"])
+        with pytest.raises(IndexError, match="Too many levels"):
+            df.set_index(idx_lev).reset_index(level=[0, 1, 2])
+
+    def test_reset_index_right_dtype(self):
+        time = np.arange(0.0, 10, np.sqrt(2) / 2)
+        s1 = Series(
+            (9.81 * time**2) / 2, index=Index(time, name="time"), name="speed"
+        )
+        df = DataFrame(s1)
+
+        reset = s1.reset_index()
+        assert reset["time"].dtype == np.float64
+
+        reset = df.reset_index()
+        assert reset["time"].dtype == np.float64
+
+    def test_reset_index_multiindex_col(self):
+        vals = np.random.randn(3, 3).astype(object)
+        idx = ["x", "y", "z"]
+        full = np.hstack(([[x] for x in idx], vals))
+        df = DataFrame(
+            vals,
+            Index(idx, name="a"),
+            columns=[["b", "b", "c"], ["mean", "median", "mean"]],
+        )
+        rs = df.reset_index()
+        xp = DataFrame(
+            full, columns=[["a", "b", "b", "c"], ["", "mean", "median", "mean"]]
+        )
+        tm.assert_frame_equal(rs, xp)
+
+        rs = df.reset_index(col_fill=None)
+        xp = DataFrame(
+            full, columns=[["a", "b", "b", "c"], ["a", "mean", "median", "mean"]]
+        )
+        tm.assert_frame_equal(rs, xp)
+
+        rs = df.reset_index(col_level=1, col_fill="blah")
+        xp = DataFrame(
+            full, columns=[["blah", "b", "b", "c"], ["a", "mean", "median", "mean"]]
+        )
+        tm.assert_frame_equal(rs, xp)
+
+        df = DataFrame(
+            vals,
+            MultiIndex.from_arrays([[0, 1, 2], ["x", "y", "z"]], names=["d", "a"]),
+            columns=[["b", "b", "c"], ["mean", "median", "mean"]],
+        )
+        rs = df.reset_index("a")
+        xp = DataFrame(
+            full,
+            Index([0, 1, 2], name="d"),
+            columns=[["a", "b", "b", "c"], ["", "mean", "median", "mean"]],
+        )
+        tm.assert_frame_equal(rs, xp)
+
+        rs = df.reset_index("a", col_fill=None)
+        xp = DataFrame(
+            full,
+            Index(range(3), name="d"),
+            columns=[["a", "b", "b", "c"], ["a", "mean", "median", "mean"]],
+        )
+        tm.assert_frame_equal(rs, xp)
+
+        rs = df.reset_index("a", col_fill="blah", col_level=1)
+        xp = DataFrame(
+            full,
+            Index(range(3), name="d"),
+            columns=[["blah", "b", "b", "c"], ["a", "mean", "median", "mean"]],
+        )
+        tm.assert_frame_equal(rs, xp)
+
+    def test_reset_index_multiindex_nan(self):
+        # GH#6322, testing reset_index on MultiIndexes
+        # when we have a nan or all nan
+        df = DataFrame(
+            {"A": ["a", "b", "c"], "B": [0, 1, np.nan], "C": np.random.rand(3)}
+        )
+        rs = df.set_index(["A", "B"]).reset_index()
+        tm.assert_frame_equal(rs, df)
+
+        df = DataFrame(
+            {"A": [np.nan, "b", "c"], "B": [0, 1, 2], "C": np.random.rand(3)}
+        )
+        rs = df.set_index(["A", "B"]).reset_index()
+        tm.assert_frame_equal(rs, df)
+
+        df = DataFrame({"A": ["a", "b", "c"], "B": [0, 1, 2], "C": [np.nan, 1.1, 2.2]})
+        rs = df.set_index(["A", "B"]).reset_index()
+        tm.assert_frame_equal(rs, df)
+
+        df = DataFrame(
+            {
+                "A": ["a", "b", "c"],
+                "B": [np.nan, np.nan, np.nan],
+                "C": np.random.rand(3),
+            }
+        )
+        rs = df.set_index(["A", "B"]).reset_index()
+        tm.assert_frame_equal(rs, df)
+
+    @pytest.mark.parametrize(
+        "name",
+        [
+            None,
+            "foo",
+            2,
+            3.0,
+            pd.Timedelta(6),
+            Timestamp("2012-12-30", tz="UTC"),
+            "2012-12-31",
+        ],
+    )
+    def test_reset_index_with_datetimeindex_cols(self, name):
+        # GH#5818
+        df = DataFrame(
+            [[1, 2], [3, 4]],
+            columns=date_range("1/1/2013", "1/2/2013"),
+            index=["A", "B"],
+        )
+        df.index.name = name
+
+        result = df.reset_index()
+
+        item = name if name is not None else "index"
+        columns = Index([item, datetime(2013, 1, 1), datetime(2013, 1, 2)])
+        if isinstance(item, str) and item == "2012-12-31":
+            columns = columns.astype("datetime64[ns]")
+        else:
+            assert columns.dtype == object
+
+        expected = DataFrame(
+            [["A", 1, 2], ["B", 3, 4]],
+            columns=columns,
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_reset_index_range(self):
+        # GH#12071
+        df = DataFrame([[0, 0], [1, 1]], columns=["A", "B"], index=RangeIndex(stop=2))
+        result = df.reset_index()
+        assert isinstance(result.index, RangeIndex)
+        expected = DataFrame(
+            [[0, 0, 0], [1, 1, 1]],
+            columns=["index", "A", "B"],
+            index=RangeIndex(stop=2),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_reset_index_multiindex_columns(self, multiindex_df):
+        result = multiindex_df[["B"]].rename_axis("A").reset_index()
+        tm.assert_frame_equal(result, multiindex_df)
+
+        # GH#16120: already existing column
+        msg = r"cannot insert \('A', ''\), already exists"
+        with pytest.raises(ValueError, match=msg):
+            multiindex_df.rename_axis("A").reset_index()
+
+        # GH#16164: multiindex (tuple) full key
+        result = multiindex_df.set_index([("A", "")]).reset_index()
+        tm.assert_frame_equal(result, multiindex_df)
+
+        # with additional (unnamed) index level
+        idx_col = DataFrame(
+            [[0], [1]], columns=MultiIndex.from_tuples([("level_0", "")])
+        )
+        expected = pd.concat([idx_col, multiindex_df[[("B", "b"), ("A", "")]]], axis=1)
+        result = multiindex_df.set_index([("B", "b")], append=True).reset_index()
+        tm.assert_frame_equal(result, expected)
+
+        # with index name which is a too long tuple...
+        msg = "Item must have length equal to number of levels."
+        with pytest.raises(ValueError, match=msg):
+            multiindex_df.rename_axis([("C", "c", "i")]).reset_index()
+
+        # or too short...
+        levels = [["A", "a", ""], ["B", "b", "i"]]
+        df2 = DataFrame([[0, 2], [1, 3]], columns=MultiIndex.from_tuples(levels))
+        idx_col = DataFrame(
+            [[0], [1]], columns=MultiIndex.from_tuples([("C", "c", "ii")])
+        )
+        expected = pd.concat([idx_col, df2], axis=1)
+        result = df2.rename_axis([("C", "c")]).reset_index(col_fill="ii")
+        tm.assert_frame_equal(result, expected)
+
+        # ... which is incompatible with col_fill=None
+        with pytest.raises(
+            ValueError,
+            match=(
+                "col_fill=None is incompatible with "
+                r"incomplete column name \('C', 'c'\)"
+            ),
+        ):
+            df2.rename_axis([("C", "c")]).reset_index(col_fill=None)
+
+        # with col_level != 0
+        result = df2.rename_axis([("c", "ii")]).reset_index(col_level=1, col_fill="C")
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("flag", [False, True])
+    @pytest.mark.parametrize("allow_duplicates", [False, True])
+    def test_reset_index_duplicate_columns_allow(
+        self, multiindex_df, flag, allow_duplicates
+    ):
+        # GH#44755 reset_index with duplicate column labels
+        df = multiindex_df.rename_axis("A")
+        df = df.set_flags(allows_duplicate_labels=flag)
+
+        if flag and allow_duplicates:
+            result = df.reset_index(allow_duplicates=allow_duplicates)
+            levels = [["A", ""], ["A", ""], ["B", "b"]]
+            expected = DataFrame(
+                [[0, 0, 2], [1, 1, 3]], columns=MultiIndex.from_tuples(levels)
+            )
+            tm.assert_frame_equal(result, expected)
+        else:
+            if not flag and allow_duplicates:
+                msg = (
+                    "Cannot specify 'allow_duplicates=True' when "
+                    "'self.flags.allows_duplicate_labels' is False"
+                )
+            else:
+                msg = r"cannot insert \('A', ''\), already exists"
+            with pytest.raises(ValueError, match=msg):
+                df.reset_index(allow_duplicates=allow_duplicates)
+
+    @pytest.mark.parametrize("flag", [False, True])
+    def test_reset_index_duplicate_columns_default(self, multiindex_df, flag):
+        df = multiindex_df.rename_axis("A")
+        df = df.set_flags(allows_duplicate_labels=flag)
+
+        msg = r"cannot insert \('A', ''\), already exists"
+        with pytest.raises(ValueError, match=msg):
+            df.reset_index()
+
+    @pytest.mark.parametrize("allow_duplicates", ["bad value"])
+    def test_reset_index_allow_duplicates_check(self, multiindex_df, allow_duplicates):
+        with pytest.raises(ValueError, match="expected type bool"):
+            multiindex_df.reset_index(allow_duplicates=allow_duplicates)
+
+    def test_reset_index_datetime(self, tz_naive_fixture):
+        # GH#3950
+        tz = tz_naive_fixture
+        idx1 = date_range("1/1/2011", periods=5, freq="D", tz=tz, name="idx1")
+        idx2 = Index(range(5), name="idx2", dtype="int64")
+        idx = MultiIndex.from_arrays([idx1, idx2])
+        df = DataFrame(
+            {"a": np.arange(5, dtype="int64"), "b": ["A", "B", "C", "D", "E"]},
+            index=idx,
+        )
+
+        expected = DataFrame(
+            {
+                "idx1": [
+                    datetime(2011, 1, 1),
+                    datetime(2011, 1, 2),
+                    datetime(2011, 1, 3),
+                    datetime(2011, 1, 4),
+                    datetime(2011, 1, 5),
+                ],
+                "idx2": np.arange(5, dtype="int64"),
+                "a": np.arange(5, dtype="int64"),
+                "b": ["A", "B", "C", "D", "E"],
+            },
+            columns=["idx1", "idx2", "a", "b"],
+        )
+        expected["idx1"] = expected["idx1"].apply(lambda d: Timestamp(d, tz=tz))
+
+        tm.assert_frame_equal(df.reset_index(), expected)
+
+        idx3 = date_range(
+            "1/1/2012", periods=5, freq="MS", tz="Europe/Paris", name="idx3"
+        )
+        idx = MultiIndex.from_arrays([idx1, idx2, idx3])
+        df = DataFrame(
+            {"a": np.arange(5, dtype="int64"), "b": ["A", "B", "C", "D", "E"]},
+            index=idx,
+        )
+
+        expected = DataFrame(
+            {
+                "idx1": [
+                    datetime(2011, 1, 1),
+                    datetime(2011, 1, 2),
+                    datetime(2011, 1, 3),
+                    datetime(2011, 1, 4),
+                    datetime(2011, 1, 5),
+                ],
+                "idx2": np.arange(5, dtype="int64"),
+                "idx3": [
+                    datetime(2012, 1, 1),
+                    datetime(2012, 2, 1),
+                    datetime(2012, 3, 1),
+                    datetime(2012, 4, 1),
+                    datetime(2012, 5, 1),
+                ],
+                "a": np.arange(5, dtype="int64"),
+                "b": ["A", "B", "C", "D", "E"],
+            },
+            columns=["idx1", "idx2", "idx3", "a", "b"],
+        )
+        expected["idx1"] = expected["idx1"].apply(lambda d: Timestamp(d, tz=tz))
+        expected["idx3"] = expected["idx3"].apply(
+            lambda d: Timestamp(d, tz="Europe/Paris")
+        )
+        tm.assert_frame_equal(df.reset_index(), expected)
+
+        # GH#7793
+        idx = MultiIndex.from_product(
+            [["a", "b"], date_range("20130101", periods=3, tz=tz)]
+        )
+        df = DataFrame(
+            np.arange(6, dtype="int64").reshape(6, 1), columns=["a"], index=idx
+        )
+
+        expected = DataFrame(
+            {
+                "level_0": "a a a b b b".split(),
+                "level_1": [
+                    datetime(2013, 1, 1),
+                    datetime(2013, 1, 2),
+                    datetime(2013, 1, 3),
+                ]
+                * 2,
+                "a": np.arange(6, dtype="int64"),
+            },
+            columns=["level_0", "level_1", "a"],
+        )
+        expected["level_1"] = expected["level_1"].apply(lambda d: Timestamp(d, tz=tz))
+        result = df.reset_index()
+        tm.assert_frame_equal(result, expected)
+
+    def test_reset_index_period(self):
+        # GH#7746
+        idx = MultiIndex.from_product(
+            [pd.period_range("20130101", periods=3, freq="M"), list("abc")],
+            names=["month", "feature"],
+        )
+
+        df = DataFrame(
+            np.arange(9, dtype="int64").reshape(-1, 1), index=idx, columns=["a"]
+        )
+        expected = DataFrame(
+            {
+                "month": (
+                    [pd.Period("2013-01", freq="M")] * 3
+                    + [pd.Period("2013-02", freq="M")] * 3
+                    + [pd.Period("2013-03", freq="M")] * 3
+                ),
+                "feature": ["a", "b", "c"] * 3,
+                "a": np.arange(9, dtype="int64"),
+            },
+            columns=["month", "feature", "a"],
+        )
+        result = df.reset_index()
+        tm.assert_frame_equal(result, expected)
+
+    def test_reset_index_delevel_infer_dtype(self):
+        tuples = list(product(["foo", "bar"], [10, 20], [1.0, 1.1]))
+        index = MultiIndex.from_tuples(tuples, names=["prm0", "prm1", "prm2"])
+        df = DataFrame(np.random.randn(8, 3), columns=["A", "B", "C"], index=index)
+        deleveled = df.reset_index()
+        assert is_integer_dtype(deleveled["prm1"])
+        assert is_float_dtype(deleveled["prm2"])
+
+    def test_reset_index_with_drop(
+        self, multiindex_year_month_day_dataframe_random_data
+    ):
+        ymd = multiindex_year_month_day_dataframe_random_data
+
+        deleveled = ymd.reset_index(drop=True)
+        assert len(deleveled.columns) == len(ymd.columns)
+        assert deleveled.index.name == ymd.index.name
+
+    @pytest.mark.parametrize(
+        "ix_data, exp_data",
+        [
+            (
+                [(pd.NaT, 1), (pd.NaT, 2)],
+                {"a": [pd.NaT, pd.NaT], "b": [1, 2], "x": [11, 12]},
+            ),
+            (
+                [(pd.NaT, 1), (Timestamp("2020-01-01"), 2)],
+                {"a": [pd.NaT, Timestamp("2020-01-01")], "b": [1, 2], "x": [11, 12]},
+            ),
+            (
+                [(pd.NaT, 1), (pd.Timedelta(123, "d"), 2)],
+                {"a": [pd.NaT, pd.Timedelta(123, "d")], "b": [1, 2], "x": [11, 12]},
+            ),
+        ],
+    )
+    def test_reset_index_nat_multiindex(self, ix_data, exp_data):
+        # GH#36541: that reset_index() does not raise ValueError
+        ix = MultiIndex.from_tuples(ix_data, names=["a", "b"])
+        result = DataFrame({"x": [11, 12]}, index=ix)
+        result = result.reset_index()
+
+        expected = DataFrame(exp_data)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "codes", ([[0, 0, 1, 1], [0, 1, 0, 1]], [[0, 0, -1, 1], [0, 1, 0, 1]])
+    )
+    def test_rest_index_multiindex_categorical_with_missing_values(self, codes):
+        # GH#24206
+
+        index = MultiIndex(
+            [CategoricalIndex(["A", "B"]), CategoricalIndex(["a", "b"])], codes
+        )
+        data = {"col": range(len(index))}
+        df = DataFrame(data=data, index=index)
+
+        expected = DataFrame(
+            {
+                "level_0": Categorical.from_codes(codes[0], categories=["A", "B"]),
+                "level_1": Categorical.from_codes(codes[1], categories=["a", "b"]),
+                "col": range(4),
+            }
+        )
+
+        res = df.reset_index()
+        tm.assert_frame_equal(res, expected)
+
+        # roundtrip
+        res = expected.set_index(["level_0", "level_1"]).reset_index()
+        tm.assert_frame_equal(res, expected)
+
+
+@pytest.mark.parametrize(
+    "array, dtype",
+    [
+        (["a", "b"], object),
+        (
+            pd.period_range("12-1-2000", periods=2, freq="Q-DEC"),
+            pd.PeriodDtype(freq="Q-DEC"),
+        ),
+    ],
+)
+def test_reset_index_dtypes_on_empty_frame_with_multiindex(array, dtype):
+    # GH 19602 - Preserve dtype on empty DataFrame with MultiIndex
+    idx = MultiIndex.from_product([[0, 1], [0.5, 1.0], array])
+    result = DataFrame(index=idx)[:0].reset_index().dtypes
+    expected = Series({"level_0": np.int64, "level_1": np.float64, "level_2": dtype})
+    tm.assert_series_equal(result, expected)
+
+
+def test_reset_index_empty_frame_with_datetime64_multiindex():
+    # https://github.com/pandas-dev/pandas/issues/35606
+    idx = MultiIndex(
+        levels=[[Timestamp("2020-07-20 00:00:00")], [3, 4]],
+        codes=[[], []],
+        names=["a", "b"],
+    )
+    df = DataFrame(index=idx, columns=["c", "d"])
+    result = df.reset_index()
+    expected = DataFrame(
+        columns=list("abcd"), index=RangeIndex(start=0, stop=0, step=1)
+    )
+    expected["a"] = expected["a"].astype("datetime64[ns]")
+    expected["b"] = expected["b"].astype("int64")
+    tm.assert_frame_equal(result, expected)
+
+
+def test_reset_index_empty_frame_with_datetime64_multiindex_from_groupby():
+    # https://github.com/pandas-dev/pandas/issues/35657
+    df = DataFrame({"c1": [10.0], "c2": ["a"], "c3": pd.to_datetime("2020-01-01")})
+    df = df.head(0).groupby(["c2", "c3"])[["c1"]].sum()
+    result = df.reset_index()
+    expected = DataFrame(
+        columns=["c2", "c3", "c1"], index=RangeIndex(start=0, stop=0, step=1)
+    )
+    expected["c3"] = expected["c3"].astype("datetime64[ns]")
+    expected["c1"] = expected["c1"].astype("float64")
+    tm.assert_frame_equal(result, expected)
+
+
+def test_reset_index_multiindex_nat():
+    # GH 11479
+    idx = range(3)
+    tstamp = date_range("2015-07-01", freq="D", periods=3)
+    df = DataFrame({"id": idx, "tstamp": tstamp, "a": list("abc")})
+    df.loc[2, "tstamp"] = pd.NaT
+    result = df.set_index(["id", "tstamp"]).reset_index("id")
+    expected = DataFrame(
+        {"id": range(3), "a": list("abc")},
+        index=pd.DatetimeIndex(["2015-07-01", "2015-07-02", "NaT"], name="tstamp"),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_reset_index_interval_columns_object_cast():
+    # GH 19136
+    df = DataFrame(
+        np.eye(2), index=Index([1, 2], name="Year"), columns=cut([1, 2], [0, 1, 2])
+    )
+    result = df.reset_index()
+    expected = DataFrame(
+        [[1, 1.0, 0.0], [2, 0.0, 1.0]],
+        columns=Index(["Year", Interval(0, 1), Interval(1, 2)]),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_reset_index_rename(float_frame):
+    # GH 6878
+    result = float_frame.reset_index(names="new_name")
+    expected = Series(float_frame.index.values, name="new_name")
+    tm.assert_series_equal(result["new_name"], expected)
+
+    result = float_frame.reset_index(names=123)
+    expected = Series(float_frame.index.values, name=123)
+    tm.assert_series_equal(result[123], expected)
+
+
+def test_reset_index_rename_multiindex(float_frame):
+    # GH 6878
+    stacked_df = float_frame.stack()[::2]
+    stacked_df = DataFrame({"foo": stacked_df, "bar": stacked_df})
+
+    names = ["first", "second"]
+    stacked_df.index.names = names
+
+    result = stacked_df.reset_index()
+    expected = stacked_df.reset_index(names=["new_first", "new_second"])
+    tm.assert_series_equal(result["first"], expected["new_first"], check_names=False)
+    tm.assert_series_equal(result["second"], expected["new_second"], check_names=False)
+
+
+def test_errorreset_index_rename(float_frame):
+    # GH 6878
+    stacked_df = float_frame.stack()[::2]
+    stacked_df = DataFrame({"first": stacked_df, "second": stacked_df})
+
+    with pytest.raises(
+        ValueError, match="Index names must be str or 1-dimensional list"
+    ):
+        stacked_df.reset_index(names={"first": "new_first", "second": "new_second"})
+
+    with pytest.raises(IndexError, match="list index out of range"):
+        stacked_df.reset_index(names=["new_first"])
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_to_csv.py b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_to_csv.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a68876d7e11aa06216c65f9f4adfc6cb4a210ef
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_to_csv.py
@@ -0,0 +1,1308 @@
+import csv
+from io import StringIO
+import os
+
+import numpy as np
+import pytest
+
+from pandas.errors import ParserError
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    NaT,
+    Series,
+    Timestamp,
+    date_range,
+    read_csv,
+    to_datetime,
+)
+import pandas._testing as tm
+import pandas.core.common as com
+
+from pandas.io.common import get_handle
+
+
+class TestDataFrameToCSV:
+    def read_csv(self, path, **kwargs):
+        params = {"index_col": 0}
+        params.update(**kwargs)
+
+        return read_csv(path, **params)
+
+    def test_to_csv_from_csv1(self, float_frame, datetime_frame):
+        with tm.ensure_clean("__tmp_to_csv_from_csv1__") as path:
+            float_frame.iloc[:5, float_frame.columns.get_loc("A")] = np.nan
+
+            float_frame.to_csv(path)
+            float_frame.to_csv(path, columns=["A", "B"])
+            float_frame.to_csv(path, header=False)
+            float_frame.to_csv(path, index=False)
+
+            # test roundtrip
+            # freq does not roundtrip
+            datetime_frame.index = datetime_frame.index._with_freq(None)
+            datetime_frame.to_csv(path)
+            recons = self.read_csv(path, parse_dates=True)
+            tm.assert_frame_equal(datetime_frame, recons)
+
+            datetime_frame.to_csv(path, index_label="index")
+            recons = self.read_csv(path, index_col=None, parse_dates=True)
+
+            assert len(recons.columns) == len(datetime_frame.columns) + 1
+
+            # no index
+            datetime_frame.to_csv(path, index=False)
+            recons = self.read_csv(path, index_col=None, parse_dates=True)
+            tm.assert_almost_equal(datetime_frame.values, recons.values)
+
+            # corner case
+            dm = DataFrame(
+                {
+                    "s1": Series(range(3), index=np.arange(3, dtype=np.int64)),
+                    "s2": Series(range(2), index=np.arange(2, dtype=np.int64)),
+                }
+            )
+            dm.to_csv(path)
+
+            recons = self.read_csv(path)
+            tm.assert_frame_equal(dm, recons)
+
+    def test_to_csv_from_csv2(self, float_frame):
+        with tm.ensure_clean("__tmp_to_csv_from_csv2__") as path:
+            # duplicate index
+            df = DataFrame(
+                np.random.randn(3, 3), index=["a", "a", "b"], columns=["x", "y", "z"]
+            )
+            df.to_csv(path)
+            result = self.read_csv(path)
+            tm.assert_frame_equal(result, df)
+
+            midx = MultiIndex.from_tuples([("A", 1, 2), ("A", 1, 2), ("B", 1, 2)])
+            df = DataFrame(np.random.randn(3, 3), index=midx, columns=["x", "y", "z"])
+
+            df.to_csv(path)
+            result = self.read_csv(path, index_col=[0, 1, 2], parse_dates=False)
+            tm.assert_frame_equal(result, df, check_names=False)
+
+            # column aliases
+            col_aliases = Index(["AA", "X", "Y", "Z"])
+            float_frame.to_csv(path, header=col_aliases)
+
+            rs = self.read_csv(path)
+            xp = float_frame.copy()
+            xp.columns = col_aliases
+            tm.assert_frame_equal(xp, rs)
+
+            msg = "Writing 4 cols but got 2 aliases"
+            with pytest.raises(ValueError, match=msg):
+                float_frame.to_csv(path, header=["AA", "X"])
+
+    def test_to_csv_from_csv3(self):
+        with tm.ensure_clean("__tmp_to_csv_from_csv3__") as path:
+            df1 = DataFrame(np.random.randn(3, 1))
+            df2 = DataFrame(np.random.randn(3, 1))
+
+            df1.to_csv(path)
+            df2.to_csv(path, mode="a", header=False)
+            xp = pd.concat([df1, df2])
+            rs = read_csv(path, index_col=0)
+            rs.columns = [int(label) for label in rs.columns]
+            xp.columns = [int(label) for label in xp.columns]
+            tm.assert_frame_equal(xp, rs)
+
+    def test_to_csv_from_csv4(self):
+        with tm.ensure_clean("__tmp_to_csv_from_csv4__") as path:
+            # GH 10833 (TimedeltaIndex formatting)
+            dt = pd.Timedelta(seconds=1)
+            df = DataFrame(
+                {"dt_data": [i * dt for i in range(3)]},
+                index=Index([i * dt for i in range(3)], name="dt_index"),
+            )
+            df.to_csv(path)
+
+            result = read_csv(path, index_col="dt_index")
+            result.index = pd.to_timedelta(result.index)
+            result["dt_data"] = pd.to_timedelta(result["dt_data"])
+
+            tm.assert_frame_equal(df, result, check_index_type=True)
+
+    def test_to_csv_from_csv5(self, timezone_frame):
+        # tz, 8260
+        with tm.ensure_clean("__tmp_to_csv_from_csv5__") as path:
+            timezone_frame.to_csv(path)
+            result = read_csv(path, index_col=0, parse_dates=["A"])
+
+            converter = (
+                lambda c: to_datetime(result[c])
+                .dt.tz_convert("UTC")
+                .dt.tz_convert(timezone_frame[c].dt.tz)
+            )
+            result["B"] = converter("B")
+            result["C"] = converter("C")
+            tm.assert_frame_equal(result, timezone_frame)
+
+    def test_to_csv_cols_reordering(self):
+        # GH3454
+        chunksize = 5
+        N = int(chunksize * 2.5)
+
+        df = tm.makeCustomDataframe(N, 3)
+        cs = df.columns
+        cols = [cs[2], cs[0]]
+
+        with tm.ensure_clean() as path:
+            df.to_csv(path, columns=cols, chunksize=chunksize)
+            rs_c = read_csv(path, index_col=0)
+
+        tm.assert_frame_equal(df[cols], rs_c, check_names=False)
+
+    @pytest.mark.parametrize("cols", [None, ["b", "a"]])
+    def test_to_csv_new_dupe_cols(self, cols):
+        chunksize = 5
+        N = int(chunksize * 2.5)
+
+        # dupe cols
+        df = tm.makeCustomDataframe(N, 3)
+        df.columns = ["a", "a", "b"]
+        with tm.ensure_clean() as path:
+            df.to_csv(path, columns=cols, chunksize=chunksize)
+            rs_c = read_csv(path, index_col=0)
+
+            # we wrote them in a different order
+            # so compare them in that order
+            if cols is not None:
+                if df.columns.is_unique:
+                    rs_c.columns = cols
+                else:
+                    indexer, missing = df.columns.get_indexer_non_unique(cols)
+                    rs_c.columns = df.columns.take(indexer)
+
+                for c in cols:
+                    obj_df = df[c]
+                    obj_rs = rs_c[c]
+                    if isinstance(obj_df, Series):
+                        tm.assert_series_equal(obj_df, obj_rs)
+                    else:
+                        tm.assert_frame_equal(obj_df, obj_rs, check_names=False)
+
+            # wrote in the same order
+            else:
+                rs_c.columns = df.columns
+                tm.assert_frame_equal(df, rs_c, check_names=False)
+
+    @pytest.mark.slow
+    def test_to_csv_dtnat(self):
+        # GH3437
+        def make_dtnat_arr(n, nnat=None):
+            if nnat is None:
+                nnat = int(n * 0.1)  # 10%
+            s = list(date_range("2000", freq="5min", periods=n))
+            if nnat:
+                for i in np.random.randint(0, len(s), nnat):
+                    s[i] = NaT
+                i = np.random.randint(100)
+                s[-i] = NaT
+                s[i] = NaT
+            return s
+
+        chunksize = 1000
+        s1 = make_dtnat_arr(chunksize + 5)
+        s2 = make_dtnat_arr(chunksize + 5, 0)
+
+        with tm.ensure_clean("1.csv") as pth:
+            df = DataFrame({"a": s1, "b": s2})
+            df.to_csv(pth, chunksize=chunksize)
+
+            recons = self.read_csv(pth).apply(to_datetime)
+            tm.assert_frame_equal(df, recons, check_names=False)
+
+    def _return_result_expected(
+        self,
+        df,
+        chunksize,
+        r_dtype=None,
+        c_dtype=None,
+        rnlvl=None,
+        cnlvl=None,
+        dupe_col=False,
+    ):
+        kwargs = {"parse_dates": False}
+        if cnlvl:
+            if rnlvl is not None:
+                kwargs["index_col"] = list(range(rnlvl))
+            kwargs["header"] = list(range(cnlvl))
+
+            with tm.ensure_clean("__tmp_to_csv_moar__") as path:
+                df.to_csv(path, encoding="utf8", chunksize=chunksize)
+                recons = self.read_csv(path, **kwargs)
+        else:
+            kwargs["header"] = 0
+
+            with tm.ensure_clean("__tmp_to_csv_moar__") as path:
+                df.to_csv(path, encoding="utf8", chunksize=chunksize)
+                recons = self.read_csv(path, **kwargs)
+
+        def _to_uni(x):
+            if not isinstance(x, str):
+                return x.decode("utf8")
+            return x
+
+        if dupe_col:
+            # read_Csv disambiguates the columns by
+            # labeling them dupe.1,dupe.2, etc'. monkey patch columns
+            recons.columns = df.columns
+        if rnlvl and not cnlvl:
+            delta_lvl = [recons.iloc[:, i].values for i in range(rnlvl - 1)]
+            ix = MultiIndex.from_arrays([list(recons.index)] + delta_lvl)
+            recons.index = ix
+            recons = recons.iloc[:, rnlvl - 1 :]
+
+        type_map = {"i": "i", "f": "f", "s": "O", "u": "O", "dt": "O", "p": "O"}
+        if r_dtype:
+            if r_dtype == "u":  # unicode
+                r_dtype = "O"
+                recons.index = np.array(
+                    [_to_uni(label) for label in recons.index], dtype=r_dtype
+                )
+                df.index = np.array(
+                    [_to_uni(label) for label in df.index], dtype=r_dtype
+                )
+            elif r_dtype == "dt":  # unicode
+                r_dtype = "O"
+                recons.index = np.array(
+                    [Timestamp(label) for label in recons.index], dtype=r_dtype
+                )
+                df.index = np.array(
+                    [Timestamp(label) for label in df.index], dtype=r_dtype
+                )
+            elif r_dtype == "p":
+                r_dtype = "O"
+                idx_list = to_datetime(recons.index)
+                recons.index = np.array(
+                    [Timestamp(label) for label in idx_list], dtype=r_dtype
+                )
+                df.index = np.array(
+                    list(map(Timestamp, df.index.to_timestamp())), dtype=r_dtype
+                )
+            else:
+                r_dtype = type_map.get(r_dtype)
+                recons.index = np.array(recons.index, dtype=r_dtype)
+                df.index = np.array(df.index, dtype=r_dtype)
+        if c_dtype:
+            if c_dtype == "u":
+                c_dtype = "O"
+                recons.columns = np.array(
+                    [_to_uni(label) for label in recons.columns], dtype=c_dtype
+                )
+                df.columns = np.array(
+                    [_to_uni(label) for label in df.columns], dtype=c_dtype
+                )
+            elif c_dtype == "dt":
+                c_dtype = "O"
+                recons.columns = np.array(
+                    [Timestamp(label) for label in recons.columns], dtype=c_dtype
+                )
+                df.columns = np.array(
+                    [Timestamp(label) for label in df.columns], dtype=c_dtype
+                )
+            elif c_dtype == "p":
+                c_dtype = "O"
+                col_list = to_datetime(recons.columns)
+                recons.columns = np.array(
+                    [Timestamp(label) for label in col_list], dtype=c_dtype
+                )
+                col_list = df.columns.to_timestamp()
+                df.columns = np.array(
+                    [Timestamp(label) for label in col_list], dtype=c_dtype
+                )
+            else:
+                c_dtype = type_map.get(c_dtype)
+                recons.columns = np.array(recons.columns, dtype=c_dtype)
+                df.columns = np.array(df.columns, dtype=c_dtype)
+        return df, recons
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize(
+        "nrows", [2, 10, 99, 100, 101, 102, 198, 199, 200, 201, 202, 249, 250, 251]
+    )
+    def test_to_csv_nrows(self, nrows):
+        df = tm.makeCustomDataframe(nrows, 4, r_idx_type="dt", c_idx_type="s")
+        result, expected = self._return_result_expected(df, 1000, "dt", "s")
+        tm.assert_frame_equal(result, expected, check_names=False)
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize(
+        "nrows", [2, 10, 99, 100, 101, 102, 198, 199, 200, 201, 202, 249, 250, 251]
+    )
+    @pytest.mark.parametrize(
+        "r_idx_type, c_idx_type", [("i", "i"), ("s", "s"), ("s", "dt"), ("p", "p")]
+    )
+    @pytest.mark.parametrize("ncols", [1, 2, 3, 4])
+    def test_to_csv_idx_types(self, nrows, r_idx_type, c_idx_type, ncols):
+        df = tm.makeCustomDataframe(
+            nrows, ncols, r_idx_type=r_idx_type, c_idx_type=c_idx_type
+        )
+        result, expected = self._return_result_expected(
+            df,
+            1000,
+            r_idx_type,
+            c_idx_type,
+        )
+        tm.assert_frame_equal(result, expected, check_names=False)
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize(
+        "nrows", [10, 98, 99, 100, 101, 102, 198, 199, 200, 201, 202, 249, 250, 251]
+    )
+    @pytest.mark.parametrize("ncols", [1, 2, 3, 4])
+    def test_to_csv_idx_ncols(self, nrows, ncols):
+        df = tm.makeCustomDataframe(nrows, ncols)
+        result, expected = self._return_result_expected(df, 1000)
+        tm.assert_frame_equal(result, expected, check_names=False)
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("nrows", [10, 98, 99, 100, 101, 102])
+    def test_to_csv_dup_cols(self, nrows):
+        df = tm.makeCustomDataframe(nrows, 3)
+        cols = list(df.columns)
+        cols[:2] = ["dupe", "dupe"]
+        cols[-2:] = ["dupe", "dupe"]
+        ix = list(df.index)
+        ix[:2] = ["rdupe", "rdupe"]
+        ix[-2:] = ["rdupe", "rdupe"]
+        df.index = ix
+        df.columns = cols
+        result, expected = self._return_result_expected(df, 1000, dupe_col=True)
+        tm.assert_frame_equal(result, expected, check_names=False)
+
+    @pytest.mark.slow
+    def test_to_csv_empty(self):
+        df = DataFrame(index=np.arange(10, dtype=np.int64))
+        result, expected = self._return_result_expected(df, 1000)
+        tm.assert_frame_equal(result, expected, check_column_type=False)
+
+    @pytest.mark.slow
+    def test_to_csv_chunksize(self):
+        chunksize = 1000
+        df = tm.makeCustomDataframe(chunksize // 2 + 1, 2, r_idx_nlevels=2)
+        result, expected = self._return_result_expected(df, chunksize, rnlvl=2)
+        tm.assert_frame_equal(result, expected, check_names=False)
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize(
+        "nrows", [2, 10, 99, 100, 101, 102, 198, 199, 200, 201, 202, 249, 250, 251]
+    )
+    @pytest.mark.parametrize("ncols", [2, 3, 4])
+    @pytest.mark.parametrize(
+        "df_params, func_params",
+        [
+            [{"r_idx_nlevels": 2}, {"rnlvl": 2}],
+            [{"c_idx_nlevels": 2}, {"cnlvl": 2}],
+            [{"r_idx_nlevels": 2, "c_idx_nlevels": 2}, {"rnlvl": 2, "cnlvl": 2}],
+        ],
+    )
+    def test_to_csv_params(self, nrows, df_params, func_params, ncols):
+        df = tm.makeCustomDataframe(nrows, ncols, **df_params)
+        result, expected = self._return_result_expected(df, 1000, **func_params)
+        tm.assert_frame_equal(result, expected, check_names=False)
+
+    def test_to_csv_from_csv_w_some_infs(self, float_frame):
+        # test roundtrip with inf, -inf, nan, as full columns and mix
+        float_frame["G"] = np.nan
+        f = lambda x: [np.inf, np.nan][np.random.rand() < 0.5]
+        float_frame["H"] = float_frame.index.map(f)
+
+        with tm.ensure_clean() as path:
+            float_frame.to_csv(path)
+            recons = self.read_csv(path)
+
+            tm.assert_frame_equal(float_frame, recons)
+            tm.assert_frame_equal(np.isinf(float_frame), np.isinf(recons))
+
+    def test_to_csv_from_csv_w_all_infs(self, float_frame):
+        # test roundtrip with inf, -inf, nan, as full columns and mix
+        float_frame["E"] = np.inf
+        float_frame["F"] = -np.inf
+
+        with tm.ensure_clean() as path:
+            float_frame.to_csv(path)
+            recons = self.read_csv(path)
+
+            tm.assert_frame_equal(float_frame, recons)
+            tm.assert_frame_equal(np.isinf(float_frame), np.isinf(recons))
+
+    def test_to_csv_no_index(self):
+        # GH 3624, after appending columns, to_csv fails
+        with tm.ensure_clean("__tmp_to_csv_no_index__") as path:
+            df = DataFrame({"c1": [1, 2, 3], "c2": [4, 5, 6]})
+            df.to_csv(path, index=False)
+            result = read_csv(path)
+            tm.assert_frame_equal(df, result)
+            df["c3"] = Series([7, 8, 9], dtype="int64")
+            df.to_csv(path, index=False)
+            result = read_csv(path)
+            tm.assert_frame_equal(df, result)
+
+    def test_to_csv_with_mix_columns(self):
+        # gh-11637: incorrect output when a mix of integer and string column
+        # names passed as columns parameter in to_csv
+
+        df = DataFrame({0: ["a", "b", "c"], 1: ["aa", "bb", "cc"]})
+        df["test"] = "txt"
+        assert df.to_csv() == df.to_csv(columns=[0, 1, "test"])
+
+    def test_to_csv_headers(self):
+        # GH6186, the presence or absence of `index` incorrectly
+        # causes to_csv to have different header semantics.
+        from_df = DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
+        to_df = DataFrame([[1, 2], [3, 4]], columns=["X", "Y"])
+        with tm.ensure_clean("__tmp_to_csv_headers__") as path:
+            from_df.to_csv(path, header=["X", "Y"])
+            recons = self.read_csv(path)
+
+            tm.assert_frame_equal(to_df, recons)
+
+            from_df.to_csv(path, index=False, header=["X", "Y"])
+            recons = self.read_csv(path)
+
+            return_value = recons.reset_index(inplace=True)
+            assert return_value is None
+            tm.assert_frame_equal(to_df, recons)
+
+    def test_to_csv_multiindex(self, float_frame, datetime_frame):
+        frame = float_frame
+        old_index = frame.index
+        arrays = np.arange(len(old_index) * 2, dtype=np.int64).reshape(2, -1)
+        new_index = MultiIndex.from_arrays(arrays, names=["first", "second"])
+        frame.index = new_index
+
+        with tm.ensure_clean("__tmp_to_csv_multiindex__") as path:
+            frame.to_csv(path, header=False)
+            frame.to_csv(path, columns=["A", "B"])
+
+            # round trip
+            frame.to_csv(path)
+
+            df = self.read_csv(path, index_col=[0, 1], parse_dates=False)
+
+            # TODO to_csv drops column name
+            tm.assert_frame_equal(frame, df, check_names=False)
+            assert frame.index.names == df.index.names
+
+            # needed if setUp becomes a class method
+            float_frame.index = old_index
+
+            # try multiindex with dates
+            tsframe = datetime_frame
+            old_index = tsframe.index
+            new_index = [old_index, np.arange(len(old_index), dtype=np.int64)]
+            tsframe.index = MultiIndex.from_arrays(new_index)
+
+            tsframe.to_csv(path, index_label=["time", "foo"])
+            with tm.assert_produces_warning(
+                UserWarning, match="Could not infer format"
+            ):
+                recons = self.read_csv(path, index_col=[0, 1], parse_dates=True)
+
+            # TODO to_csv drops column name
+            tm.assert_frame_equal(tsframe, recons, check_names=False)
+
+            # do not load index
+            tsframe.to_csv(path)
+            recons = self.read_csv(path, index_col=None)
+            assert len(recons.columns) == len(tsframe.columns) + 2
+
+            # no index
+            tsframe.to_csv(path, index=False)
+            recons = self.read_csv(path, index_col=None)
+            tm.assert_almost_equal(recons.values, datetime_frame.values)
+
+            # needed if setUp becomes class method
+            datetime_frame.index = old_index
+
+        with tm.ensure_clean("__tmp_to_csv_multiindex__") as path:
+            # GH3571, GH1651, GH3141
+
+            def _make_frame(names=None):
+                if names is True:
+                    names = ["first", "second"]
+                return DataFrame(
+                    np.random.randint(0, 10, size=(3, 3)),
+                    columns=MultiIndex.from_tuples(
+                        [("bah", "foo"), ("bah", "bar"), ("ban", "baz")], names=names
+                    ),
+                    dtype="int64",
+                )
+
+            # column & index are multi-index
+            df = tm.makeCustomDataframe(5, 3, r_idx_nlevels=2, c_idx_nlevels=4)
+            df.to_csv(path)
+            result = read_csv(path, header=[0, 1, 2, 3], index_col=[0, 1])
+            tm.assert_frame_equal(df, result)
+
+            # column is mi
+            df = tm.makeCustomDataframe(5, 3, r_idx_nlevels=1, c_idx_nlevels=4)
+            df.to_csv(path)
+            result = read_csv(path, header=[0, 1, 2, 3], index_col=0)
+            tm.assert_frame_equal(df, result)
+
+            # dup column names?
+            df = tm.makeCustomDataframe(5, 3, r_idx_nlevels=3, c_idx_nlevels=4)
+            df.to_csv(path)
+            result = read_csv(path, header=[0, 1, 2, 3], index_col=[0, 1, 2])
+            tm.assert_frame_equal(df, result)
+
+            # writing with no index
+            df = _make_frame()
+            df.to_csv(path, index=False)
+            result = read_csv(path, header=[0, 1])
+            tm.assert_frame_equal(df, result)
+
+            # we lose the names here
+            df = _make_frame(True)
+            df.to_csv(path, index=False)
+            result = read_csv(path, header=[0, 1])
+            assert com.all_none(*result.columns.names)
+            result.columns.names = df.columns.names
+            tm.assert_frame_equal(df, result)
+
+            # whatsnew example
+            df = _make_frame()
+            df.to_csv(path)
+            result = read_csv(path, header=[0, 1], index_col=[0])
+            tm.assert_frame_equal(df, result)
+
+            df = _make_frame(True)
+            df.to_csv(path)
+            result = read_csv(path, header=[0, 1], index_col=[0])
+            tm.assert_frame_equal(df, result)
+
+            # invalid options
+            df = _make_frame(True)
+            df.to_csv(path)
+
+            for i in [6, 7]:
+                msg = f"len of {i}, but only 5 lines in file"
+                with pytest.raises(ParserError, match=msg):
+                    read_csv(path, header=list(range(i)), index_col=0)
+
+            # write with cols
+            msg = "cannot specify cols with a MultiIndex"
+            with pytest.raises(TypeError, match=msg):
+                df.to_csv(path, columns=["foo", "bar"])
+
+        with tm.ensure_clean("__tmp_to_csv_multiindex__") as path:
+            # empty
+            tsframe[:0].to_csv(path)
+            recons = self.read_csv(path)
+
+            exp = tsframe[:0]
+            exp.index = []
+
+            tm.assert_index_equal(recons.columns, exp.columns)
+            assert len(recons) == 0
+
+    def test_to_csv_interval_index(self):
+        # GH 28210
+        df = DataFrame({"A": list("abc"), "B": range(3)}, index=pd.interval_range(0, 3))
+
+        with tm.ensure_clean("__tmp_to_csv_interval_index__.csv") as path:
+            df.to_csv(path)
+            result = self.read_csv(path, index_col=0)
+
+            # can't roundtrip intervalindex via read_csv so check string repr (GH 23595)
+            expected = df.copy()
+            expected.index = expected.index.astype(str)
+
+            tm.assert_frame_equal(result, expected)
+
+    def test_to_csv_float32_nanrep(self):
+        df = DataFrame(np.random.randn(1, 4).astype(np.float32))
+        df[1] = np.nan
+
+        with tm.ensure_clean("__tmp_to_csv_float32_nanrep__.csv") as path:
+            df.to_csv(path, na_rep=999)
+
+            with open(path) as f:
+                lines = f.readlines()
+                assert lines[1].split(",")[2] == "999"
+
+    def test_to_csv_withcommas(self):
+        # Commas inside fields should be correctly escaped when saving as CSV.
+        df = DataFrame({"A": [1, 2, 3], "B": ["5,6", "7,8", "9,0"]})
+
+        with tm.ensure_clean("__tmp_to_csv_withcommas__.csv") as path:
+            df.to_csv(path)
+            df2 = self.read_csv(path)
+            tm.assert_frame_equal(df2, df)
+
+    def test_to_csv_mixed(self):
+        def create_cols(name):
+            return [f"{name}{i:03d}" for i in range(5)]
+
+        df_float = DataFrame(
+            np.random.randn(100, 5), dtype="float64", columns=create_cols("float")
+        )
+        df_int = DataFrame(
+            np.random.randn(100, 5).astype("int64"),
+            dtype="int64",
+            columns=create_cols("int"),
+        )
+        df_bool = DataFrame(True, index=df_float.index, columns=create_cols("bool"))
+        df_object = DataFrame(
+            "foo", index=df_float.index, columns=create_cols("object")
+        )
+        df_dt = DataFrame(
+            Timestamp("20010101"), index=df_float.index, columns=create_cols("date")
+        )
+
+        # add in some nans
+        df_float.iloc[30:50, 1:3] = np.nan
+
+        # ## this is a bug in read_csv right now ####
+        # df_dt.loc[30:50,1:3] = np.nan
+
+        df = pd.concat([df_float, df_int, df_bool, df_object, df_dt], axis=1)
+
+        # dtype
+        dtypes = {}
+        for n, dtype in [
+            ("float", np.float64),
+            ("int", np.int64),
+            ("bool", np.bool_),
+            ("object", object),
+        ]:
+            for c in create_cols(n):
+                dtypes[c] = dtype
+
+        with tm.ensure_clean() as filename:
+            df.to_csv(filename)
+            rs = read_csv(
+                filename, index_col=0, dtype=dtypes, parse_dates=create_cols("date")
+            )
+            tm.assert_frame_equal(rs, df)
+
+    def test_to_csv_dups_cols(self):
+        df = DataFrame(
+            np.random.randn(1000, 30),
+            columns=list(range(15)) + list(range(15)),
+            dtype="float64",
+        )
+
+        with tm.ensure_clean() as filename:
+            df.to_csv(filename)  # single dtype, fine
+            result = read_csv(filename, index_col=0)
+            result.columns = df.columns
+            tm.assert_frame_equal(result, df)
+
+        df_float = DataFrame(np.random.randn(1000, 3), dtype="float64")
+        df_int = DataFrame(np.random.randn(1000, 3)).astype("int64")
+        df_bool = DataFrame(True, index=df_float.index, columns=range(3))
+        df_object = DataFrame("foo", index=df_float.index, columns=range(3))
+        df_dt = DataFrame(Timestamp("20010101"), index=df_float.index, columns=range(3))
+        df = pd.concat(
+            [df_float, df_int, df_bool, df_object, df_dt], axis=1, ignore_index=True
+        )
+
+        df.columns = [0, 1, 2] * 5
+
+        with tm.ensure_clean() as filename:
+            df.to_csv(filename)
+            result = read_csv(filename, index_col=0)
+
+            # date cols
+            for i in ["0.4", "1.4", "2.4"]:
+                result[i] = to_datetime(result[i])
+
+            result.columns = df.columns
+            tm.assert_frame_equal(result, df)
+
+        # GH3457
+
+        N = 10
+        df = tm.makeCustomDataframe(N, 3)
+        df.columns = ["a", "a", "b"]
+
+        with tm.ensure_clean() as filename:
+            df.to_csv(filename)
+
+            # read_csv will rename the dups columns
+            result = read_csv(filename, index_col=0)
+            result = result.rename(columns={"a.1": "a"})
+            tm.assert_frame_equal(result, df)
+
+    @pytest.mark.parametrize("chunksize", [10000, 50000, 100000])
+    def test_to_csv_chunking(self, chunksize):
+        aa = DataFrame({"A": range(100000)})
+        aa["B"] = aa.A + 1.0
+        aa["C"] = aa.A + 2.0
+        aa["D"] = aa.A + 3.0
+
+        with tm.ensure_clean() as filename:
+            aa.to_csv(filename, chunksize=chunksize)
+            rs = read_csv(filename, index_col=0)
+            tm.assert_frame_equal(rs, aa)
+
+    @pytest.mark.slow
+    def test_to_csv_wide_frame_formatting(self):
+        # Issue #8621
+        df = DataFrame(np.random.randn(1, 100010), columns=None, index=None)
+        with tm.ensure_clean() as filename:
+            df.to_csv(filename, header=False, index=False)
+            rs = read_csv(filename, header=None)
+            tm.assert_frame_equal(rs, df)
+
+    def test_to_csv_bug(self):
+        f1 = StringIO("a,1.0\nb,2.0")
+        df = self.read_csv(f1, header=None)
+        newdf = DataFrame({"t": df[df.columns[0]]})
+
+        with tm.ensure_clean() as path:
+            newdf.to_csv(path)
+
+            recons = read_csv(path, index_col=0)
+            # don't check_names as t != 1
+            tm.assert_frame_equal(recons, newdf, check_names=False)
+
+    def test_to_csv_unicode(self):
+        df = DataFrame({"c/\u03c3": [1, 2, 3]})
+        with tm.ensure_clean() as path:
+            df.to_csv(path, encoding="UTF-8")
+            df2 = read_csv(path, index_col=0, encoding="UTF-8")
+            tm.assert_frame_equal(df, df2)
+
+            df.to_csv(path, encoding="UTF-8", index=False)
+            df2 = read_csv(path, index_col=None, encoding="UTF-8")
+            tm.assert_frame_equal(df, df2)
+
+    def test_to_csv_unicode_index_col(self):
+        buf = StringIO("")
+        df = DataFrame(
+            [["\u05d0", "d2", "d3", "d4"], ["a1", "a2", "a3", "a4"]],
+            columns=["\u05d0", "\u05d1", "\u05d2", "\u05d3"],
+            index=["\u05d0", "\u05d1"],
+        )
+
+        df.to_csv(buf, encoding="UTF-8")
+        buf.seek(0)
+
+        df2 = read_csv(buf, index_col=0, encoding="UTF-8")
+        tm.assert_frame_equal(df, df2)
+
+    def test_to_csv_stringio(self, float_frame):
+        buf = StringIO()
+        float_frame.to_csv(buf)
+        buf.seek(0)
+        recons = read_csv(buf, index_col=0)
+        tm.assert_frame_equal(recons, float_frame)
+
+    def test_to_csv_float_format(self):
+        df = DataFrame(
+            [[0.123456, 0.234567, 0.567567], [12.32112, 123123.2, 321321.2]],
+            index=["A", "B"],
+            columns=["X", "Y", "Z"],
+        )
+
+        with tm.ensure_clean() as filename:
+            df.to_csv(filename, float_format="%.2f")
+
+            rs = read_csv(filename, index_col=0)
+            xp = DataFrame(
+                [[0.12, 0.23, 0.57], [12.32, 123123.20, 321321.20]],
+                index=["A", "B"],
+                columns=["X", "Y", "Z"],
+            )
+            tm.assert_frame_equal(rs, xp)
+
+    def test_to_csv_float_format_over_decimal(self):
+        # GH#47436
+        df = DataFrame({"a": [0.5, 1.0]})
+        result = df.to_csv(
+            decimal=",",
+            float_format=lambda x: np.format_float_positional(x, trim="-"),
+            index=False,
+        )
+        expected_rows = ["a", "0.5", "1"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
+
+    def test_to_csv_unicodewriter_quoting(self):
+        df = DataFrame({"A": [1, 2, 3], "B": ["foo", "bar", "baz"]})
+
+        buf = StringIO()
+        df.to_csv(buf, index=False, quoting=csv.QUOTE_NONNUMERIC, encoding="utf-8")
+
+        result = buf.getvalue()
+        expected_rows = ['"A","B"', '1,"foo"', '2,"bar"', '3,"baz"']
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
+
+    @pytest.mark.parametrize("encoding", [None, "utf-8"])
+    def test_to_csv_quote_none(self, encoding):
+        # GH4328
+        df = DataFrame({"A": ["hello", '{"hello"}']})
+        buf = StringIO()
+        df.to_csv(buf, quoting=csv.QUOTE_NONE, encoding=encoding, index=False)
+
+        result = buf.getvalue()
+        expected_rows = ["A", "hello", '{"hello"}']
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
+
+    def test_to_csv_index_no_leading_comma(self):
+        df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["one", "two", "three"])
+
+        buf = StringIO()
+        df.to_csv(buf, index_label=False)
+
+        expected_rows = ["A,B", "one,1,4", "two,2,5", "three,3,6"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert buf.getvalue() == expected
+
+    def test_to_csv_lineterminators(self):
+        # see gh-20353
+        df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["one", "two", "three"])
+
+        with tm.ensure_clean() as path:
+            # case 1: CRLF as line terminator
+            df.to_csv(path, lineterminator="\r\n")
+            expected = b",A,B\r\none,1,4\r\ntwo,2,5\r\nthree,3,6\r\n"
+
+            with open(path, mode="rb") as f:
+                assert f.read() == expected
+
+        with tm.ensure_clean() as path:
+            # case 2: LF as line terminator
+            df.to_csv(path, lineterminator="\n")
+            expected = b",A,B\none,1,4\ntwo,2,5\nthree,3,6\n"
+
+            with open(path, mode="rb") as f:
+                assert f.read() == expected
+
+        with tm.ensure_clean() as path:
+            # case 3: The default line terminator(=os.linesep)(gh-21406)
+            df.to_csv(path)
+            os_linesep = os.linesep.encode("utf-8")
+            expected = (
+                b",A,B"
+                + os_linesep
+                + b"one,1,4"
+                + os_linesep
+                + b"two,2,5"
+                + os_linesep
+                + b"three,3,6"
+                + os_linesep
+            )
+
+            with open(path, mode="rb") as f:
+                assert f.read() == expected
+
+    def test_to_csv_from_csv_categorical(self):
+        # CSV with categoricals should result in the same output
+        # as when one would add a "normal" Series/DataFrame.
+        s = Series(pd.Categorical(["a", "b", "b", "a", "a", "c", "c", "c"]))
+        s2 = Series(["a", "b", "b", "a", "a", "c", "c", "c"])
+        res = StringIO()
+
+        s.to_csv(res, header=False)
+        exp = StringIO()
+
+        s2.to_csv(exp, header=False)
+        assert res.getvalue() == exp.getvalue()
+
+        df = DataFrame({"s": s})
+        df2 = DataFrame({"s": s2})
+
+        res = StringIO()
+        df.to_csv(res)
+
+        exp = StringIO()
+        df2.to_csv(exp)
+
+        assert res.getvalue() == exp.getvalue()
+
+    def test_to_csv_path_is_none(self, float_frame):
+        # GH 8215
+        # Make sure we return string for consistency with
+        # Series.to_csv()
+        csv_str = float_frame.to_csv(path_or_buf=None)
+        assert isinstance(csv_str, str)
+        recons = read_csv(StringIO(csv_str), index_col=0)
+        tm.assert_frame_equal(float_frame, recons)
+
+    @pytest.mark.parametrize(
+        "df,encoding",
+        [
+            (
+                DataFrame(
+                    [[0.123456, 0.234567, 0.567567], [12.32112, 123123.2, 321321.2]],
+                    index=["A", "B"],
+                    columns=["X", "Y", "Z"],
+                ),
+                None,
+            ),
+            # GH 21241, 21118
+            (DataFrame([["abc", "def", "ghi"]], columns=["X", "Y", "Z"]), "ascii"),
+            (DataFrame(5 * [[123, "你好", "世界"]], columns=["X", "Y", "Z"]), "gb2312"),
+            (
+                DataFrame(5 * [[123, "Γειά σου", "Κόσμε"]], columns=["X", "Y", "Z"]),
+                "cp737",
+            ),
+        ],
+    )
+    def test_to_csv_compression(self, df, encoding, compression):
+        with tm.ensure_clean() as filename:
+            df.to_csv(filename, compression=compression, encoding=encoding)
+            # test the round trip - to_csv -> read_csv
+            result = read_csv(
+                filename, compression=compression, index_col=0, encoding=encoding
+            )
+            tm.assert_frame_equal(df, result)
+
+            # test the round trip using file handle - to_csv -> read_csv
+            with get_handle(
+                filename, "w", compression=compression, encoding=encoding
+            ) as handles:
+                df.to_csv(handles.handle, encoding=encoding)
+                assert not handles.handle.closed
+
+            result = read_csv(
+                filename,
+                compression=compression,
+                encoding=encoding,
+                index_col=0,
+            ).squeeze("columns")
+            tm.assert_frame_equal(df, result)
+
+            # explicitly make sure file is compressed
+            with tm.decompress_file(filename, compression) as fh:
+                text = fh.read().decode(encoding or "utf8")
+                for col in df.columns:
+                    assert col in text
+
+            with tm.decompress_file(filename, compression) as fh:
+                tm.assert_frame_equal(df, read_csv(fh, index_col=0, encoding=encoding))
+
+    def test_to_csv_date_format(self, datetime_frame):
+        with tm.ensure_clean("__tmp_to_csv_date_format__") as path:
+            dt_index = datetime_frame.index
+            datetime_frame = DataFrame(
+                {"A": dt_index, "B": dt_index.shift(1)}, index=dt_index
+            )
+            datetime_frame.to_csv(path, date_format="%Y%m%d")
+
+            # Check that the data was put in the specified format
+            test = read_csv(path, index_col=0)
+
+            datetime_frame_int = datetime_frame.applymap(
+                lambda x: int(x.strftime("%Y%m%d"))
+            )
+            datetime_frame_int.index = datetime_frame_int.index.map(
+                lambda x: int(x.strftime("%Y%m%d"))
+            )
+
+            tm.assert_frame_equal(test, datetime_frame_int)
+
+            datetime_frame.to_csv(path, date_format="%Y-%m-%d")
+
+            # Check that the data was put in the specified format
+            test = read_csv(path, index_col=0)
+            datetime_frame_str = datetime_frame.applymap(
+                lambda x: x.strftime("%Y-%m-%d")
+            )
+            datetime_frame_str.index = datetime_frame_str.index.map(
+                lambda x: x.strftime("%Y-%m-%d")
+            )
+
+            tm.assert_frame_equal(test, datetime_frame_str)
+
+            # Check that columns get converted
+            datetime_frame_columns = datetime_frame.T
+            datetime_frame_columns.to_csv(path, date_format="%Y%m%d")
+
+            test = read_csv(path, index_col=0)
+
+            datetime_frame_columns = datetime_frame_columns.applymap(
+                lambda x: int(x.strftime("%Y%m%d"))
+            )
+            # Columns don't get converted to ints by read_csv
+            datetime_frame_columns.columns = datetime_frame_columns.columns.map(
+                lambda x: x.strftime("%Y%m%d")
+            )
+
+            tm.assert_frame_equal(test, datetime_frame_columns)
+
+            # test NaTs
+            nat_index = to_datetime(
+                ["NaT"] * 10 + ["2000-01-01", "2000-01-01", "2000-01-01"]
+            )
+            nat_frame = DataFrame({"A": nat_index}, index=nat_index)
+            nat_frame.to_csv(path, date_format="%Y-%m-%d")
+
+            test = read_csv(path, parse_dates=[0, 1], index_col=0)
+
+            tm.assert_frame_equal(test, nat_frame)
+
+    @pytest.mark.parametrize("td", [pd.Timedelta(0), pd.Timedelta("10s")])
+    def test_to_csv_with_dst_transitions(self, td):
+        with tm.ensure_clean("csv_date_format_with_dst") as path:
+            # make sure we are not failing on transitions
+            times = date_range(
+                "2013-10-26 23:00",
+                "2013-10-27 01:00",
+                tz="Europe/London",
+                freq="H",
+                ambiguous="infer",
+            )
+            i = times + td
+            i = i._with_freq(None)  # freq is not preserved by read_csv
+            time_range = np.array(range(len(i)), dtype="int64")
+            df = DataFrame({"A": time_range}, index=i)
+            df.to_csv(path, index=True)
+            # we have to reconvert the index as we
+            # don't parse the tz's
+            result = read_csv(path, index_col=0)
+            result.index = to_datetime(result.index, utc=True).tz_convert(
+                "Europe/London"
+            )
+            tm.assert_frame_equal(result, df)
+
+    def test_to_csv_with_dst_transitions_with_pickle(self):
+        # GH11619
+        idx = date_range("2015-01-01", "2015-12-31", freq="H", tz="Europe/Paris")
+        idx = idx._with_freq(None)  # freq does not round-trip
+        idx._data._freq = None  # otherwise there is trouble on unpickle
+        df = DataFrame({"values": 1, "idx": idx}, index=idx)
+        with tm.ensure_clean("csv_date_format_with_dst") as path:
+            df.to_csv(path, index=True)
+            result = read_csv(path, index_col=0)
+            result.index = to_datetime(result.index, utc=True).tz_convert(
+                "Europe/Paris"
+            )
+            result["idx"] = to_datetime(result["idx"], utc=True).astype(
+                "datetime64[ns, Europe/Paris]"
+            )
+            tm.assert_frame_equal(result, df)
+
+        # assert working
+        df.astype(str)
+
+        with tm.ensure_clean("csv_date_format_with_dst") as path:
+            df.to_pickle(path)
+            result = pd.read_pickle(path)
+            tm.assert_frame_equal(result, df)
+
+    def test_to_csv_quoting(self):
+        df = DataFrame(
+            {
+                "c_bool": [True, False],
+                "c_float": [1.0, 3.2],
+                "c_int": [42, np.nan],
+                "c_string": ["a", "b,c"],
+            }
+        )
+
+        expected_rows = [
+            ",c_bool,c_float,c_int,c_string",
+            "0,True,1.0,42.0,a",
+            '1,False,3.2,,"b,c"',
+        ]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+
+        result = df.to_csv()
+        assert result == expected
+
+        result = df.to_csv(quoting=None)
+        assert result == expected
+
+        expected_rows = [
+            ",c_bool,c_float,c_int,c_string",
+            "0,True,1.0,42.0,a",
+            '1,False,3.2,,"b,c"',
+        ]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+
+        result = df.to_csv(quoting=csv.QUOTE_MINIMAL)
+        assert result == expected
+
+        expected_rows = [
+            '"","c_bool","c_float","c_int","c_string"',
+            '"0","True","1.0","42.0","a"',
+            '"1","False","3.2","","b,c"',
+        ]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+
+        result = df.to_csv(quoting=csv.QUOTE_ALL)
+        assert result == expected
+
+        # see gh-12922, gh-13259: make sure changes to
+        # the formatters do not break this behaviour
+        expected_rows = [
+            '"","c_bool","c_float","c_int","c_string"',
+            '0,True,1.0,42.0,"a"',
+            '1,False,3.2,"","b,c"',
+        ]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        result = df.to_csv(quoting=csv.QUOTE_NONNUMERIC)
+        assert result == expected
+
+        msg = "need to escape, but no escapechar set"
+        with pytest.raises(csv.Error, match=msg):
+            df.to_csv(quoting=csv.QUOTE_NONE)
+
+        with pytest.raises(csv.Error, match=msg):
+            df.to_csv(quoting=csv.QUOTE_NONE, escapechar=None)
+
+        expected_rows = [
+            ",c_bool,c_float,c_int,c_string",
+            "0,True,1.0,42.0,a",
+            "1,False,3.2,,b!,c",
+        ]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        result = df.to_csv(quoting=csv.QUOTE_NONE, escapechar="!")
+        assert result == expected
+
+        expected_rows = [
+            ",c_bool,c_ffloat,c_int,c_string",
+            "0,True,1.0,42.0,a",
+            "1,False,3.2,,bf,c",
+        ]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        result = df.to_csv(quoting=csv.QUOTE_NONE, escapechar="f")
+        assert result == expected
+
+        # see gh-3503: quoting Windows line terminators
+        # presents with encoding?
+        text_rows = ["a,b,c", '1,"test \r\n",3']
+        text = tm.convert_rows_list_to_csv_str(text_rows)
+        df = read_csv(StringIO(text))
+
+        buf = StringIO()
+        df.to_csv(buf, encoding="utf-8", index=False)
+        assert buf.getvalue() == text
+
+        # xref gh-7791: make sure the quoting parameter is passed through
+        # with multi-indexes
+        df = DataFrame({"a": [1, 2], "b": [3, 4], "c": [5, 6]})
+        df = df.set_index(["a", "b"])
+
+        expected_rows = ['"a","b","c"', '"1","3","5"', '"2","4","6"']
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert df.to_csv(quoting=csv.QUOTE_ALL) == expected
+
+    def test_period_index_date_overflow(self):
+        # see gh-15982
+
+        dates = ["1990-01-01", "2000-01-01", "3005-01-01"]
+        index = pd.PeriodIndex(dates, freq="D")
+
+        df = DataFrame([4, 5, 6], index=index)
+        result = df.to_csv()
+
+        expected_rows = [",0", "1990-01-01,4", "2000-01-01,5", "3005-01-01,6"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
+
+        date_format = "%m-%d-%Y"
+        result = df.to_csv(date_format=date_format)
+
+        expected_rows = [",0", "01-01-1990,4", "01-01-2000,5", "01-01-3005,6"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
+
+        # Overflow with pd.NaT
+        dates = ["1990-01-01", NaT, "3005-01-01"]
+        index = pd.PeriodIndex(dates, freq="D")
+
+        df = DataFrame([4, 5, 6], index=index)
+        result = df.to_csv()
+
+        expected_rows = [",0", "1990-01-01,4", ",5", "3005-01-01,6"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
+
+    def test_multi_index_header(self):
+        # see gh-5539
+        columns = MultiIndex.from_tuples([("a", 1), ("a", 2), ("b", 1), ("b", 2)])
+        df = DataFrame([[1, 2, 3, 4], [5, 6, 7, 8]])
+        df.columns = columns
+
+        header = ["a", "b", "c", "d"]
+        result = df.to_csv(header=header)
+
+        expected_rows = [",a,b,c,d", "0,1,2,3,4", "1,5,6,7,8"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
+
+    def test_to_csv_single_level_multi_index(self):
+        # see gh-26303
+        index = Index([(1,), (2,), (3,)])
+        df = DataFrame([[1, 2, 3]], columns=index)
+        df = df.reindex(columns=[(1,), (3,)])
+        expected = ",1,3\n0,1,3\n"
+        result = df.to_csv(lineterminator="\n")
+        tm.assert_almost_equal(result, expected)
+
+    def test_gz_lineend(self):
+        # GH 25311
+        df = DataFrame({"a": [1, 2]})
+        expected_rows = ["a", "1", "2"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        with tm.ensure_clean("__test_gz_lineend.csv.gz") as path:
+            df.to_csv(path, index=False)
+            with tm.decompress_file(path, compression="gzip") as f:
+                result = f.read().decode("utf-8")
+
+        assert result == expected
+
+    def test_to_csv_numpy_16_bug(self):
+        frame = DataFrame({"a": date_range("1/1/2000", periods=10)})
+
+        buf = StringIO()
+        frame.to_csv(buf)
+
+        result = buf.getvalue()
+        assert "2000-01-01" in result
+
+    def test_to_csv_na_quoting(self):
+        # GH 15891
+        # Normalize carriage return for Windows OS
+        result = (
+            DataFrame([None, None])
+            .to_csv(None, header=False, index=False, na_rep="")
+            .replace("\r\n", "\n")
+        )
+        expected = '""\n""\n'
+        assert result == expected
+
+    def test_to_csv_categorical_and_ea(self):
+        # GH#46812
+        df = DataFrame({"a": "x", "b": [1, pd.NA]})
+        df["b"] = df["b"].astype("Int16")
+        df["b"] = df["b"].astype("category")
+        result = df.to_csv()
+        expected_rows = [",a,b", "0,x,1", "1,x,"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
+
+    def test_to_csv_categorical_and_interval(self):
+        # GH#46297
+        df = DataFrame(
+            {
+                "a": [
+                    pd.Interval(
+                        Timestamp("2020-01-01"),
+                        Timestamp("2020-01-02"),
+                        closed="both",
+                    )
+                ]
+            }
+        )
+        df["a"] = df["a"].astype("category")
+        result = df.to_csv()
+        expected_rows = [",a", '0,"[2020-01-01, 2020-01-02]"']
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_to_numpy.py b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_to_numpy.py
new file mode 100644
index 0000000000000000000000000000000000000000..2040e70eb266085cda46d7cd2bf6743a57ad413b
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_to_numpy.py
@@ -0,0 +1,42 @@
+import numpy as np
+
+import pandas.util._test_decorators as td
+
+from pandas import (
+    DataFrame,
+    Timestamp,
+)
+import pandas._testing as tm
+
+
+class TestToNumpy:
+    def test_to_numpy(self):
+        df = DataFrame({"A": [1, 2], "B": [3, 4.5]})
+        expected = np.array([[1, 3], [2, 4.5]])
+        result = df.to_numpy()
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_to_numpy_dtype(self):
+        df = DataFrame({"A": [1, 2], "B": [3, 4.5]})
+        expected = np.array([[1, 3], [2, 4]], dtype="int64")
+        result = df.to_numpy(dtype="int64")
+        tm.assert_numpy_array_equal(result, expected)
+
+    @td.skip_array_manager_invalid_test
+    def test_to_numpy_copy(self, using_copy_on_write):
+        arr = np.random.randn(4, 3)
+        df = DataFrame(arr)
+        if using_copy_on_write:
+            assert df.values.base is not arr
+            assert df.to_numpy(copy=False).base is df.values.base
+        else:
+            assert df.values.base is arr
+            assert df.to_numpy(copy=False).base is arr
+        assert df.to_numpy(copy=True).base is not arr
+
+    def test_to_numpy_mixed_dtype_to_str(self):
+        # https://github.com/pandas-dev/pandas/issues/35455
+        df = DataFrame([[Timestamp("2020-01-01 00:00:00"), 100.0]])
+        result = df.to_numpy(dtype=str)
+        expected = np.array([["2020-01-01 00:00:00", "100.0"]], dtype=str)
+        tm.assert_numpy_array_equal(result, expected)
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_to_records.py b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_to_records.py
new file mode 100644
index 0000000000000000000000000000000000000000..393d304024bb6c585d43901e0acec0a42219c015
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_to_records.py
@@ -0,0 +1,519 @@
+from collections import abc
+import email
+from email.parser import Parser
+
+import numpy as np
+import pytest
+
+from pandas import (
+    CategoricalDtype,
+    DataFrame,
+    MultiIndex,
+    Series,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameToRecords:
+    def test_to_records_timeseries(self):
+        index = date_range("1/1/2000", periods=10)
+        df = DataFrame(np.random.randn(10, 3), index=index, columns=["a", "b", "c"])
+
+        result = df.to_records()
+        assert result["index"].dtype == "M8[ns]"
+
+        result = df.to_records(index=False)
+
+    def test_to_records_dt64(self):
+        df = DataFrame(
+            [["one", "two", "three"], ["four", "five", "six"]],
+            index=date_range("2012-01-01", "2012-01-02"),
+        )
+
+        expected = df.index.values[0]
+        result = df.to_records()["index"][0]
+        assert expected == result
+
+    def test_to_records_dt64tz_column(self):
+        # GH#32535 dont less tz in to_records
+        df = DataFrame({"A": date_range("2012-01-01", "2012-01-02", tz="US/Eastern")})
+
+        result = df.to_records()
+
+        assert result.dtype["A"] == object
+        val = result[0][1]
+        assert isinstance(val, Timestamp)
+        assert val == df.loc[0, "A"]
+
+    def test_to_records_with_multindex(self):
+        # GH#3189
+        index = [
+            ["bar", "bar", "baz", "baz", "foo", "foo", "qux", "qux"],
+            ["one", "two", "one", "two", "one", "two", "one", "two"],
+        ]
+        data = np.zeros((8, 4))
+        df = DataFrame(data, index=index)
+        r = df.to_records(index=True)["level_0"]
+        assert "bar" in r
+        assert "one" not in r
+
+    def test_to_records_with_Mapping_type(self):
+        abc.Mapping.register(email.message.Message)
+
+        headers = Parser().parsestr(
+            "From: <user@example.com>\n"
+            "To: <someone_else@example.com>\n"
+            "Subject: Test message\n"
+            "\n"
+            "Body would go here\n"
+        )
+
+        frame = DataFrame.from_records([headers])
+        all(x in frame for x in ["Type", "Subject", "From"])
+
+    def test_to_records_floats(self):
+        df = DataFrame(np.random.rand(10, 10))
+        df.to_records()
+
+    def test_to_records_index_name(self):
+        df = DataFrame(np.random.randn(3, 3))
+        df.index.name = "X"
+        rs = df.to_records()
+        assert "X" in rs.dtype.fields
+
+        df = DataFrame(np.random.randn(3, 3))
+        rs = df.to_records()
+        assert "index" in rs.dtype.fields
+
+        df.index = MultiIndex.from_tuples([("a", "x"), ("a", "y"), ("b", "z")])
+        df.index.names = ["A", None]
+        result = df.to_records()
+        expected = np.rec.fromarrays(
+            [np.array(["a", "a", "b"]), np.array(["x", "y", "z"])]
+            + [np.asarray(df.iloc[:, i]) for i in range(3)],
+            dtype={
+                "names": ["A", "level_1", "0", "1", "2"],
+                "formats": [
+                    "O",
+                    "O",
+                    f"{tm.ENDIAN}f8",
+                    f"{tm.ENDIAN}f8",
+                    f"{tm.ENDIAN}f8",
+                ],
+            },
+        )
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_to_records_with_unicode_index(self):
+        # GH#13172
+        # unicode_literals conflict with to_records
+        result = DataFrame([{"a": "x", "b": "y"}]).set_index("a").to_records()
+        expected = np.rec.array([("x", "y")], dtype=[("a", "O"), ("b", "O")])
+        tm.assert_almost_equal(result, expected)
+
+    def test_to_records_index_dtype(self):
+        # GH 47263: consistent data types for Index and MultiIndex
+        df = DataFrame(
+            {
+                1: date_range("2022-01-01", periods=2),
+                2: date_range("2022-01-01", periods=2),
+                3: date_range("2022-01-01", periods=2),
+            }
+        )
+
+        expected = np.rec.array(
+            [
+                ("2022-01-01", "2022-01-01", "2022-01-01"),
+                ("2022-01-02", "2022-01-02", "2022-01-02"),
+            ],
+            dtype=[
+                ("1", f"{tm.ENDIAN}M8[ns]"),
+                ("2", f"{tm.ENDIAN}M8[ns]"),
+                ("3", f"{tm.ENDIAN}M8[ns]"),
+            ],
+        )
+
+        result = df.to_records(index=False)
+        tm.assert_almost_equal(result, expected)
+
+        result = df.set_index(1).to_records(index=True)
+        tm.assert_almost_equal(result, expected)
+
+        result = df.set_index([1, 2]).to_records(index=True)
+        tm.assert_almost_equal(result, expected)
+
+    def test_to_records_with_unicode_column_names(self):
+        # xref issue: https://github.com/numpy/numpy/issues/2407
+        # Issue GH#11879. to_records used to raise an exception when used
+        # with column names containing non-ascii characters in Python 2
+        result = DataFrame(data={"accented_name_é": [1.0]}).to_records()
+
+        # Note that numpy allows for unicode field names but dtypes need
+        # to be specified using dictionary instead of list of tuples.
+        expected = np.rec.array(
+            [(0, 1.0)],
+            dtype={"names": ["index", "accented_name_é"], "formats": ["=i8", "=f8"]},
+        )
+        tm.assert_almost_equal(result, expected)
+
+    def test_to_records_with_categorical(self):
+        # GH#8626
+
+        # dict creation
+        df = DataFrame({"A": list("abc")}, dtype="category")
+        expected = Series(list("abc"), dtype="category", name="A")
+        tm.assert_series_equal(df["A"], expected)
+
+        # list-like creation
+        df = DataFrame(list("abc"), dtype="category")
+        expected = Series(list("abc"), dtype="category", name=0)
+        tm.assert_series_equal(df[0], expected)
+
+        # to record array
+        # this coerces
+        result = df.to_records()
+        expected = np.rec.array(
+            [(0, "a"), (1, "b"), (2, "c")], dtype=[("index", "=i8"), ("0", "O")]
+        )
+        tm.assert_almost_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "kwargs,expected",
+        [
+            # No dtypes --> default to array dtypes.
+            (
+                {},
+                np.rec.array(
+                    [(0, 1, 0.2, "a"), (1, 2, 1.5, "bc")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", f"{tm.ENDIAN}i8"),
+                        ("B", f"{tm.ENDIAN}f8"),
+                        ("C", "O"),
+                    ],
+                ),
+            ),
+            # Should have no effect in this case.
+            (
+                {"index": True},
+                np.rec.array(
+                    [(0, 1, 0.2, "a"), (1, 2, 1.5, "bc")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", f"{tm.ENDIAN}i8"),
+                        ("B", f"{tm.ENDIAN}f8"),
+                        ("C", "O"),
+                    ],
+                ),
+            ),
+            # Column dtype applied across the board. Index unaffected.
+            (
+                {"column_dtypes": f"{tm.ENDIAN}U4"},
+                np.rec.array(
+                    [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", f"{tm.ENDIAN}U4"),
+                        ("B", f"{tm.ENDIAN}U4"),
+                        ("C", f"{tm.ENDIAN}U4"),
+                    ],
+                ),
+            ),
+            # Index dtype applied across the board. Columns unaffected.
+            (
+                {"index_dtypes": f"{tm.ENDIAN}U1"},
+                np.rec.array(
+                    [("0", 1, 0.2, "a"), ("1", 2, 1.5, "bc")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}U1"),
+                        ("A", f"{tm.ENDIAN}i8"),
+                        ("B", f"{tm.ENDIAN}f8"),
+                        ("C", "O"),
+                    ],
+                ),
+            ),
+            # Pass in a type instance.
+            (
+                {"column_dtypes": str},
+                np.rec.array(
+                    [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", f"{tm.ENDIAN}U"),
+                        ("B", f"{tm.ENDIAN}U"),
+                        ("C", f"{tm.ENDIAN}U"),
+                    ],
+                ),
+            ),
+            # Pass in a dtype instance.
+            (
+                {"column_dtypes": np.dtype("unicode")},
+                np.rec.array(
+                    [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", f"{tm.ENDIAN}U"),
+                        ("B", f"{tm.ENDIAN}U"),
+                        ("C", f"{tm.ENDIAN}U"),
+                    ],
+                ),
+            ),
+            # Pass in a dictionary (name-only).
+            (
+                {
+                    "column_dtypes": {
+                        "A": np.int8,
+                        "B": np.float32,
+                        "C": f"{tm.ENDIAN}U2",
+                    }
+                },
+                np.rec.array(
+                    [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", "i1"),
+                        ("B", f"{tm.ENDIAN}f4"),
+                        ("C", f"{tm.ENDIAN}U2"),
+                    ],
+                ),
+            ),
+            # Pass in a dictionary (indices-only).
+            (
+                {"index_dtypes": {0: "int16"}},
+                np.rec.array(
+                    [(0, 1, 0.2, "a"), (1, 2, 1.5, "bc")],
+                    dtype=[
+                        ("index", "i2"),
+                        ("A", f"{tm.ENDIAN}i8"),
+                        ("B", f"{tm.ENDIAN}f8"),
+                        ("C", "O"),
+                    ],
+                ),
+            ),
+            # Ignore index mappings if index is not True.
+            (
+                {"index": False, "index_dtypes": f"{tm.ENDIAN}U2"},
+                np.rec.array(
+                    [(1, 0.2, "a"), (2, 1.5, "bc")],
+                    dtype=[
+                        ("A", f"{tm.ENDIAN}i8"),
+                        ("B", f"{tm.ENDIAN}f8"),
+                        ("C", "O"),
+                    ],
+                ),
+            ),
+            # Non-existent names / indices in mapping should not error.
+            (
+                {"index_dtypes": {0: "int16", "not-there": "float32"}},
+                np.rec.array(
+                    [(0, 1, 0.2, "a"), (1, 2, 1.5, "bc")],
+                    dtype=[
+                        ("index", "i2"),
+                        ("A", f"{tm.ENDIAN}i8"),
+                        ("B", f"{tm.ENDIAN}f8"),
+                        ("C", "O"),
+                    ],
+                ),
+            ),
+            # Names / indices not in mapping default to array dtype.
+            (
+                {"column_dtypes": {"A": np.int8, "B": np.float32}},
+                np.rec.array(
+                    [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", "i1"),
+                        ("B", f"{tm.ENDIAN}f4"),
+                        ("C", "O"),
+                    ],
+                ),
+            ),
+            # Names / indices not in dtype mapping default to array dtype.
+            (
+                {"column_dtypes": {"A": np.dtype("int8"), "B": np.dtype("float32")}},
+                np.rec.array(
+                    [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", "i1"),
+                        ("B", f"{tm.ENDIAN}f4"),
+                        ("C", "O"),
+                    ],
+                ),
+            ),
+            # Mixture of everything.
+            (
+                {
+                    "column_dtypes": {"A": np.int8, "B": np.float32},
+                    "index_dtypes": f"{tm.ENDIAN}U2",
+                },
+                np.rec.array(
+                    [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}U2"),
+                        ("A", "i1"),
+                        ("B", f"{tm.ENDIAN}f4"),
+                        ("C", "O"),
+                    ],
+                ),
+            ),
+            # Invalid dype values.
+            (
+                {"index": False, "column_dtypes": []},
+                (ValueError, "Invalid dtype \\[\\] specified for column A"),
+            ),
+            (
+                {"index": False, "column_dtypes": {"A": "int32", "B": 5}},
+                (ValueError, "Invalid dtype 5 specified for column B"),
+            ),
+            # Numpy can't handle EA types, so check error is raised
+            (
+                {
+                    "index": False,
+                    "column_dtypes": {"A": "int32", "B": CategoricalDtype(["a", "b"])},
+                },
+                (ValueError, "Invalid dtype category specified for column B"),
+            ),
+            # Check that bad types raise
+            (
+                {"index": False, "column_dtypes": {"A": "int32", "B": "foo"}},
+                (TypeError, "data type [\"']foo[\"'] not understood"),
+            ),
+        ],
+    )
+    def test_to_records_dtype(self, kwargs, expected):
+        # see GH#18146
+        df = DataFrame({"A": [1, 2], "B": [0.2, 1.5], "C": ["a", "bc"]})
+
+        if not isinstance(expected, np.recarray):
+            with pytest.raises(expected[0], match=expected[1]):
+                df.to_records(**kwargs)
+        else:
+            result = df.to_records(**kwargs)
+            tm.assert_almost_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "df,kwargs,expected",
+        [
+            # MultiIndex in the index.
+            (
+                DataFrame(
+                    [[1, 2, 3], [4, 5, 6], [7, 8, 9]], columns=list("abc")
+                ).set_index(["a", "b"]),
+                {"column_dtypes": "float64", "index_dtypes": {0: "int32", 1: "int8"}},
+                np.rec.array(
+                    [(1, 2, 3.0), (4, 5, 6.0), (7, 8, 9.0)],
+                    dtype=[
+                        ("a", f"{tm.ENDIAN}i4"),
+                        ("b", "i1"),
+                        ("c", f"{tm.ENDIAN}f8"),
+                    ],
+                ),
+            ),
+            # MultiIndex in the columns.
+            (
+                DataFrame(
+                    [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+                    columns=MultiIndex.from_tuples(
+                        [("a", "d"), ("b", "e"), ("c", "f")]
+                    ),
+                ),
+                {
+                    "column_dtypes": {0: f"{tm.ENDIAN}U1", 2: "float32"},
+                    "index_dtypes": "float32",
+                },
+                np.rec.array(
+                    [(0.0, "1", 2, 3.0), (1.0, "4", 5, 6.0), (2.0, "7", 8, 9.0)],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}f4"),
+                        ("('a', 'd')", f"{tm.ENDIAN}U1"),
+                        ("('b', 'e')", f"{tm.ENDIAN}i8"),
+                        ("('c', 'f')", f"{tm.ENDIAN}f4"),
+                    ],
+                ),
+            ),
+            # MultiIndex in both the columns and index.
+            (
+                DataFrame(
+                    [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+                    columns=MultiIndex.from_tuples(
+                        [("a", "d"), ("b", "e"), ("c", "f")], names=list("ab")
+                    ),
+                    index=MultiIndex.from_tuples(
+                        [("d", -4), ("d", -5), ("f", -6)], names=list("cd")
+                    ),
+                ),
+                {
+                    "column_dtypes": "float64",
+                    "index_dtypes": {0: f"{tm.ENDIAN}U2", 1: "int8"},
+                },
+                np.rec.array(
+                    [
+                        ("d", -4, 1.0, 2.0, 3.0),
+                        ("d", -5, 4.0, 5.0, 6.0),
+                        ("f", -6, 7, 8, 9.0),
+                    ],
+                    dtype=[
+                        ("c", f"{tm.ENDIAN}U2"),
+                        ("d", "i1"),
+                        ("('a', 'd')", f"{tm.ENDIAN}f8"),
+                        ("('b', 'e')", f"{tm.ENDIAN}f8"),
+                        ("('c', 'f')", f"{tm.ENDIAN}f8"),
+                    ],
+                ),
+            ),
+        ],
+    )
+    def test_to_records_dtype_mi(self, df, kwargs, expected):
+        # see GH#18146
+        result = df.to_records(**kwargs)
+        tm.assert_almost_equal(result, expected)
+
+    def test_to_records_dict_like(self):
+        # see GH#18146
+        class DictLike:
+            def __init__(self, **kwargs) -> None:
+                self.d = kwargs.copy()
+
+            def __getitem__(self, key):
+                return self.d.__getitem__(key)
+
+            def __contains__(self, key) -> bool:
+                return key in self.d
+
+            def keys(self):
+                return self.d.keys()
+
+        df = DataFrame({"A": [1, 2], "B": [0.2, 1.5], "C": ["a", "bc"]})
+
+        dtype_mappings = {
+            "column_dtypes": DictLike(**{"A": np.int8, "B": np.float32}),
+            "index_dtypes": f"{tm.ENDIAN}U2",
+        }
+
+        result = df.to_records(**dtype_mappings)
+        expected = np.rec.array(
+            [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
+            dtype=[
+                ("index", f"{tm.ENDIAN}U2"),
+                ("A", "i1"),
+                ("B", f"{tm.ENDIAN}f4"),
+                ("C", "O"),
+            ],
+        )
+        tm.assert_almost_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", ["UTC", "GMT", "US/Eastern"])
+    def test_to_records_datetimeindex_with_tz(self, tz):
+        # GH#13937
+        dr = date_range("2016-01-01", periods=10, freq="S", tz=tz)
+
+        df = DataFrame({"datetime": dr}, index=dr)
+
+        expected = df.to_records()
+        result = df.tz_convert("UTC").to_records()
+
+        # both converted to UTC, so they are equal
+        tm.assert_numpy_array_equal(result, expected)
diff --git a/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_tz_convert.py b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_tz_convert.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3d2bd795c45a134e0aaa93e8902c7ed938aa0ef
--- /dev/null
+++ b/videochat2/lib/python3.10/site-packages/pandas/tests/frame/methods/test_tz_convert.py
@@ -0,0 +1,131 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestTZConvert:
+    def test_tz_convert(self, frame_or_series):
+        rng = date_range("1/1/2011", periods=200, freq="D", tz="US/Eastern")
+
+        obj = DataFrame({"a": 1}, index=rng)
+        obj = tm.get_obj(obj, frame_or_series)
+
+        result = obj.tz_convert("Europe/Berlin")
+        expected = DataFrame({"a": 1}, rng.tz_convert("Europe/Berlin"))
+        expected = tm.get_obj(expected, frame_or_series)
+
+        assert result.index.tz.zone == "Europe/Berlin"
+        tm.assert_equal(result, expected)
+
+    def test_tz_convert_axis1(self):
+        rng = date_range("1/1/2011", periods=200, freq="D", tz="US/Eastern")
+
+        obj = DataFrame({"a": 1}, index=rng)
+
+        obj = obj.T
+        result = obj.tz_convert("Europe/Berlin", axis=1)
+        assert result.columns.tz.zone == "Europe/Berlin"
+
+        expected = DataFrame({"a": 1}, rng.tz_convert("Europe/Berlin"))
+
+        tm.assert_equal(result, expected.T)
+
+    def test_tz_convert_naive(self, frame_or_series):
+        # can't convert tz-naive
+        rng = date_range("1/1/2011", periods=200, freq="D")
+        ts = Series(1, index=rng)
+        ts = frame_or_series(ts)
+
+        with pytest.raises(TypeError, match="Cannot convert tz-naive"):
+            ts.tz_convert("US/Eastern")
+
+    @pytest.mark.parametrize("fn", ["tz_localize", "tz_convert"])
+    def test_tz_convert_and_localize(self, fn):
+        l0 = date_range("20140701", periods=5, freq="D")
+        l1 = date_range("20140701", periods=5, freq="D")
+
+        int_idx = Index(range(5))
+
+        if fn == "tz_convert":
+            l0 = l0.tz_localize("UTC")
+            l1 = l1.tz_localize("UTC")
+
+        for idx in [l0, l1]:
+            l0_expected = getattr(idx, fn)("US/Pacific")
+            l1_expected = getattr(idx, fn)("US/Pacific")
+
+            df1 = DataFrame(np.ones(5), index=l0)
+            df1 = getattr(df1, fn)("US/Pacific")
+            tm.assert_index_equal(df1.index, l0_expected)
+
+            # MultiIndex
+            # GH7846
+            df2 = DataFrame(np.ones(5), MultiIndex.from_arrays([l0, l1]))
+
+            # freq is not preserved in MultiIndex construction
+            l1_expected = l1_expected._with_freq(None)
+            l0_expected = l0_expected._with_freq(None)
+            l1 = l1._with_freq(None)
+            l0 = l0._with_freq(None)
+
+            df3 = getattr(df2, fn)("US/Pacific", level=0)
+            assert not df3.index.levels[0].equals(l0)
+            tm.assert_index_equal(df3.index.levels[0], l0_expected)
+            tm.assert_index_equal(df3.index.levels[1], l1)
+            assert not df3.index.levels[1].equals(l1_expected)
+
+            df3 = getattr(df2, fn)("US/Pacific", level=1)
+            tm.assert_index_equal(df3.index.levels[0], l0)
+            assert not df3.index.levels[0].equals(l0_expected)
+            tm.assert_index_equal(df3.index.levels[1], l1_expected)
+            assert not df3.index.levels[1].equals(l1)
+
+            df4 = DataFrame(np.ones(5), MultiIndex.from_arrays([int_idx, l0]))
+
+            # TODO: untested
+            df5 = getattr(df4, fn)("US/Pacific", level=1)  # noqa
+
+            tm.assert_index_equal(df3.index.levels[0], l0)
+            assert not df3.index.levels[0].equals(l0_expected)
+            tm.assert_index_equal(df3.index.levels[1], l1_expected)
+            assert not df3.index.levels[1].equals(l1)
+
+        # Bad Inputs
+
+        # Not DatetimeIndex / PeriodIndex
+        with pytest.raises(TypeError, match="DatetimeIndex"):
+            df = DataFrame(index=int_idx)
+            getattr(df, fn)("US/Pacific")
+
+        # Not DatetimeIndex / PeriodIndex
+        with pytest.raises(TypeError, match="DatetimeIndex"):
+            df = DataFrame(np.ones(5), MultiIndex.from_arrays([int_idx, l0]))
+            getattr(df, fn)("US/Pacific", level=0)
+
+        # Invalid level
+        with pytest.raises(ValueError, match="not valid"):
+            df = DataFrame(index=l0)
+            getattr(df, fn)("US/Pacific", level=1)
+
+    @pytest.mark.parametrize("copy", [True, False])
+    def test_tz_convert_copy_inplace_mutate(self, copy, frame_or_series):
+        # GH#6326
+        obj = frame_or_series(
+            np.arange(0, 5),
+            index=date_range("20131027", periods=5, freq="1H", tz="Europe/Berlin"),
+        )
+        orig = obj.copy()
+        result = obj.tz_convert("UTC", copy=copy)
+        expected = frame_or_series(np.arange(0, 5), index=obj.index.tz_convert("UTC"))
+        tm.assert_equal(result, expected)
+        tm.assert_equal(obj, orig)
+        assert result.index is not obj.index
+        assert result is not obj