Add files using upload-large-folder tool

.gitattributes

@@ -1289,3 +1289,9 @@ videochat2/lib/python3.10/site-packages/pandas/tests/io/formats/__pycache__/test
 videochat2/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_loc.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 videochat2/lib/python3.10/site-packages/pandas/tests/tools/__pycache__/test_to_datetime.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 videochat2/lib/python3.10/site-packages/ninja/data/bin/ninja filter=lfs diff=lfs merge=lfs -text
+videochat2/lib/python3.10/site-packages/opencv_python.libs/libswresample-c26a2b7e.so.4.7.100 filter=lfs diff=lfs merge=lfs -text
+videochat2/lib/python3.10/site-packages/opencv_python.libs/libxcb-xkb-9ba31ab3.so.1.0.0 filter=lfs diff=lfs merge=lfs -text
+videochat2/lib/python3.10/site-packages/opencv_python.libs/libvpx-2c989c7f.so.8.0.0 filter=lfs diff=lfs merge=lfs -text
+videochat2/lib/python3.10/site-packages/opencv_python.libs/libavformat-0e2a2001.so.59.27.100 filter=lfs diff=lfs merge=lfs -text
+videochat2/lib/python3.10/site-packages/opencv_python.libs/libssl-4e89c2e4.so.1.1 filter=lfs diff=lfs merge=lfs -text
+videochat2/lib/python3.10/site-packages/opencv_python.libs/libQt5Test-c38a5234.so.5.15.0 filter=lfs diff=lfs merge=lfs -text

videochat2/lib/python3.10/site-packages/PyYAML-6.0.1.dist-info/INSTALLER

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

videochat2/lib/python3.10/site-packages/PyYAML-6.0.1.dist-info/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2017-2021 Ingy döt Net
+Copyright (c) 2006-2016 Kirill Simonov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

videochat2/lib/python3.10/site-packages/PyYAML-6.0.1.dist-info/METADATA

@@ -0,0 +1,46 @@
+Metadata-Version: 2.1
+Name: PyYAML
+Version: 6.0.1
+Summary: YAML parser and emitter for Python
+Home-page: https://pyyaml.org/
+Download-URL: https://pypi.org/project/PyYAML/
+Author: Kirill Simonov
+Author-email: xi@resolvent.net
+License: MIT
+Project-URL: Bug Tracker, https://github.com/yaml/pyyaml/issues
+Project-URL: CI, https://github.com/yaml/pyyaml/actions
+Project-URL: Documentation, https://pyyaml.org/wiki/PyYAMLDocumentation
+Project-URL: Mailing lists, http://lists.sourceforge.net/lists/listinfo/yaml-core
+Project-URL: Source Code, https://github.com/yaml/pyyaml
+Platform: Any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Markup
+Requires-Python: >=3.6
+License-File: LICENSE
+
+YAML is a data serialization format designed for human readability
+and interaction with scripting languages.  PyYAML is a YAML parser
+and emitter for Python.
+
+PyYAML features a complete YAML 1.1 parser, Unicode support, pickle
+support, capable extension API, and sensible error messages.  PyYAML
+supports standard YAML tags and provides Python-specific tags that
+allow to represent an arbitrary Python object.
+
+PyYAML is applicable for a broad range of tasks from complex
+configuration files to object serialization and persistence.

videochat2/lib/python3.10/site-packages/PyYAML-6.0.1.dist-info/RECORD

@@ -0,0 +1,44 @@
+PyYAML-6.0.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+PyYAML-6.0.1.dist-info/LICENSE,sha256=jTko-dxEkP1jVwfLiOsmvXZBAqcoKVQwfT5RZ6V36KQ,1101
+PyYAML-6.0.1.dist-info/METADATA,sha256=UNNF8-SzzwOKXVo-kV5lXUGH2_wDWMBmGxqISpp5HQk,2058
+PyYAML-6.0.1.dist-info/RECORD,,
+PyYAML-6.0.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+PyYAML-6.0.1.dist-info/WHEEL,sha256=iZaXX0Td62Nww8bojl0E84uJHjT41csHPKZmbUBbJPs,152
+PyYAML-6.0.1.dist-info/top_level.txt,sha256=rpj0IVMTisAjh_1vG3Ccf9v5jpCQwAz6cD1IVU5ZdhQ,11
+_yaml/__init__.py,sha256=04Ae_5osxahpJHa3XBZUAf4wi6XX32gR8D6X6p64GEA,1402
+_yaml/__pycache__/__init__.cpython-310.pyc,,
+yaml/__init__.py,sha256=bhl05qSeO-1ZxlSRjGrvl2m9nrXb1n9-GQatTN0Mrqc,12311
+yaml/__pycache__/__init__.cpython-310.pyc,,
+yaml/__pycache__/composer.cpython-310.pyc,,
+yaml/__pycache__/constructor.cpython-310.pyc,,
+yaml/__pycache__/cyaml.cpython-310.pyc,,
+yaml/__pycache__/dumper.cpython-310.pyc,,
+yaml/__pycache__/emitter.cpython-310.pyc,,
+yaml/__pycache__/error.cpython-310.pyc,,
+yaml/__pycache__/events.cpython-310.pyc,,
+yaml/__pycache__/loader.cpython-310.pyc,,
+yaml/__pycache__/nodes.cpython-310.pyc,,
+yaml/__pycache__/parser.cpython-310.pyc,,
+yaml/__pycache__/reader.cpython-310.pyc,,
+yaml/__pycache__/representer.cpython-310.pyc,,
+yaml/__pycache__/resolver.cpython-310.pyc,,
+yaml/__pycache__/scanner.cpython-310.pyc,,
+yaml/__pycache__/serializer.cpython-310.pyc,,
+yaml/__pycache__/tokens.cpython-310.pyc,,
+yaml/_yaml.cpython-310-x86_64-linux-gnu.so,sha256=_9iVrASatQgQSFXlKeCe2uK2TyKwk9nd61Cs_-fqAHM,2226000
+yaml/composer.py,sha256=_Ko30Wr6eDWUeUpauUGT3Lcg9QPBnOPVlTnIMRGJ9FM,4883
+yaml/constructor.py,sha256=kNgkfaeLUkwQYY_Q6Ff1Tz2XVw_pG1xVE9Ak7z-viLA,28639
+yaml/cyaml.py,sha256=6ZrAG9fAYvdVe2FK_w0hmXoG7ZYsoYUwapG8CiC72H0,3851
+yaml/dumper.py,sha256=PLctZlYwZLp7XmeUdwRuv4nYOZ2UBnDIUy8-lKfLF-o,2837
+yaml/emitter.py,sha256=jghtaU7eFwg31bG0B7RZea_29Adi9CKmXq_QjgQpCkQ,43006
+yaml/error.py,sha256=Ah9z-toHJUbE9j-M8YpxgSRM5CgLCcwVzJgLLRF2Fxo,2533
+yaml/events.py,sha256=50_TksgQiE4up-lKo_V-nBy-tAIxkIPQxY5qDhKCeHw,2445
+yaml/loader.py,sha256=UVa-zIqmkFSCIYq_PgSGm4NSJttHY2Rf_zQ4_b1fHN0,2061
+yaml/nodes.py,sha256=gPKNj8pKCdh2d4gr3gIYINnPOaOxGhJAUiYhGRnPE84,1440
+yaml/parser.py,sha256=ilWp5vvgoHFGzvOZDItFoGjD6D42nhlZrZyjAwa0oJo,25495
+yaml/reader.py,sha256=0dmzirOiDG4Xo41RnuQS7K9rkY3xjHiVasfDMNTqCNw,6794
+yaml/representer.py,sha256=IuWP-cAW9sHKEnS0gCqSa894k1Bg4cgTxaDwIcbRQ-Y,14190
+yaml/resolver.py,sha256=9L-VYfm4mWHxUD1Vg4X7rjDRK_7VZd6b92wzq7Y2IKY,9004
+yaml/scanner.py,sha256=YEM3iLZSaQwXcQRg2l2R4MdT0zGP2F9eHkKGKnHyWQY,51279
+yaml/serializer.py,sha256=ChuFgmhU01hj4xgI8GaKv6vfM2Bujwa9i7d2FAHj7cA,4165
+yaml/tokens.py,sha256=lTQIzSVw8Mg9wv459-TjiOQe6wVziqaRlqX2_89rp54,2573

videochat2/lib/python3.10/site-packages/PyYAML-6.0.1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.40.0)
+Root-Is-Purelib: false
+Tag: cp310-cp310-manylinux_2_17_x86_64
+Tag: cp310-cp310-manylinux2014_x86_64
+

videochat2/lib/python3.10/site-packages/PyYAML-6.0.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+_yaml
+yaml

videochat2/lib/python3.10/site-packages/WebOb-1.8.9.dist-info/top_level.txt

@@ -0,0 +1 @@
+webob

videochat2/lib/python3.10/site-packages/opencv_python.libs/libQt5Test-c38a5234.so.5.15.0

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

videochat2/lib/python3.10/site-packages/opencv_python.libs/libavformat-0e2a2001.so.59.27.100

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

videochat2/lib/python3.10/site-packages/opencv_python.libs/libssl-4e89c2e4.so.1.1

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

videochat2/lib/python3.10/site-packages/opencv_python.libs/libswresample-c26a2b7e.so.4.7.100

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

videochat2/lib/python3.10/site-packages/opencv_python.libs/libvpx-2c989c7f.so.8.0.0

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

videochat2/lib/python3.10/site-packages/opencv_python.libs/libxcb-xkb-9ba31ab3.so.1.0.0

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

videochat2/lib/python3.10/site-packages/pandas/tests/api/test_api.py

@@ -0,0 +1,258 @@
+from __future__ import annotations
+
+import pytest
+
+import pandas as pd
+from pandas import api
+import pandas._testing as tm
+
+
+class Base:
+    def check(self, namespace, expected, ignored=None):
+        # see which names are in the namespace, minus optional
+        # ignored ones
+        # compare vs the expected
+
+        result = sorted(
+            f for f in dir(namespace) if not f.startswith("__") and f != "annotations"
+        )
+        if ignored is not None:
+            result = sorted(set(result) - set(ignored))
+
+        expected = sorted(expected)
+        tm.assert_almost_equal(result, expected)
+
+
+class TestPDApi(Base):
+    # these are optionally imported based on testing
+    # & need to be ignored
+    ignored = ["tests", "locale", "conftest"]
+
+    # top-level sub-packages
+    public_lib = [
+        "api",
+        "arrays",
+        "options",
+        "test",
+        "testing",
+        "errors",
+        "plotting",
+        "io",
+        "tseries",
+    ]
+    private_lib = ["compat", "core", "pandas", "util"]
+
+    # misc
+    misc = ["IndexSlice", "NaT", "NA"]
+
+    # top-level classes
+    classes = [
+        "ArrowDtype",
+        "Categorical",
+        "CategoricalIndex",
+        "DataFrame",
+        "DateOffset",
+        "DatetimeIndex",
+        "ExcelFile",
+        "ExcelWriter",
+        "Flags",
+        "Grouper",
+        "HDFStore",
+        "Index",
+        "MultiIndex",
+        "Period",
+        "PeriodIndex",
+        "RangeIndex",
+        "Series",
+        "SparseDtype",
+        "StringDtype",
+        "Timedelta",
+        "TimedeltaIndex",
+        "Timestamp",
+        "Interval",
+        "IntervalIndex",
+        "CategoricalDtype",
+        "PeriodDtype",
+        "IntervalDtype",
+        "DatetimeTZDtype",
+        "BooleanDtype",
+        "Int8Dtype",
+        "Int16Dtype",
+        "Int32Dtype",
+        "Int64Dtype",
+        "UInt8Dtype",
+        "UInt16Dtype",
+        "UInt32Dtype",
+        "UInt64Dtype",
+        "Float32Dtype",
+        "Float64Dtype",
+        "NamedAgg",
+    ]
+
+    # these are already deprecated; awaiting removal
+    deprecated_classes: list[str] = []
+
+    # external modules exposed in pandas namespace
+    modules: list[str] = []
+
+    # top-level functions
+    funcs = [
+        "array",
+        "bdate_range",
+        "concat",
+        "crosstab",
+        "cut",
+        "date_range",
+        "interval_range",
+        "eval",
+        "factorize",
+        "get_dummies",
+        "from_dummies",
+        "infer_freq",
+        "isna",
+        "isnull",
+        "lreshape",
+        "melt",
+        "notna",
+        "notnull",
+        "offsets",
+        "merge",
+        "merge_ordered",
+        "merge_asof",
+        "period_range",
+        "pivot",
+        "pivot_table",
+        "qcut",
+        "show_versions",
+        "timedelta_range",
+        "unique",
+        "value_counts",
+        "wide_to_long",
+    ]
+
+    # top-level option funcs
+    funcs_option = [
+        "reset_option",
+        "describe_option",
+        "get_option",
+        "option_context",
+        "set_option",
+        "set_eng_float_format",
+    ]
+
+    # top-level read_* funcs
+    funcs_read = [
+        "read_clipboard",
+        "read_csv",
+        "read_excel",
+        "read_fwf",
+        "read_gbq",
+        "read_hdf",
+        "read_html",
+        "read_xml",
+        "read_json",
+        "read_pickle",
+        "read_sas",
+        "read_sql",
+        "read_sql_query",
+        "read_sql_table",
+        "read_stata",
+        "read_table",
+        "read_feather",
+        "read_parquet",
+        "read_orc",
+        "read_spss",
+    ]
+
+    # top-level json funcs
+    funcs_json = ["json_normalize"]
+
+    # top-level to_* funcs
+    funcs_to = ["to_datetime", "to_numeric", "to_pickle", "to_timedelta"]
+
+    # top-level to deprecate in the future
+    deprecated_funcs_in_future: list[str] = []
+
+    # these are already deprecated; awaiting removal
+    deprecated_funcs: list[str] = []
+
+    # private modules in pandas namespace
+    private_modules = [
+        "_config",
+        "_libs",
+        "_is_numpy_dev",
+        "_testing",
+        "_typing",
+        "_version",
+    ]
+
+    def test_api(self):
+        checkthese = (
+            self.public_lib
+            + self.private_lib
+            + self.misc
+            + self.modules
+            + self.classes
+            + self.funcs
+            + self.funcs_option
+            + self.funcs_read
+            + self.funcs_json
+            + self.funcs_to
+            + self.private_modules
+        )
+        self.check(namespace=pd, expected=checkthese, ignored=self.ignored)
+
+    def test_api_all(self):
+        expected = set(
+            self.public_lib
+            + self.misc
+            + self.modules
+            + self.classes
+            + self.funcs
+            + self.funcs_option
+            + self.funcs_read
+            + self.funcs_json
+            + self.funcs_to
+        ) - set(self.deprecated_classes)
+        actual = set(pd.__all__)
+
+        extraneous = actual - expected
+        assert not extraneous
+
+        missing = expected - actual
+        assert not missing
+
+    def test_depr(self):
+        deprecated_list = (
+            self.deprecated_classes
+            + self.deprecated_funcs
+            + self.deprecated_funcs_in_future
+        )
+        for depr in deprecated_list:
+            with tm.assert_produces_warning(FutureWarning):
+                _ = getattr(pd, depr)
+
+
+class TestApi(Base):
+    allowed = ["types", "extensions", "indexers", "interchange"]
+
+    def test_api(self):
+        self.check(api, self.allowed)
+
+
+class TestTesting(Base):
+    funcs = [
+        "assert_frame_equal",
+        "assert_series_equal",
+        "assert_index_equal",
+        "assert_extension_array_equal",
+    ]
+
+    def test_testing(self):
+        from pandas import testing
+
+        self.check(testing, self.funcs)
+
+    def test_util_in_top_level(self):
+        with pytest.raises(AttributeError, match="foo"):
+            pd.util.foo

videochat2/lib/python3.10/site-packages/pandas/tests/base/test_constructors.py

@@ -0,0 +1,174 @@
+from datetime import datetime
+import sys
+
+import numpy as np
+import pytest
+
+from pandas.compat import PYPY
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+)
+import pandas._testing as tm
+from pandas.core.accessor import PandasDelegate
+from pandas.core.base import (
+    NoNewAttributesMixin,
+    PandasObject,
+)
+
+
+def series_via_frame_from_dict(x, **kwargs):
+    return DataFrame({"a": x}, **kwargs)["a"]
+
+
+def series_via_frame_from_scalar(x, **kwargs):
+    return DataFrame(x, **kwargs)[0]
+
+
+@pytest.fixture(
+    params=[
+        Series,
+        series_via_frame_from_dict,
+        series_via_frame_from_scalar,
+        Index,
+    ],
+    ids=["Series", "DataFrame-dict", "DataFrame-array", "Index"],
+)
+def constructor(request):
+    return request.param
+
+
+class TestPandasDelegate:
+    class Delegator:
+        _properties = ["prop"]
+        _methods = ["test_method"]
+
+        def _set_prop(self, value):
+            self.prop = value
+
+        def _get_prop(self):
+            return self.prop
+
+        prop = property(_get_prop, _set_prop, doc="foo property")
+
+        def test_method(self, *args, **kwargs):
+            """a test method"""
+
+    class Delegate(PandasDelegate, PandasObject):
+        def __init__(self, obj) -> None:
+            self.obj = obj
+
+    def test_invalid_delegation(self):
+        # these show that in order for the delegation to work
+        # the _delegate_* methods need to be overridden to not raise
+        # a TypeError
+
+        self.Delegate._add_delegate_accessors(
+            delegate=self.Delegator,
+            accessors=self.Delegator._properties,
+            typ="property",
+        )
+        self.Delegate._add_delegate_accessors(
+            delegate=self.Delegator, accessors=self.Delegator._methods, typ="method"
+        )
+
+        delegate = self.Delegate(self.Delegator())
+
+        msg = "You cannot access the property prop"
+        with pytest.raises(TypeError, match=msg):
+            delegate.prop
+
+        msg = "The property prop cannot be set"
+        with pytest.raises(TypeError, match=msg):
+            delegate.prop = 5
+
+        msg = "You cannot access the property prop"
+        with pytest.raises(TypeError, match=msg):
+            delegate.prop
+
+    @pytest.mark.skipif(PYPY, reason="not relevant for PyPy")
+    def test_memory_usage(self):
+        # Delegate does not implement memory_usage.
+        # Check that we fall back to in-built `__sizeof__`
+        # GH 12924
+        delegate = self.Delegate(self.Delegator())
+        sys.getsizeof(delegate)
+
+
+class TestNoNewAttributesMixin:
+    def test_mixin(self):
+        class T(NoNewAttributesMixin):
+            pass
+
+        t = T()
+        assert not hasattr(t, "__frozen")
+
+        t.a = "test"
+        assert t.a == "test"
+
+        t._freeze()
+        assert "__frozen" in dir(t)
+        assert getattr(t, "__frozen")
+        msg = "You cannot add any new attribute"
+        with pytest.raises(AttributeError, match=msg):
+            t.b = "test"
+
+        assert not hasattr(t, "b")
+
+
+class TestConstruction:
+    # test certain constructor behaviours on dtype inference across Series,
+    # Index and DataFrame
+
+    @pytest.mark.parametrize(
+        "a",
+        [
+            np.array(["2263-01-01"], dtype="datetime64[D]"),
+            np.array([datetime(2263, 1, 1)], dtype=object),
+            np.array([np.datetime64("2263-01-01", "D")], dtype=object),
+            np.array(["2263-01-01"], dtype=object),
+        ],
+        ids=[
+            "datetime64[D]",
+            "object-datetime.datetime",
+            "object-numpy-scalar",
+            "object-string",
+        ],
+    )
+    def test_constructor_datetime_outofbound(self, a, constructor):
+        # GH-26853 (+ bug GH-26206 out of bound non-ns unit)
+
+        # No dtype specified (dtype inference)
+        # datetime64[non-ns] raise error, other cases result in object dtype
+        # and preserve original data
+        if a.dtype.kind == "M":
+            # Can't fit in nanosecond bounds -> get the nearest supported unit
+            result = constructor(a)
+            assert result.dtype == "M8[s]"
+        else:
+            result = constructor(a)
+            assert result.dtype == "object"
+            tm.assert_numpy_array_equal(result.to_numpy(), a)
+
+        # Explicit dtype specified
+        # Forced conversion fails for all -> all cases raise error
+        msg = "Out of bounds|Out of bounds .* present at position 0"
+        with pytest.raises(pd.errors.OutOfBoundsDatetime, match=msg):
+            constructor(a, dtype="datetime64[ns]")
+
+    def test_constructor_datetime_nonns(self, constructor):
+        arr = np.array(["2020-01-01T00:00:00.000000"], dtype="datetime64[us]")
+        dta = pd.core.arrays.DatetimeArray._simple_new(arr, dtype=arr.dtype)
+        expected = constructor(dta)
+        assert expected.dtype == arr.dtype
+
+        result = constructor(arr)
+        tm.assert_equal(result, expected)
+
+        # https://github.com/pandas-dev/pandas/issues/34843
+        arr.flags.writeable = False
+        result = constructor(arr)
+        tm.assert_equal(result, expected)

videochat2/lib/python3.10/site-packages/pandas/tests/base/test_conversion.py

@@ -0,0 +1,551 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.common import (
+    is_datetime64_dtype,
+    is_timedelta64_dtype,
+)
+from pandas.core.dtypes.dtypes import DatetimeTZDtype
+
+import pandas as pd
+from pandas import (
+    CategoricalIndex,
+    Series,
+    Timedelta,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+from pandas.core.arrays import (
+    DatetimeArray,
+    IntervalArray,
+    PandasArray,
+    PeriodArray,
+    SparseArray,
+    TimedeltaArray,
+)
+
+
+class TestToIterable:
+    # test that we convert an iterable to python types
+
+    dtypes = [
+        ("int8", int),
+        ("int16", int),
+        ("int32", int),
+        ("int64", int),
+        ("uint8", int),
+        ("uint16", int),
+        ("uint32", int),
+        ("uint64", int),
+        ("float16", float),
+        ("float32", float),
+        ("float64", float),
+        ("datetime64[ns]", Timestamp),
+        ("datetime64[ns, US/Eastern]", Timestamp),
+        ("timedelta64[ns]", Timedelta),
+    ]
+
+    @pytest.mark.parametrize("dtype, rdtype", dtypes)
+    @pytest.mark.parametrize(
+        "method",
+        [
+            lambda x: x.tolist(),
+            lambda x: x.to_list(),
+            lambda x: list(x),
+            lambda x: list(x.__iter__()),
+        ],
+        ids=["tolist", "to_list", "list", "iter"],
+    )
+    def test_iterable(self, index_or_series, method, dtype, rdtype):
+        # gh-10904
+        # gh-13258
+        # coerce iteration to underlying python / pandas types
+        typ = index_or_series
+        if dtype == "float16" and issubclass(typ, pd.Index):
+            with pytest.raises(NotImplementedError, match="float16 indexes are not "):
+                typ([1], dtype=dtype)
+            return
+        s = typ([1], dtype=dtype)
+        result = method(s)[0]
+        assert isinstance(result, rdtype)
+
+    @pytest.mark.parametrize(
+        "dtype, rdtype, obj",
+        [
+            ("object", object, "a"),
+            ("object", int, 1),
+            ("category", object, "a"),
+            ("category", int, 1),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "method",
+        [
+            lambda x: x.tolist(),
+            lambda x: x.to_list(),
+            lambda x: list(x),
+            lambda x: list(x.__iter__()),
+        ],
+        ids=["tolist", "to_list", "list", "iter"],
+    )
+    def test_iterable_object_and_category(
+        self, index_or_series, method, dtype, rdtype, obj
+    ):
+        # gh-10904
+        # gh-13258
+        # coerce iteration to underlying python / pandas types
+        typ = index_or_series
+        s = typ([obj], dtype=dtype)
+        result = method(s)[0]
+        assert isinstance(result, rdtype)
+
+    @pytest.mark.parametrize("dtype, rdtype", dtypes)
+    def test_iterable_items(self, dtype, rdtype):
+        # gh-13258
+        # test if items yields the correct boxed scalars
+        # this only applies to series
+        s = Series([1], dtype=dtype)
+        _, result = list(s.items())[0]
+        assert isinstance(result, rdtype)
+
+        _, result = list(s.items())[0]
+        assert isinstance(result, rdtype)
+
+    @pytest.mark.parametrize(
+        "dtype, rdtype", dtypes + [("object", int), ("category", int)]
+    )
+    def test_iterable_map(self, index_or_series, dtype, rdtype):
+        # gh-13236
+        # coerce iteration to underlying python / pandas types
+        typ = index_or_series
+        if dtype == "float16" and issubclass(typ, pd.Index):
+            with pytest.raises(NotImplementedError, match="float16 indexes are not "):
+                typ([1], dtype=dtype)
+            return
+        s = typ([1], dtype=dtype)
+        result = s.map(type)[0]
+        if not isinstance(rdtype, tuple):
+            rdtype = (rdtype,)
+        assert result in rdtype
+
+    @pytest.mark.parametrize(
+        "method",
+        [
+            lambda x: x.tolist(),
+            lambda x: x.to_list(),
+            lambda x: list(x),
+            lambda x: list(x.__iter__()),
+        ],
+        ids=["tolist", "to_list", "list", "iter"],
+    )
+    def test_categorial_datetimelike(self, method):
+        i = CategoricalIndex([Timestamp("1999-12-31"), Timestamp("2000-12-31")])
+
+        result = method(i)[0]
+        assert isinstance(result, Timestamp)
+
+    def test_iter_box(self):
+        vals = [Timestamp("2011-01-01"), Timestamp("2011-01-02")]
+        s = Series(vals)
+        assert s.dtype == "datetime64[ns]"
+        for res, exp in zip(s, vals):
+            assert isinstance(res, Timestamp)
+            assert res.tz is None
+            assert res == exp
+
+        vals = [
+            Timestamp("2011-01-01", tz="US/Eastern"),
+            Timestamp("2011-01-02", tz="US/Eastern"),
+        ]
+        s = Series(vals)
+
+        assert s.dtype == "datetime64[ns, US/Eastern]"
+        for res, exp in zip(s, vals):
+            assert isinstance(res, Timestamp)
+            assert res.tz == exp.tz
+            assert res == exp
+
+        # timedelta
+        vals = [Timedelta("1 days"), Timedelta("2 days")]
+        s = Series(vals)
+        assert s.dtype == "timedelta64[ns]"
+        for res, exp in zip(s, vals):
+            assert isinstance(res, Timedelta)
+            assert res == exp
+
+        # period
+        vals = [pd.Period("2011-01-01", freq="M"), pd.Period("2011-01-02", freq="M")]
+        s = Series(vals)
+        assert s.dtype == "Period[M]"
+        for res, exp in zip(s, vals):
+            assert isinstance(res, pd.Period)
+            assert res.freq == "M"
+            assert res == exp
+
+
+@pytest.mark.parametrize(
+    "arr, expected_type, dtype",
+    [
+        (np.array([0, 1], dtype=np.int64), np.ndarray, "int64"),
+        (np.array(["a", "b"]), np.ndarray, "object"),
+        (pd.Categorical(["a", "b"]), pd.Categorical, "category"),
+        (
+            pd.DatetimeIndex(["2017", "2018"], tz="US/Central"),
+            DatetimeArray,
+            "datetime64[ns, US/Central]",
+        ),
+        (
+            pd.PeriodIndex([2018, 2019], freq="A"),
+            PeriodArray,
+            pd.core.dtypes.dtypes.PeriodDtype("A-DEC"),
+        ),
+        (pd.IntervalIndex.from_breaks([0, 1, 2]), IntervalArray, "interval"),
+        (
+            pd.DatetimeIndex(["2017", "2018"]),
+            DatetimeArray,
+            "datetime64[ns]",
+        ),
+        (
+            pd.TimedeltaIndex([10**10]),
+            TimedeltaArray,
+            "m8[ns]",
+        ),
+    ],
+)
+def test_values_consistent(arr, expected_type, dtype):
+    l_values = Series(arr)._values
+    r_values = pd.Index(arr)._values
+    assert type(l_values) is expected_type
+    assert type(l_values) is type(r_values)
+
+    tm.assert_equal(l_values, r_values)
+
+
+@pytest.mark.parametrize("arr", [np.array([1, 2, 3])])
+def test_numpy_array(arr):
+    ser = Series(arr)
+    result = ser.array
+    expected = PandasArray(arr)
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_numpy_array_all_dtypes(any_numpy_dtype):
+    ser = Series(dtype=any_numpy_dtype)
+    result = ser.array
+    if is_datetime64_dtype(any_numpy_dtype):
+        assert isinstance(result, DatetimeArray)
+    elif is_timedelta64_dtype(any_numpy_dtype):
+        assert isinstance(result, TimedeltaArray)
+    else:
+        assert isinstance(result, PandasArray)
+
+
+@pytest.mark.parametrize(
+    "arr, attr",
+    [
+        (pd.Categorical(["a", "b"]), "_codes"),
+        (pd.core.arrays.period_array(["2000", "2001"], freq="D"), "_ndarray"),
+        (pd.array([0, np.nan], dtype="Int64"), "_data"),
+        (IntervalArray.from_breaks([0, 1]), "_left"),
+        (SparseArray([0, 1]), "_sparse_values"),
+        (DatetimeArray(np.array([1, 2], dtype="datetime64[ns]")), "_ndarray"),
+        # tz-aware Datetime
+        (
+            DatetimeArray(
+                np.array(
+                    ["2000-01-01T12:00:00", "2000-01-02T12:00:00"], dtype="M8[ns]"
+                ),
+                dtype=DatetimeTZDtype(tz="US/Central"),
+            ),
+            "_ndarray",
+        ),
+    ],
+)
+def test_array(arr, attr, index_or_series, request):
+    box = index_or_series
+
+    result = box(arr, copy=False).array
+
+    if attr:
+        arr = getattr(arr, attr)
+        result = getattr(result, attr)
+
+    assert result is arr
+
+
+def test_array_multiindex_raises():
+    idx = pd.MultiIndex.from_product([["A"], ["a", "b"]])
+    msg = "MultiIndex has no single backing array"
+    with pytest.raises(ValueError, match=msg):
+        idx.array
+
+
+@pytest.mark.parametrize(
+    "arr, expected",
+    [
+        (np.array([1, 2], dtype=np.int64), np.array([1, 2], dtype=np.int64)),
+        (pd.Categorical(["a", "b"]), np.array(["a", "b"], dtype=object)),
+        (
+            pd.core.arrays.period_array(["2000", "2001"], freq="D"),
+            np.array([pd.Period("2000", freq="D"), pd.Period("2001", freq="D")]),
+        ),
+        (pd.array([0, np.nan], dtype="Int64"), np.array([0, pd.NA], dtype=object)),
+        (
+            IntervalArray.from_breaks([0, 1, 2]),
+            np.array([pd.Interval(0, 1), pd.Interval(1, 2)], dtype=object),
+        ),
+        (SparseArray([0, 1]), np.array([0, 1], dtype=np.int64)),
+        # tz-naive datetime
+        (
+            DatetimeArray(np.array(["2000", "2001"], dtype="M8[ns]")),
+            np.array(["2000", "2001"], dtype="M8[ns]"),
+        ),
+        # tz-aware stays tz`-aware
+        (
+            DatetimeArray(
+                np.array(
+                    ["2000-01-01T06:00:00", "2000-01-02T06:00:00"], dtype="M8[ns]"
+                ),
+                dtype=DatetimeTZDtype(tz="US/Central"),
+            ),
+            np.array(
+                [
+                    Timestamp("2000-01-01", tz="US/Central"),
+                    Timestamp("2000-01-02", tz="US/Central"),
+                ]
+            ),
+        ),
+        # Timedelta
+        (
+            TimedeltaArray(np.array([0, 3600000000000], dtype="i8"), freq="H"),
+            np.array([0, 3600000000000], dtype="m8[ns]"),
+        ),
+        # GH#26406 tz is preserved in Categorical[dt64tz]
+        (
+            pd.Categorical(date_range("2016-01-01", periods=2, tz="US/Pacific")),
+            np.array(
+                [
+                    Timestamp("2016-01-01", tz="US/Pacific"),
+                    Timestamp("2016-01-02", tz="US/Pacific"),
+                ]
+            ),
+        ),
+    ],
+)
+def test_to_numpy(arr, expected, index_or_series_or_array, request):
+    box = index_or_series_or_array
+
+    with tm.assert_produces_warning(None):
+        thing = box(arr)
+
+    if arr.dtype.name == "int64" and box is pd.array:
+        mark = pytest.mark.xfail(reason="thing is Int64 and to_numpy() returns object")
+        request.node.add_marker(mark)
+
+    result = thing.to_numpy()
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = np.asarray(thing)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("as_series", [True, False])
+@pytest.mark.parametrize(
+    "arr", [np.array([1, 2, 3], dtype="int64"), np.array(["a", "b", "c"], dtype=object)]
+)
+def test_to_numpy_copy(arr, as_series):
+    obj = pd.Index(arr, copy=False)
+    if as_series:
+        obj = Series(obj.values, copy=False)
+
+    # no copy by default
+    result = obj.to_numpy()
+    assert np.shares_memory(arr, result) is True
+
+    result = obj.to_numpy(copy=False)
+    assert np.shares_memory(arr, result) is True
+
+    # copy=True
+    result = obj.to_numpy(copy=True)
+    assert np.shares_memory(arr, result) is False
+
+
+@pytest.mark.parametrize("as_series", [True, False])
+def test_to_numpy_dtype(as_series):
+    tz = "US/Eastern"
+    obj = pd.DatetimeIndex(["2000", "2001"], tz=tz)
+    if as_series:
+        obj = Series(obj)
+
+    # preserve tz by default
+    result = obj.to_numpy()
+    expected = np.array(
+        [Timestamp("2000", tz=tz), Timestamp("2001", tz=tz)], dtype=object
+    )
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = obj.to_numpy(dtype="object")
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = obj.to_numpy(dtype="M8[ns]")
+    expected = np.array(["2000-01-01T05", "2001-01-01T05"], dtype="M8[ns]")
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "values, dtype, na_value, expected",
+    [
+        ([1, 2, None], "float64", 0, [1.0, 2.0, 0.0]),
+        (
+            [Timestamp("2000"), Timestamp("2000"), pd.NaT],
+            None,
+            Timestamp("2000"),
+            [np.datetime64("2000-01-01T00:00:00.000000000")] * 3,
+        ),
+    ],
+)
+def test_to_numpy_na_value_numpy_dtype(
+    index_or_series, values, dtype, na_value, expected
+):
+    obj = index_or_series(values)
+    result = obj.to_numpy(dtype=dtype, na_value=na_value)
+    expected = np.array(expected)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "data, multiindex, dtype, na_value, expected",
+    [
+        (
+            [1, 2, None, 4],
+            [(0, "a"), (0, "b"), (1, "b"), (1, "c")],
+            float,
+            None,
+            [1.0, 2.0, np.nan, 4.0],
+        ),
+        (
+            [1, 2, None, 4],
+            [(0, "a"), (0, "b"), (1, "b"), (1, "c")],
+            float,
+            np.nan,
+            [1.0, 2.0, np.nan, 4.0],
+        ),
+        (
+            [1.0, 2.0, np.nan, 4.0],
+            [("a", 0), ("a", 1), ("a", 2), ("b", 0)],
+            int,
+            0,
+            [1, 2, 0, 4],
+        ),
+        (
+            [Timestamp("2000"), Timestamp("2000"), pd.NaT],
+            [(0, Timestamp("2021")), (0, Timestamp("2022")), (1, Timestamp("2000"))],
+            None,
+            Timestamp("2000"),
+            [np.datetime64("2000-01-01T00:00:00.000000000")] * 3,
+        ),
+    ],
+)
+def test_to_numpy_multiindex_series_na_value(
+    data, multiindex, dtype, na_value, expected
+):
+    index = pd.MultiIndex.from_tuples(multiindex)
+    series = Series(data, index=index)
+    result = series.to_numpy(dtype=dtype, na_value=na_value)
+    expected = np.array(expected)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_to_numpy_kwargs_raises():
+    # numpy
+    s = Series([1, 2, 3])
+    msg = r"to_numpy\(\) got an unexpected keyword argument 'foo'"
+    with pytest.raises(TypeError, match=msg):
+        s.to_numpy(foo=True)
+
+    # extension
+    s = Series([1, 2, 3], dtype="Int64")
+    with pytest.raises(TypeError, match=msg):
+        s.to_numpy(foo=True)
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        {"a": [1, 2, 3], "b": [1, 2, None]},
+        {"a": np.array([1, 2, 3]), "b": np.array([1, 2, np.nan])},
+        {"a": pd.array([1, 2, 3]), "b": pd.array([1, 2, None])},
+    ],
+)
+@pytest.mark.parametrize("dtype, na_value", [(float, np.nan), (object, None)])
+def test_to_numpy_dataframe_na_value(data, dtype, na_value):
+    # https://github.com/pandas-dev/pandas/issues/33820
+    df = pd.DataFrame(data)
+    result = df.to_numpy(dtype=dtype, na_value=na_value)
+    expected = np.array([[1, 1], [2, 2], [3, na_value]], dtype=dtype)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "data, expected",
+    [
+        (
+            {"a": pd.array([1, 2, None])},
+            np.array([[1.0], [2.0], [np.nan]], dtype=float),
+        ),
+        (
+            {"a": [1, 2, 3], "b": [1, 2, 3]},
+            np.array([[1, 1], [2, 2], [3, 3]], dtype=float),
+        ),
+    ],
+)
+def test_to_numpy_dataframe_single_block(data, expected):
+    # https://github.com/pandas-dev/pandas/issues/33820
+    df = pd.DataFrame(data)
+    result = df.to_numpy(dtype=float, na_value=np.nan)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_to_numpy_dataframe_single_block_no_mutate():
+    # https://github.com/pandas-dev/pandas/issues/33820
+    result = pd.DataFrame(np.array([1.0, 2.0, np.nan]))
+    expected = pd.DataFrame(np.array([1.0, 2.0, np.nan]))
+    result.to_numpy(na_value=0.0)
+    tm.assert_frame_equal(result, expected)
+
+
+class TestAsArray:
+    @pytest.mark.parametrize("tz", [None, "US/Central"])
+    def test_asarray_object_dt64(self, tz):
+        ser = Series(date_range("2000", periods=2, tz=tz))
+
+        with tm.assert_produces_warning(None):
+            # Future behavior (for tzaware case) with no warning
+            result = np.asarray(ser, dtype=object)
+
+        expected = np.array(
+            [Timestamp("2000-01-01", tz=tz), Timestamp("2000-01-02", tz=tz)]
+        )
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_asarray_tz_naive(self):
+        # This shouldn't produce a warning.
+        ser = Series(date_range("2000", periods=2))
+        expected = np.array(["2000-01-01", "2000-01-02"], dtype="M8[ns]")
+        result = np.asarray(ser)
+
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_asarray_tz_aware(self):
+        tz = "US/Central"
+        ser = Series(date_range("2000", periods=2, tz=tz))
+        expected = np.array(["2000-01-01T06", "2000-01-02T06"], dtype="M8[ns]")
+        result = np.asarray(ser, dtype="datetime64[ns]")
+
+        tm.assert_numpy_array_equal(result, expected)
+
+        # Old behavior with no warning
+        result = np.asarray(ser, dtype="M8[ns]")
+
+        tm.assert_numpy_array_equal(result, expected)

videochat2/lib/python3.10/site-packages/pandas/tests/base/test_transpose.py

@@ -0,0 +1,56 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    CategoricalDtype,
+    DataFrame,
+)
+import pandas._testing as tm
+
+
+def test_transpose(index_or_series_obj):
+    obj = index_or_series_obj
+    tm.assert_equal(obj.transpose(), obj)
+
+
+def test_transpose_non_default_axes(index_or_series_obj):
+    msg = "the 'axes' parameter is not supported"
+    obj = index_or_series_obj
+    with pytest.raises(ValueError, match=msg):
+        obj.transpose(1)
+    with pytest.raises(ValueError, match=msg):
+        obj.transpose(axes=1)
+
+
+def test_numpy_transpose(index_or_series_obj):
+    msg = "the 'axes' parameter is not supported"
+    obj = index_or_series_obj
+    tm.assert_equal(np.transpose(obj), obj)
+
+    with pytest.raises(ValueError, match=msg):
+        np.transpose(obj, axes=1)
+
+
+@pytest.mark.parametrize(
+    "data, transposed_data, index, columns, dtype",
+    [
+        ([[1], [2]], [[1, 2]], ["a", "a"], ["b"], int),
+        ([[1], [2]], [[1, 2]], ["a", "a"], ["b"], CategoricalDtype([1, 2])),
+        ([[1, 2]], [[1], [2]], ["b"], ["a", "a"], int),
+        ([[1, 2]], [[1], [2]], ["b"], ["a", "a"], CategoricalDtype([1, 2])),
+        ([[1, 2], [3, 4]], [[1, 3], [2, 4]], ["a", "a"], ["b", "b"], int),
+        (
+            [[1, 2], [3, 4]],
+            [[1, 3], [2, 4]],
+            ["a", "a"],
+            ["b", "b"],
+            CategoricalDtype([1, 2, 3, 4]),
+        ),
+    ],
+)
+def test_duplicate_labels(data, transposed_data, index, columns, dtype):
+    # GH 42380
+    df = DataFrame(data, index=index, columns=columns, dtype=dtype)
+    result = df.T
+    expected = DataFrame(transposed_data, index=columns, columns=index, dtype=dtype)
+    tm.assert_frame_equal(result, expected)

videochat2/lib/python3.10/site-packages/pandas/tests/base/test_unique.py

@@ -0,0 +1,121 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.common import is_datetime64tz_dtype
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.tests.base.common import allow_na_ops
+
+
+def test_unique(index_or_series_obj):
+    obj = index_or_series_obj
+    obj = np.repeat(obj, range(1, len(obj) + 1))
+    result = obj.unique()
+
+    # dict.fromkeys preserves the order
+    unique_values = list(dict.fromkeys(obj.values))
+    if isinstance(obj, pd.MultiIndex):
+        expected = pd.MultiIndex.from_tuples(unique_values)
+        expected.names = obj.names
+        tm.assert_index_equal(result, expected, exact=True)
+    elif isinstance(obj, pd.Index):
+        expected = pd.Index(unique_values, dtype=obj.dtype)
+        if is_datetime64tz_dtype(obj.dtype):
+            expected = expected.normalize()
+        tm.assert_index_equal(result, expected, exact=True)
+    else:
+        expected = np.array(unique_values)
+        tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("null_obj", [np.nan, None])
+def test_unique_null(null_obj, index_or_series_obj):
+    obj = index_or_series_obj
+
+    if not allow_na_ops(obj):
+        pytest.skip("type doesn't allow for NA operations")
+    elif len(obj) < 1:
+        pytest.skip("Test doesn't make sense on empty data")
+    elif isinstance(obj, pd.MultiIndex):
+        pytest.skip(f"MultiIndex can't hold '{null_obj}'")
+
+    values = obj._values
+    values[0:2] = null_obj
+
+    klass = type(obj)
+    repeated_values = np.repeat(values, range(1, len(values) + 1))
+    obj = klass(repeated_values, dtype=obj.dtype)
+    result = obj.unique()
+
+    unique_values_raw = dict.fromkeys(obj.values)
+    # because np.nan == np.nan is False, but None == None is True
+    # np.nan would be duplicated, whereas None wouldn't
+    unique_values_not_null = [val for val in unique_values_raw if not pd.isnull(val)]
+    unique_values = [null_obj] + unique_values_not_null
+
+    if isinstance(obj, pd.Index):
+        expected = pd.Index(unique_values, dtype=obj.dtype)
+        if is_datetime64tz_dtype(obj.dtype):
+            result = result.normalize()
+            expected = expected.normalize()
+        tm.assert_index_equal(result, expected, exact=True)
+    else:
+        expected = np.array(unique_values, dtype=obj.dtype)
+        tm.assert_numpy_array_equal(result, expected)
+
+
+def test_nunique(index_or_series_obj):
+    obj = index_or_series_obj
+    obj = np.repeat(obj, range(1, len(obj) + 1))
+    expected = len(obj.unique())
+    assert obj.nunique(dropna=False) == expected
+
+
+@pytest.mark.parametrize("null_obj", [np.nan, None])
+def test_nunique_null(null_obj, index_or_series_obj):
+    obj = index_or_series_obj
+
+    if not allow_na_ops(obj):
+        pytest.skip("type doesn't allow for NA operations")
+    elif isinstance(obj, pd.MultiIndex):
+        pytest.skip(f"MultiIndex can't hold '{null_obj}'")
+
+    values = obj._values
+    values[0:2] = null_obj
+
+    klass = type(obj)
+    repeated_values = np.repeat(values, range(1, len(values) + 1))
+    obj = klass(repeated_values, dtype=obj.dtype)
+
+    if isinstance(obj, pd.CategoricalIndex):
+        assert obj.nunique() == len(obj.categories)
+        assert obj.nunique(dropna=False) == len(obj.categories) + 1
+    else:
+        num_unique_values = len(obj.unique())
+        assert obj.nunique() == max(0, num_unique_values - 1)
+        assert obj.nunique(dropna=False) == max(0, num_unique_values)
+
+
+@pytest.mark.single_cpu
+def test_unique_bad_unicode(index_or_series):
+    # regression test for #34550
+    uval = "\ud83d"  # smiley emoji
+
+    obj = index_or_series([uval] * 2)
+    result = obj.unique()
+
+    if isinstance(obj, pd.Index):
+        expected = pd.Index(["\ud83d"], dtype=object)
+        tm.assert_index_equal(result, expected, exact=True)
+    else:
+        expected = np.array(["\ud83d"], dtype=object)
+        tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("dropna", [True, False])
+def test_nunique_dropna(dropna):
+    # GH37566
+    ser = pd.Series(["yes", "yes", pd.NA, np.nan, None, pd.NaT])
+    res = ser.nunique(dropna)
+    assert res == 1 if dropna else 5

videochat2/lib/python3.10/site-packages/pandas/tests/base/test_value_counts.py

@@ -0,0 +1,320 @@
+import collections
+from datetime import timedelta
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DatetimeIndex,
+    Index,
+    Interval,
+    IntervalIndex,
+    MultiIndex,
+    Series,
+    Timedelta,
+    TimedeltaIndex,
+)
+import pandas._testing as tm
+from pandas.tests.base.common import allow_na_ops
+
+
+def test_value_counts(index_or_series_obj):
+    obj = index_or_series_obj
+    obj = np.repeat(obj, range(1, len(obj) + 1))
+    result = obj.value_counts()
+
+    counter = collections.Counter(obj)
+    expected = Series(dict(counter.most_common()), dtype=np.int64, name="count")
+
+    if obj.dtype != np.float16:
+        expected.index = expected.index.astype(obj.dtype)
+    else:
+        with pytest.raises(NotImplementedError, match="float16 indexes are not "):
+            expected.index.astype(obj.dtype)
+        return
+    if isinstance(expected.index, MultiIndex):
+        expected.index.names = obj.names
+    else:
+        expected.index.name = obj.name
+
+    if not isinstance(result.dtype, np.dtype):
+        if getattr(obj.dtype, "storage", "") == "pyarrow":
+            expected = expected.astype("int64[pyarrow]")
+        else:
+            # i.e IntegerDtype
+            expected = expected.astype("Int64")
+
+    # TODO(GH#32514): Order of entries with the same count is inconsistent
+    #  on CI (gh-32449)
+    if obj.duplicated().any():
+        result = result.sort_index()
+        expected = expected.sort_index()
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("null_obj", [np.nan, None])
+def test_value_counts_null(null_obj, index_or_series_obj):
+    orig = index_or_series_obj
+    obj = orig.copy()
+
+    if not allow_na_ops(obj):
+        pytest.skip("type doesn't allow for NA operations")
+    elif len(obj) < 1:
+        pytest.skip("Test doesn't make sense on empty data")
+    elif isinstance(orig, MultiIndex):
+        pytest.skip(f"MultiIndex can't hold '{null_obj}'")
+
+    values = obj._values
+    values[0:2] = null_obj
+
+    klass = type(obj)
+    repeated_values = np.repeat(values, range(1, len(values) + 1))
+    obj = klass(repeated_values, dtype=obj.dtype)
+
+    # because np.nan == np.nan is False, but None == None is True
+    # np.nan would be duplicated, whereas None wouldn't
+    counter = collections.Counter(obj.dropna())
+    expected = Series(dict(counter.most_common()), dtype=np.int64, name="count")
+
+    if obj.dtype != np.float16:
+        expected.index = expected.index.astype(obj.dtype)
+    else:
+        with pytest.raises(NotImplementedError, match="float16 indexes are not "):
+            expected.index.astype(obj.dtype)
+        return
+    expected.index.name = obj.name
+
+    result = obj.value_counts()
+    if obj.duplicated().any():
+        # TODO(GH#32514):
+        #  Order of entries with the same count is inconsistent on CI (gh-32449)
+        expected = expected.sort_index()
+        result = result.sort_index()
+
+    if not isinstance(result.dtype, np.dtype):
+        if getattr(obj.dtype, "storage", "") == "pyarrow":
+            expected = expected.astype("int64[pyarrow]")
+        else:
+            # i.e IntegerDtype
+            expected = expected.astype("Int64")
+    tm.assert_series_equal(result, expected)
+
+    expected[null_obj] = 3
+
+    result = obj.value_counts(dropna=False)
+    if obj.duplicated().any():
+        # TODO(GH#32514):
+        #  Order of entries with the same count is inconsistent on CI (gh-32449)
+        expected = expected.sort_index()
+        result = result.sort_index()
+    tm.assert_series_equal(result, expected)
+
+
+def test_value_counts_inferred(index_or_series):
+    klass = index_or_series
+    s_values = ["a", "b", "b", "b", "b", "c", "d", "d", "a", "a"]
+    s = klass(s_values)
+    expected = Series([4, 3, 2, 1], index=["b", "a", "d", "c"], name="count")
+    tm.assert_series_equal(s.value_counts(), expected)
+
+    if isinstance(s, Index):
+        exp = Index(np.unique(np.array(s_values, dtype=np.object_)))
+        tm.assert_index_equal(s.unique(), exp)
+    else:
+        exp = np.unique(np.array(s_values, dtype=np.object_))
+        tm.assert_numpy_array_equal(s.unique(), exp)
+
+    assert s.nunique() == 4
+    # don't sort, have to sort after the fact as not sorting is
+    # platform-dep
+    hist = s.value_counts(sort=False).sort_values()
+    expected = Series([3, 1, 4, 2], index=list("acbd"), name="count").sort_values()
+    tm.assert_series_equal(hist, expected)
+
+    # sort ascending
+    hist = s.value_counts(ascending=True)
+    expected = Series([1, 2, 3, 4], index=list("cdab"), name="count")
+    tm.assert_series_equal(hist, expected)
+
+    # relative histogram.
+    hist = s.value_counts(normalize=True)
+    expected = Series(
+        [0.4, 0.3, 0.2, 0.1], index=["b", "a", "d", "c"], name="proportion"
+    )
+    tm.assert_series_equal(hist, expected)
+
+
+def test_value_counts_bins(index_or_series):
+    klass = index_or_series
+    s_values = ["a", "b", "b", "b", "b", "c", "d", "d", "a", "a"]
+    s = klass(s_values)
+
+    # bins
+    msg = "bins argument only works with numeric data"
+    with pytest.raises(TypeError, match=msg):
+        s.value_counts(bins=1)
+
+    s1 = Series([1, 1, 2, 3])
+    res1 = s1.value_counts(bins=1)
+    exp1 = Series({Interval(0.997, 3.0): 4}, name="count")
+    tm.assert_series_equal(res1, exp1)
+    res1n = s1.value_counts(bins=1, normalize=True)
+    exp1n = Series({Interval(0.997, 3.0): 1.0}, name="proportion")
+    tm.assert_series_equal(res1n, exp1n)
+
+    if isinstance(s1, Index):
+        tm.assert_index_equal(s1.unique(), Index([1, 2, 3]))
+    else:
+        exp = np.array([1, 2, 3], dtype=np.int64)
+        tm.assert_numpy_array_equal(s1.unique(), exp)
+
+    assert s1.nunique() == 3
+
+    # these return the same
+    res4 = s1.value_counts(bins=4, dropna=True)
+    intervals = IntervalIndex.from_breaks([0.997, 1.5, 2.0, 2.5, 3.0])
+    exp4 = Series([2, 1, 1, 0], index=intervals.take([0, 1, 3, 2]), name="count")
+    tm.assert_series_equal(res4, exp4)
+
+    res4 = s1.value_counts(bins=4, dropna=False)
+    intervals = IntervalIndex.from_breaks([0.997, 1.5, 2.0, 2.5, 3.0])
+    exp4 = Series([2, 1, 1, 0], index=intervals.take([0, 1, 3, 2]), name="count")
+    tm.assert_series_equal(res4, exp4)
+
+    res4n = s1.value_counts(bins=4, normalize=True)
+    exp4n = Series(
+        [0.5, 0.25, 0.25, 0], index=intervals.take([0, 1, 3, 2]), name="proportion"
+    )
+    tm.assert_series_equal(res4n, exp4n)
+
+    # handle NA's properly
+    s_values = ["a", "b", "b", "b", np.nan, np.nan, "d", "d", "a", "a", "b"]
+    s = klass(s_values)
+    expected = Series([4, 3, 2], index=["b", "a", "d"], name="count")
+    tm.assert_series_equal(s.value_counts(), expected)
+
+    if isinstance(s, Index):
+        exp = Index(["a", "b", np.nan, "d"])
+        tm.assert_index_equal(s.unique(), exp)
+    else:
+        exp = np.array(["a", "b", np.nan, "d"], dtype=object)
+        tm.assert_numpy_array_equal(s.unique(), exp)
+    assert s.nunique() == 3
+
+    s = klass({}) if klass is dict else klass({}, dtype=object)
+    expected = Series([], dtype=np.int64, name="count")
+    tm.assert_series_equal(s.value_counts(), expected, check_index_type=False)
+    # returned dtype differs depending on original
+    if isinstance(s, Index):
+        tm.assert_index_equal(s.unique(), Index([]), exact=False)
+    else:
+        tm.assert_numpy_array_equal(s.unique(), np.array([]), check_dtype=False)
+
+    assert s.nunique() == 0
+
+
+def test_value_counts_datetime64(index_or_series):
+    klass = index_or_series
+
+    # GH 3002, datetime64[ns]
+    # don't test names though
+    df = pd.DataFrame(
+        {
+            "person_id": ["xxyyzz", "xxyyzz", "xxyyzz", "xxyyww", "foofoo", "foofoo"],
+            "dt": pd.to_datetime(
+                [
+                    "2010-01-01",
+                    "2010-01-01",
+                    "2010-01-01",
+                    "2009-01-01",
+                    "2008-09-09",
+                    "2008-09-09",
+                ]
+            ),
+            "food": ["PIE", "GUM", "EGG", "EGG", "PIE", "GUM"],
+        }
+    )
+
+    s = klass(df["dt"].copy())
+    s.name = None
+    idx = pd.to_datetime(
+        ["2010-01-01 00:00:00", "2008-09-09 00:00:00", "2009-01-01 00:00:00"]
+    )
+    expected_s = Series([3, 2, 1], index=idx, name="count")
+    tm.assert_series_equal(s.value_counts(), expected_s)
+
+    expected = pd.array(
+        np.array(
+            ["2010-01-01 00:00:00", "2009-01-01 00:00:00", "2008-09-09 00:00:00"],
+            dtype="datetime64[ns]",
+        )
+    )
+    if isinstance(s, Index):
+        tm.assert_index_equal(s.unique(), DatetimeIndex(expected))
+    else:
+        tm.assert_extension_array_equal(s.unique(), expected)
+
+    assert s.nunique() == 3
+
+    # with NaT
+    s = df["dt"].copy()
+    s = klass(list(s.values) + [pd.NaT] * 4)
+
+    result = s.value_counts()
+    assert result.index.dtype == "datetime64[ns]"
+    tm.assert_series_equal(result, expected_s)
+
+    result = s.value_counts(dropna=False)
+    expected_s = pd.concat(
+        [Series([4], index=DatetimeIndex([pd.NaT]), name="count"), expected_s]
+    )
+    tm.assert_series_equal(result, expected_s)
+
+    assert s.dtype == "datetime64[ns]"
+    unique = s.unique()
+    assert unique.dtype == "datetime64[ns]"
+
+    # numpy_array_equal cannot compare pd.NaT
+    if isinstance(s, Index):
+        exp_idx = DatetimeIndex(expected.tolist() + [pd.NaT])
+        tm.assert_index_equal(unique, exp_idx)
+    else:
+        tm.assert_extension_array_equal(unique[:3], expected)
+        assert pd.isna(unique[3])
+
+    assert s.nunique() == 3
+    assert s.nunique(dropna=False) == 4
+
+    # timedelta64[ns]
+    td = df.dt - df.dt + timedelta(1)
+    td = klass(td, name="dt")
+
+    result = td.value_counts()
+    expected_s = Series([6], index=Index([Timedelta("1day")], name="dt"), name="count")
+    tm.assert_series_equal(result, expected_s)
+
+    expected = TimedeltaIndex(["1 days"], name="dt")
+    if isinstance(td, Index):
+        tm.assert_index_equal(td.unique(), expected)
+    else:
+        tm.assert_extension_array_equal(td.unique(), expected._values)
+
+    td2 = timedelta(1) + (df.dt - df.dt)
+    td2 = klass(td2, name="dt")
+    result2 = td2.value_counts()
+    tm.assert_series_equal(result2, expected_s)
+
+
+@pytest.mark.parametrize("dropna", [True, False])
+def test_value_counts_with_nan(dropna, index_or_series):
+    # GH31944
+    klass = index_or_series
+    values = [True, pd.NA, np.nan]
+    obj = klass(values)
+    res = obj.value_counts(dropna=dropna)
+    if dropna is True:
+        expected = Series([1], index=Index([True], dtype=obj.dtype), name="count")
+    else:
+        expected = Series([1, 1, 1], index=[True, pd.NA, np.nan], name="count")
+    tm.assert_series_equal(res, expected)

videochat2/lib/python3.10/site-packages/pyparsing/__init__.py

@@ -0,0 +1,326 @@
+# module pyparsing.py
+#
+# Copyright (c) 2003-2022  Paul T. McGuire
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__doc__ = """
+pyparsing module - Classes and methods to define and execute parsing grammars
+=============================================================================
+
+The pyparsing module is an alternative approach to creating and
+executing simple grammars, vs. the traditional lex/yacc approach, or the
+use of regular expressions.  With pyparsing, you don't need to learn
+a new syntax for defining grammars or matching expressions - the parsing
+module provides a library of classes that you use to construct the
+grammar directly in Python.
+
+Here is a program to parse "Hello, World!" (or any greeting of the form
+``"<salutation>, <addressee>!"``), built up using :class:`Word`,
+:class:`Literal`, and :class:`And` elements
+(the :meth:`'+'<ParserElement.__add__>` operators create :class:`And` expressions,
+and the strings are auto-converted to :class:`Literal` expressions)::
+
+    from pyparsing import Word, alphas
+
+    # define grammar of a greeting
+    greet = Word(alphas) + "," + Word(alphas) + "!"
+
+    hello = "Hello, World!"
+    print(hello, "->", greet.parse_string(hello))
+
+The program outputs the following::
+
+    Hello, World! -> ['Hello', ',', 'World', '!']
+
+The Python representation of the grammar is quite readable, owing to the
+self-explanatory class names, and the use of :class:`'+'<And>`,
+:class:`'|'<MatchFirst>`, :class:`'^'<Or>` and :class:`'&'<Each>` operators.
+
+The :class:`ParseResults` object returned from
+:class:`ParserElement.parse_string` can be
+accessed as a nested list, a dictionary, or an object with named
+attributes.
+
+The pyparsing module handles some of the problems that are typically
+vexing when writing text parsers:
+
+  - extra or missing whitespace (the above program will also handle
+    "Hello,World!", "Hello  ,  World  !", etc.)
+  - quoted strings
+  - embedded comments
+
+
+Getting Started -
+-----------------
+Visit the classes :class:`ParserElement` and :class:`ParseResults` to
+see the base classes that most other pyparsing
+classes inherit from. Use the docstrings for examples of how to:
+
+ - construct literal match expressions from :class:`Literal` and
+   :class:`CaselessLiteral` classes
+ - construct character word-group expressions using the :class:`Word`
+   class
+ - see how to create repetitive expressions using :class:`ZeroOrMore`
+   and :class:`OneOrMore` classes
+ - use :class:`'+'<And>`, :class:`'|'<MatchFirst>`, :class:`'^'<Or>`,
+   and :class:`'&'<Each>` operators to combine simple expressions into
+   more complex ones
+ - associate names with your parsed results using
+   :class:`ParserElement.set_results_name`
+ - access the parsed data, which is returned as a :class:`ParseResults`
+   object
+ - find some helpful expression short-cuts like :class:`DelimitedList`
+   and :class:`one_of`
+ - find more useful common expressions in the :class:`pyparsing_common`
+   namespace class
+"""
+from typing import NamedTuple
+
+
+class version_info(NamedTuple):
+    major: int
+    minor: int
+    micro: int
+    releaselevel: str
+    serial: int
+
+    @property
+    def __version__(self):
+        return (
+            f"{self.major}.{self.minor}.{self.micro}"
+            + (
+                f"{'r' if self.releaselevel[0] == 'c' else ''}{self.releaselevel[0]}{self.serial}",
+                "",
+            )[self.releaselevel == "final"]
+        )
+
+    def __str__(self):
+        return f"{__name__} {self.__version__} / {__version_time__}"
+
+    def __repr__(self):
+        return f"{__name__}.{type(self).__name__}({', '.join('{}={!r}'.format(*nv) for nv in zip(self._fields, self))})"
+
+
+__version_info__ = version_info(3, 2, 0, "final", 1)
+__version_time__ = "13 Oct 2024 09:46 UTC"
+__version__ = __version_info__.__version__
+__versionTime__ = __version_time__
+__author__ = "Paul McGuire <ptmcg.gm+pyparsing@gmail.com>"
+
+from .util import *
+from .exceptions import *
+from .actions import *
+from .core import __diag__, __compat__
+from .results import *
+from .core import *
+from .core import _builtin_exprs as core_builtin_exprs
+from .helpers import *
+from .helpers import _builtin_exprs as helper_builtin_exprs
+
+from .unicode import unicode_set, UnicodeRangeList, pyparsing_unicode as unicode
+from .testing import pyparsing_test as testing
+from .common import (
+    pyparsing_common as common,
+    _builtin_exprs as common_builtin_exprs,
+)
+
+# Compatibility synonyms
+if "pyparsing_unicode" not in globals():
+    pyparsing_unicode = unicode  # type: ignore[misc]
+if "pyparsing_common" not in globals():
+    pyparsing_common = common
+if "pyparsing_test" not in globals():
+    pyparsing_test = testing
+
+core_builtin_exprs += common_builtin_exprs + helper_builtin_exprs
+
+
+__all__ = [
+    "__version__",
+    "__version_time__",
+    "__author__",
+    "__compat__",
+    "__diag__",
+    "And",
+    "AtLineStart",
+    "AtStringStart",
+    "CaselessKeyword",
+    "CaselessLiteral",
+    "CharsNotIn",
+    "CloseMatch",
+    "Combine",
+    "DelimitedList",
+    "Dict",
+    "Each",
+    "Empty",
+    "FollowedBy",
+    "Forward",
+    "GoToColumn",
+    "Group",
+    "IndentedBlock",
+    "Keyword",
+    "LineEnd",
+    "LineStart",
+    "Literal",
+    "Located",
+    "PrecededBy",
+    "MatchFirst",
+    "NoMatch",
+    "NotAny",
+    "OneOrMore",
+    "OnlyOnce",
+    "OpAssoc",
+    "Opt",
+    "Optional",
+    "Or",
+    "ParseBaseException",
+    "ParseElementEnhance",
+    "ParseException",
+    "ParseExpression",
+    "ParseFatalException",
+    "ParseResults",
+    "ParseSyntaxException",
+    "ParserElement",
+    "PositionToken",
+    "QuotedString",
+    "RecursiveGrammarException",
+    "Regex",
+    "SkipTo",
+    "StringEnd",
+    "StringStart",
+    "Suppress",
+    "Tag",
+    "Token",
+    "TokenConverter",
+    "White",
+    "Word",
+    "WordEnd",
+    "WordStart",
+    "ZeroOrMore",
+    "Char",
+    "alphanums",
+    "alphas",
+    "alphas8bit",
+    "any_close_tag",
+    "any_open_tag",
+    "autoname_elements",
+    "c_style_comment",
+    "col",
+    "common_html_entity",
+    "condition_as_parse_action",
+    "counted_array",
+    "cpp_style_comment",
+    "dbl_quoted_string",
+    "dbl_slash_comment",
+    "delimited_list",
+    "dict_of",
+    "empty",
+    "hexnums",
+    "html_comment",
+    "identchars",
+    "identbodychars",
+    "infix_notation",
+    "java_style_comment",
+    "line",
+    "line_end",
+    "line_start",
+    "lineno",
+    "make_html_tags",
+    "make_xml_tags",
+    "match_only_at_col",
+    "match_previous_expr",
+    "match_previous_literal",
+    "nested_expr",
+    "null_debug_action",
+    "nums",
+    "one_of",
+    "original_text_for",
+    "printables",
+    "punc8bit",
+    "pyparsing_common",
+    "pyparsing_test",
+    "pyparsing_unicode",
+    "python_style_comment",
+    "quoted_string",
+    "remove_quotes",
+    "replace_with",
+    "replace_html_entity",
+    "rest_of_line",
+    "sgl_quoted_string",
+    "srange",
+    "string_end",
+    "string_start",
+    "token_map",
+    "trace_parse_action",
+    "ungroup",
+    "unicode_set",
+    "unicode_string",
+    "with_attribute",
+    "with_class",
+    # pre-PEP8 compatibility names
+    "__versionTime__",
+    "anyCloseTag",
+    "anyOpenTag",
+    "cStyleComment",
+    "commonHTMLEntity",
+    "conditionAsParseAction",
+    "countedArray",
+    "cppStyleComment",
+    "dblQuotedString",
+    "dblSlashComment",
+    "delimitedList",
+    "dictOf",
+    "htmlComment",
+    "indentedBlock",
+    "infixNotation",
+    "javaStyleComment",
+    "lineEnd",
+    "lineStart",
+    "locatedExpr",
+    "makeHTMLTags",
+    "makeXMLTags",
+    "matchOnlyAtCol",
+    "matchPreviousExpr",
+    "matchPreviousLiteral",
+    "nestedExpr",
+    "nullDebugAction",
+    "oneOf",
+    "opAssoc",
+    "originalTextFor",
+    "pythonStyleComment",
+    "quotedString",
+    "removeQuotes",
+    "replaceHTMLEntity",
+    "replaceWith",
+    "restOfLine",
+    "sglQuotedString",
+    "stringEnd",
+    "stringStart",
+    "tokenMap",
+    "traceParseAction",
+    "unicodeString",
+    "withAttribute",
+    "withClass",
+    "common",
+    "unicode",
+    "testing",
+]