Add files using upload-large-folder tool

.gitattributes

@@ -68,3 +68,4 @@ parrot/lib/libz.so.1 filter=lfs diff=lfs merge=lfs -text
 parrot/lib/libatomic.so filter=lfs diff=lfs merge=lfs -text
 parrot/bin/lzma filter=lfs diff=lfs merge=lfs -text
 parrot/lib/libncursesw.so.6 filter=lfs diff=lfs merge=lfs -text
+parrot/lib/libncurses.so.6.4 filter=lfs diff=lfs merge=lfs -text

parrot/lib/libncurses.so.6.4

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

parrot/lib/python3.10/lib2to3/PatternGrammar3.10.16.final.0.pickle

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

parrot/lib/python3.10/site-packages/COPYING

@@ -0,0 +1,29 @@
+Copyright (c) 2011, Stavros Korokithakis
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+Neither the name of Stochastic Technologies nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

parrot/lib/python3.10/site-packages/cv2/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Olli-Pekka Heinisuo
+
+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.

parrot/lib/python3.10/site-packages/cv2/__init__.py

@@ -0,0 +1,181 @@
+'''
+OpenCV Python binary extension loader
+'''
+import os
+import importlib
+import sys
+
+__all__ = []
+
+try:
+    import numpy
+    import numpy.core.multiarray
+except ImportError:
+    print('OpenCV bindings requires "numpy" package.')
+    print('Install it via command:')
+    print('    pip install numpy')
+    raise
+
+# TODO
+# is_x64 = sys.maxsize > 2**32
+
+
+def __load_extra_py_code_for_module(base, name, enable_debug_print=False):
+    module_name = "{}.{}".format(__name__, name)
+    export_module_name = "{}.{}".format(base, name)
+    native_module = sys.modules.pop(module_name, None)
+    try:
+        py_module = importlib.import_module(module_name)
+    except ImportError as err:
+        if enable_debug_print:
+            print("Can't load Python code for module:", module_name,
+                  ". Reason:", err)
+        # Extension doesn't contain extra py code
+        return False
+
+    if base in sys.modules and not hasattr(sys.modules[base], name):
+        setattr(sys.modules[base], name, py_module)
+    sys.modules[export_module_name] = py_module
+    # If it is C extension module it is already loaded by cv2 package
+    if native_module:
+        setattr(py_module, "_native", native_module)
+        for k, v in filter(lambda kv: not hasattr(py_module, kv[0]),
+                           native_module.__dict__.items()):
+            if enable_debug_print: print('    symbol({}): {} = {}'.format(name, k, v))
+            setattr(py_module, k, v)
+    return True
+
+
+def __collect_extra_submodules(enable_debug_print=False):
+    def modules_filter(module):
+        return all((
+             # module is not internal
+             not module.startswith("_"),
+             not module.startswith("python-"),
+             # it is not a file
+             os.path.isdir(os.path.join(_extra_submodules_init_path, module))
+        ))
+    if sys.version_info[0] < 3:
+        if enable_debug_print:
+            print("Extra submodules is loaded only for Python 3")
+        return []
+
+    __INIT_FILE_PATH = os.path.abspath(__file__)
+    _extra_submodules_init_path = os.path.dirname(__INIT_FILE_PATH)
+    return filter(modules_filter, os.listdir(_extra_submodules_init_path))
+
+
+def bootstrap():
+    import sys
+
+    import copy
+    save_sys_path = copy.copy(sys.path)
+
+    if hasattr(sys, 'OpenCV_LOADER'):
+        print(sys.path)
+        raise ImportError('ERROR: recursion is detected during loading of "cv2" binary extensions. Check OpenCV installation.')
+    sys.OpenCV_LOADER = True
+
+    DEBUG = False
+    if hasattr(sys, 'OpenCV_LOADER_DEBUG'):
+        DEBUG = True
+
+    import platform
+    if DEBUG: print('OpenCV loader: os.name="{}"  platform.system()="{}"'.format(os.name, str(platform.system())))
+
+    LOADER_DIR = os.path.dirname(os.path.abspath(os.path.realpath(__file__)))
+
+    PYTHON_EXTENSIONS_PATHS = []
+    BINARIES_PATHS = []
+
+    g_vars = globals()
+    l_vars = locals().copy()
+
+    if sys.version_info[:2] < (3, 0):
+        from . load_config_py2 import exec_file_wrapper
+    else:
+        from . load_config_py3 import exec_file_wrapper
+
+    def load_first_config(fnames, required=True):
+        for fname in fnames:
+            fpath = os.path.join(LOADER_DIR, fname)
+            if not os.path.exists(fpath):
+                if DEBUG: print('OpenCV loader: config not found, skip: {}'.format(fpath))
+                continue
+            if DEBUG: print('OpenCV loader: loading config: {}'.format(fpath))
+            exec_file_wrapper(fpath, g_vars, l_vars)
+            return True
+        if required:
+            raise ImportError('OpenCV loader: missing configuration file: {}. Check OpenCV installation.'.format(fnames))
+
+    load_first_config(['config.py'], True)
+    load_first_config([
+        'config-{}.{}.py'.format(sys.version_info[0], sys.version_info[1]),
+        'config-{}.py'.format(sys.version_info[0])
+    ], True)
+
+    if DEBUG: print('OpenCV loader: PYTHON_EXTENSIONS_PATHS={}'.format(str(l_vars['PYTHON_EXTENSIONS_PATHS'])))
+    if DEBUG: print('OpenCV loader: BINARIES_PATHS={}'.format(str(l_vars['BINARIES_PATHS'])))
+
+    applySysPathWorkaround = False
+    if hasattr(sys, 'OpenCV_REPLACE_SYS_PATH_0'):
+        applySysPathWorkaround = True
+    else:
+        try:
+            BASE_DIR = os.path.dirname(LOADER_DIR)
+            if sys.path[0] == BASE_DIR or os.path.realpath(sys.path[0]) == BASE_DIR:
+                applySysPathWorkaround = True
+        except:
+            if DEBUG: print('OpenCV loader: exception during checking workaround for sys.path[0]')
+            pass  # applySysPathWorkaround is False
+
+    for p in reversed(l_vars['PYTHON_EXTENSIONS_PATHS']):
+        sys.path.insert(1 if not applySysPathWorkaround else 0, p)
+
+    if os.name == 'nt':
+        if sys.version_info[:2] >= (3, 8):  # https://github.com/python/cpython/pull/12302
+            for p in l_vars['BINARIES_PATHS']:
+                try:
+                    os.add_dll_directory(p)
+                except Exception as e:
+                    if DEBUG: print('Failed os.add_dll_directory(): '+ str(e))
+                    pass
+        os.environ['PATH'] = ';'.join(l_vars['BINARIES_PATHS']) + ';' + os.environ.get('PATH', '')
+        if DEBUG: print('OpenCV loader: PATH={}'.format(str(os.environ['PATH'])))
+    else:
+        # amending of LD_LIBRARY_PATH works for sub-processes only
+        os.environ['LD_LIBRARY_PATH'] = ':'.join(l_vars['BINARIES_PATHS']) + ':' + os.environ.get('LD_LIBRARY_PATH', '')
+
+    if DEBUG: print("Relink everything from native cv2 module to cv2 package")
+
+    py_module = sys.modules.pop("cv2")
+
+    native_module = importlib.import_module("cv2")
+
+    sys.modules["cv2"] = py_module
+    setattr(py_module, "_native", native_module)
+
+    for item_name, item in filter(lambda kv: kv[0] not in ("__file__", "__loader__", "__spec__",
+                                                           "__name__", "__package__"),
+                                  native_module.__dict__.items()):
+        if item_name not in g_vars:
+            g_vars[item_name] = item
+
+    sys.path = save_sys_path  # multiprocessing should start from bootstrap code (https://github.com/opencv/opencv/issues/18502)
+
+    try:
+        del sys.OpenCV_LOADER
+    except Exception as e:
+        if DEBUG:
+            print("Exception during delete OpenCV_LOADER:", e)
+
+    if DEBUG: print('OpenCV loader: binary extension... OK')
+
+    for submodule in __collect_extra_submodules(DEBUG):
+        if __load_extra_py_code_for_module("cv2", submodule, DEBUG):
+            if DEBUG: print("Extra Python code for", submodule, "is loaded")
+
+    if DEBUG: print('OpenCV loader: DONE')
+
+
+bootstrap()

parrot/lib/python3.10/site-packages/cv2/aruco/__init__.pyi

@@ -0,0 +1,303 @@
+__all__: list[str] = []
+
+import cv2
+import cv2.typing
+import typing as _typing
+
+
+# Enumerations
+CORNER_REFINE_NONE: int
+CORNER_REFINE_SUBPIX: int
+CORNER_REFINE_CONTOUR: int
+CORNER_REFINE_APRILTAG: int
+CornerRefineMethod = int
+"""One of [CORNER_REFINE_NONE, CORNER_REFINE_SUBPIX, CORNER_REFINE_CONTOUR, CORNER_REFINE_APRILTAG]"""
+
+DICT_4X4_50: int
+DICT_4X4_100: int
+DICT_4X4_250: int
+DICT_4X4_1000: int
+DICT_5X5_50: int
+DICT_5X5_100: int
+DICT_5X5_250: int
+DICT_5X5_1000: int
+DICT_6X6_50: int
+DICT_6X6_100: int
+DICT_6X6_250: int
+DICT_6X6_1000: int
+DICT_7X7_50: int
+DICT_7X7_100: int
+DICT_7X7_250: int
+DICT_7X7_1000: int
+DICT_ARUCO_ORIGINAL: int
+DICT_APRILTAG_16h5: int
+DICT_APRILTAG_16H5: int
+DICT_APRILTAG_25h9: int
+DICT_APRILTAG_25H9: int
+DICT_APRILTAG_36h10: int
+DICT_APRILTAG_36H10: int
+DICT_APRILTAG_36h11: int
+DICT_APRILTAG_36H11: int
+DICT_ARUCO_MIP_36h12: int
+DICT_ARUCO_MIP_36H12: int
+PredefinedDictionaryType = int
+"""One of [DICT_4X4_50, DICT_4X4_100, DICT_4X4_250, DICT_4X4_1000, DICT_5X5_50, DICT_5X5_100, DICT_5X5_250, DICT_5X5_1000, DICT_6X6_50, DICT_6X6_100, DICT_6X6_250, DICT_6X6_1000, DICT_7X7_50, DICT_7X7_100, DICT_7X7_250, DICT_7X7_1000, DICT_ARUCO_ORIGINAL, DICT_APRILTAG_16h5, DICT_APRILTAG_16H5, DICT_APRILTAG_25h9, DICT_APRILTAG_25H9, DICT_APRILTAG_36h10, DICT_APRILTAG_36H10, DICT_APRILTAG_36h11, DICT_APRILTAG_36H11, DICT_ARUCO_MIP_36h12, DICT_ARUCO_MIP_36H12]"""
+
+
+
+# Classes
+class Board:
+    # Functions
+    @_typing.overload
+    def __init__(self, objPoints: _typing.Sequence[cv2.typing.MatLike], dictionary: Dictionary, ids: cv2.typing.MatLike) -> None: ...
+    @_typing.overload
+    def __init__(self, objPoints: _typing.Sequence[cv2.UMat], dictionary: Dictionary, ids: cv2.UMat) -> None: ...
+
+    def getDictionary(self) -> Dictionary: ...
+
+    def getObjPoints(self) -> _typing.Sequence[_typing.Sequence[cv2.typing.Point3f]]: ...
+
+    def getIds(self) -> _typing.Sequence[int]: ...
+
+    def getRightBottomCorner(self) -> cv2.typing.Point3f: ...
+
+    @_typing.overload
+    def matchImagePoints(self, detectedCorners: _typing.Sequence[cv2.typing.MatLike], detectedIds: cv2.typing.MatLike, objPoints: cv2.typing.MatLike | None = ..., imgPoints: cv2.typing.MatLike | None = ...) -> tuple[cv2.typing.MatLike, cv2.typing.MatLike]: ...
+    @_typing.overload
+    def matchImagePoints(self, detectedCorners: _typing.Sequence[cv2.UMat], detectedIds: cv2.UMat, objPoints: cv2.UMat | None = ..., imgPoints: cv2.UMat | None = ...) -> tuple[cv2.UMat, cv2.UMat]: ...
+
+    @_typing.overload
+    def generateImage(self, outSize: cv2.typing.Size, img: cv2.typing.MatLike | None = ..., marginSize: int = ..., borderBits: int = ...) -> cv2.typing.MatLike: ...
+    @_typing.overload
+    def generateImage(self, outSize: cv2.typing.Size, img: cv2.UMat | None = ..., marginSize: int = ..., borderBits: int = ...) -> cv2.UMat: ...
+
+
+class GridBoard(Board):
+    # Functions
+    @_typing.overload
+    def __init__(self, size: cv2.typing.Size, markerLength: float, markerSeparation: float, dictionary: Dictionary, ids: cv2.typing.MatLike | None = ...) -> None: ...
+    @_typing.overload
+    def __init__(self, size: cv2.typing.Size, markerLength: float, markerSeparation: float, dictionary: Dictionary, ids: cv2.UMat | None = ...) -> None: ...
+
+    def getGridSize(self) -> cv2.typing.Size: ...
+
+    def getMarkerLength(self) -> float: ...
+
+    def getMarkerSeparation(self) -> float: ...
+
+
+class CharucoBoard(Board):
+    # Functions
+    @_typing.overload
+    def __init__(self, size: cv2.typing.Size, squareLength: float, markerLength: float, dictionary: Dictionary, ids: cv2.typing.MatLike | None = ...) -> None: ...
+    @_typing.overload
+    def __init__(self, size: cv2.typing.Size, squareLength: float, markerLength: float, dictionary: Dictionary, ids: cv2.UMat | None = ...) -> None: ...
+
+    def setLegacyPattern(self, legacyPattern: bool) -> None: ...
+
+    def getLegacyPattern(self) -> bool: ...
+
+    def getChessboardSize(self) -> cv2.typing.Size: ...
+
+    def getSquareLength(self) -> float: ...
+
+    def getMarkerLength(self) -> float: ...
+
+    def getChessboardCorners(self) -> _typing.Sequence[cv2.typing.Point3f]: ...
+
+    @_typing.overload
+    def checkCharucoCornersCollinear(self, charucoIds: cv2.typing.MatLike) -> bool: ...
+    @_typing.overload
+    def checkCharucoCornersCollinear(self, charucoIds: cv2.UMat) -> bool: ...
+
+
+class DetectorParameters:
+    adaptiveThreshWinSizeMin: int
+    adaptiveThreshWinSizeMax: int
+    adaptiveThreshWinSizeStep: int
+    adaptiveThreshConstant: float
+    minMarkerPerimeterRate: float
+    maxMarkerPerimeterRate: float
+    polygonalApproxAccuracyRate: float
+    minCornerDistanceRate: float
+    minDistanceToBorder: int
+    minMarkerDistanceRate: float
+    minGroupDistance: float
+    cornerRefinementMethod: int
+    cornerRefinementWinSize: int
+    relativeCornerRefinmentWinSize: float
+    cornerRefinementMaxIterations: int
+    cornerRefinementMinAccuracy: float
+    markerBorderBits: int
+    perspectiveRemovePixelPerCell: int
+    perspectiveRemoveIgnoredMarginPerCell: float
+    maxErroneousBitsInBorderRate: float
+    minOtsuStdDev: float
+    errorCorrectionRate: float
+    aprilTagQuadDecimate: float
+    aprilTagQuadSigma: float
+    aprilTagMinClusterPixels: int
+    aprilTagMaxNmaxima: int
+    aprilTagCriticalRad: float
+    aprilTagMaxLineFitMse: float
+    aprilTagMinWhiteBlackDiff: int
+    aprilTagDeglitch: int
+    detectInvertedMarker: bool
+    useAruco3Detection: bool
+    minSideLengthCanonicalImg: int
+    minMarkerLengthRatioOriginalImg: float
+
+    # Functions
+    def __init__(self) -> None: ...
+
+    def readDetectorParameters(self, fn: cv2.FileNode) -> bool: ...
+
+    def writeDetectorParameters(self, fs: cv2.FileStorage, name: str = ...) -> bool: ...
+
+
+class RefineParameters:
+    minRepDistance: float
+    errorCorrectionRate: float
+    checkAllOrders: bool
+
+    # Functions
+    def __init__(self, minRepDistance: float = ..., errorCorrectionRate: float = ..., checkAllOrders: bool = ...) -> None: ...
+
+    def readRefineParameters(self, fn: cv2.FileNode) -> bool: ...
+
+    def writeRefineParameters(self, fs: cv2.FileStorage, name: str = ...) -> bool: ...
+
+
+class ArucoDetector(cv2.Algorithm):
+    # Functions
+    def __init__(self, dictionary: Dictionary = ..., detectorParams: DetectorParameters = ..., refineParams: RefineParameters = ...) -> None: ...
+
+    @_typing.overload
+    def detectMarkers(self, image: cv2.typing.MatLike, corners: _typing.Sequence[cv2.typing.MatLike] | None = ..., ids: cv2.typing.MatLike | None = ..., rejectedImgPoints: _typing.Sequence[cv2.typing.MatLike] | None = ...) -> tuple[_typing.Sequence[cv2.typing.MatLike], cv2.typing.MatLike, _typing.Sequence[cv2.typing.MatLike]]: ...
+    @_typing.overload
+    def detectMarkers(self, image: cv2.UMat, corners: _typing.Sequence[cv2.UMat] | None = ..., ids: cv2.UMat | None = ..., rejectedImgPoints: _typing.Sequence[cv2.UMat] | None = ...) -> tuple[_typing.Sequence[cv2.UMat], cv2.UMat, _typing.Sequence[cv2.UMat]]: ...
+
+    @_typing.overload
+    def refineDetectedMarkers(self, image: cv2.typing.MatLike, board: Board, detectedCorners: _typing.Sequence[cv2.typing.MatLike], detectedIds: cv2.typing.MatLike, rejectedCorners: _typing.Sequence[cv2.typing.MatLike], cameraMatrix: cv2.typing.MatLike | None = ..., distCoeffs: cv2.typing.MatLike | None = ..., recoveredIdxs: cv2.typing.MatLike | None = ...) -> tuple[_typing.Sequence[cv2.typing.MatLike], cv2.typing.MatLike, _typing.Sequence[cv2.typing.MatLike], cv2.typing.MatLike]: ...
+    @_typing.overload
+    def refineDetectedMarkers(self, image: cv2.UMat, board: Board, detectedCorners: _typing.Sequence[cv2.UMat], detectedIds: cv2.UMat, rejectedCorners: _typing.Sequence[cv2.UMat], cameraMatrix: cv2.UMat | None = ..., distCoeffs: cv2.UMat | None = ..., recoveredIdxs: cv2.UMat | None = ...) -> tuple[_typing.Sequence[cv2.UMat], cv2.UMat, _typing.Sequence[cv2.UMat], cv2.UMat]: ...
+
+    def getDictionary(self) -> Dictionary: ...
+
+    def setDictionary(self, dictionary: Dictionary) -> None: ...
+
+    def getDetectorParameters(self) -> DetectorParameters: ...
+
+    def setDetectorParameters(self, detectorParameters: DetectorParameters) -> None: ...
+
+    def getRefineParameters(self) -> RefineParameters: ...
+
+    def setRefineParameters(self, refineParameters: RefineParameters) -> None: ...
+
+    def write(self, fs: cv2.FileStorage, name: str) -> None: ...
+
+    def read(self, fn: cv2.FileNode) -> None: ...
+
+
+class Dictionary:
+    bytesList: cv2.typing.MatLike
+    markerSize: int
+    maxCorrectionBits: int
+
+    # Functions
+    @_typing.overload
+    def __init__(self) -> None: ...
+    @_typing.overload
+    def __init__(self, bytesList: cv2.typing.MatLike, _markerSize: int, maxcorr: int = ...) -> None: ...
+
+    def readDictionary(self, fn: cv2.FileNode) -> bool: ...
+
+    def writeDictionary(self, fs: cv2.FileStorage, name: str = ...) -> None: ...
+
+    def identify(self, onlyBits: cv2.typing.MatLike, maxCorrectionRate: float) -> tuple[bool, int, int]: ...
+
+    @_typing.overload
+    def getDistanceToId(self, bits: cv2.typing.MatLike, id: int, allRotations: bool = ...) -> int: ...
+    @_typing.overload
+    def getDistanceToId(self, bits: cv2.UMat, id: int, allRotations: bool = ...) -> int: ...
+
+    @_typing.overload
+    def generateImageMarker(self, id: int, sidePixels: int, _img: cv2.typing.MatLike | None = ..., borderBits: int = ...) -> cv2.typing.MatLike: ...
+    @_typing.overload
+    def generateImageMarker(self, id: int, sidePixels: int, _img: cv2.UMat | None = ..., borderBits: int = ...) -> cv2.UMat: ...
+
+    @staticmethod
+    def getByteListFromBits(bits: cv2.typing.MatLike) -> cv2.typing.MatLike: ...
+
+    @staticmethod
+    def getBitsFromByteList(byteList: cv2.typing.MatLike, markerSize: int) -> cv2.typing.MatLike: ...
+
+
+class CharucoParameters:
+    cameraMatrix: cv2.typing.MatLike
+    distCoeffs: cv2.typing.MatLike
+    minMarkers: int
+    tryRefineMarkers: bool
+
+    # Functions
+    def __init__(self) -> None: ...
+
+
+class CharucoDetector(cv2.Algorithm):
+    # Functions
+    def __init__(self, board: CharucoBoard, charucoParams: CharucoParameters = ..., detectorParams: DetectorParameters = ..., refineParams: RefineParameters = ...) -> None: ...
+
+    def getBoard(self) -> CharucoBoard: ...
+
+    def setBoard(self, board: CharucoBoard) -> None: ...
+
+    def getCharucoParameters(self) -> CharucoParameters: ...
+
+    def setCharucoParameters(self, charucoParameters: CharucoParameters) -> None: ...
+
+    def getDetectorParameters(self) -> DetectorParameters: ...
+
+    def setDetectorParameters(self, detectorParameters: DetectorParameters) -> None: ...
+
+    def getRefineParameters(self) -> RefineParameters: ...
+
+    def setRefineParameters(self, refineParameters: RefineParameters) -> None: ...
+
+    @_typing.overload
+    def detectBoard(self, image: cv2.typing.MatLike, charucoCorners: cv2.typing.MatLike | None = ..., charucoIds: cv2.typing.MatLike | None = ..., markerCorners: _typing.Sequence[cv2.typing.MatLike] | None = ..., markerIds: cv2.typing.MatLike | None = ...) -> tuple[cv2.typing.MatLike, cv2.typing.MatLike, _typing.Sequence[cv2.typing.MatLike], cv2.typing.MatLike]: ...
+    @_typing.overload
+    def detectBoard(self, image: cv2.UMat, charucoCorners: cv2.UMat | None = ..., charucoIds: cv2.UMat | None = ..., markerCorners: _typing.Sequence[cv2.UMat] | None = ..., markerIds: cv2.UMat | None = ...) -> tuple[cv2.UMat, cv2.UMat, _typing.Sequence[cv2.UMat], cv2.UMat]: ...
+
+    @_typing.overload
+    def detectDiamonds(self, image: cv2.typing.MatLike, diamondCorners: _typing.Sequence[cv2.typing.MatLike] | None = ..., diamondIds: cv2.typing.MatLike | None = ..., markerCorners: _typing.Sequence[cv2.typing.MatLike] | None = ..., markerIds: cv2.typing.MatLike | None = ...) -> tuple[_typing.Sequence[cv2.typing.MatLike], cv2.typing.MatLike, _typing.Sequence[cv2.typing.MatLike], cv2.typing.MatLike]: ...
+    @_typing.overload
+    def detectDiamonds(self, image: cv2.UMat, diamondCorners: _typing.Sequence[cv2.UMat] | None = ..., diamondIds: cv2.UMat | None = ..., markerCorners: _typing.Sequence[cv2.UMat] | None = ..., markerIds: cv2.UMat | None = ...) -> tuple[_typing.Sequence[cv2.UMat], cv2.UMat, _typing.Sequence[cv2.UMat], cv2.UMat]: ...
+
+
+
+# Functions
+@_typing.overload
+def drawDetectedCornersCharuco(image: cv2.typing.MatLike, charucoCorners: cv2.typing.MatLike, charucoIds: cv2.typing.MatLike | None = ..., cornerColor: cv2.typing.Scalar = ...) -> cv2.typing.MatLike: ...
+@_typing.overload
+def drawDetectedCornersCharuco(image: cv2.UMat, charucoCorners: cv2.UMat, charucoIds: cv2.UMat | None = ..., cornerColor: cv2.typing.Scalar = ...) -> cv2.UMat: ...
+
+@_typing.overload
+def drawDetectedDiamonds(image: cv2.typing.MatLike, diamondCorners: _typing.Sequence[cv2.typing.MatLike], diamondIds: cv2.typing.MatLike | None = ..., borderColor: cv2.typing.Scalar = ...) -> cv2.typing.MatLike: ...
+@_typing.overload
+def drawDetectedDiamonds(image: cv2.UMat, diamondCorners: _typing.Sequence[cv2.UMat], diamondIds: cv2.UMat | None = ..., borderColor: cv2.typing.Scalar = ...) -> cv2.UMat: ...
+
+@_typing.overload
+def drawDetectedMarkers(image: cv2.typing.MatLike, corners: _typing.Sequence[cv2.typing.MatLike], ids: cv2.typing.MatLike | None = ..., borderColor: cv2.typing.Scalar = ...) -> cv2.typing.MatLike: ...
+@_typing.overload
+def drawDetectedMarkers(image: cv2.UMat, corners: _typing.Sequence[cv2.UMat], ids: cv2.UMat | None = ..., borderColor: cv2.typing.Scalar = ...) -> cv2.UMat: ...
+
+def extendDictionary(nMarkers: int, markerSize: int, baseDictionary: Dictionary = ..., randomSeed: int = ...) -> Dictionary: ...
+
+@_typing.overload
+def generateImageMarker(dictionary: Dictionary, id: int, sidePixels: int, img: cv2.typing.MatLike | None = ..., borderBits: int = ...) -> cv2.typing.MatLike: ...
+@_typing.overload
+def generateImageMarker(dictionary: Dictionary, id: int, sidePixels: int, img: cv2.UMat | None = ..., borderBits: int = ...) -> cv2.UMat: ...
+
+def getPredefinedDictionary(dict: int) -> Dictionary: ...
+
+

parrot/lib/python3.10/site-packages/cv2/config-3.py

@@ -0,0 +1,24 @@
+PYTHON_EXTENSIONS_PATHS = [
+    LOADER_DIR
+] + PYTHON_EXTENSIONS_PATHS
+
+ci_and_not_headless = False
+
+try:
+    from .version import ci_build, headless
+
+    ci_and_not_headless = ci_build and not headless
+except:
+    pass
+
+# the Qt plugin is included currently only in the pre-built wheels
+if sys.platform.startswith("linux") and ci_and_not_headless:
+    os.environ["QT_QPA_PLATFORM_PLUGIN_PATH"] = os.path.join(
+        os.path.dirname(os.path.abspath(__file__)), "qt", "plugins"
+    )
+
+# Qt will throw warning on Linux if fonts are not found
+if sys.platform.startswith("linux") and ci_and_not_headless:
+    os.environ["QT_QPA_FONTDIR"] = os.path.join(
+        os.path.dirname(os.path.abspath(__file__)), "qt", "fonts"
+    )

parrot/lib/python3.10/site-packages/cv2/config.py

@@ -0,0 +1,5 @@
+import os
+
+BINARIES_PATHS = [
+    os.path.join(os.path.join(LOADER_DIR, '../../'), 'lib64')
+] + BINARIES_PATHS

parrot/lib/python3.10/site-packages/cv2/gapi/__init__.py

@@ -0,0 +1,323 @@
+__all__ = ['op', 'kernel']
+
+import sys
+import cv2 as cv
+
+# NB: Register function in specific module
+def register(mname):
+    def parameterized(func):
+        sys.modules[mname].__dict__[func.__name__] = func
+        return func
+    return parameterized
+
+
+@register('cv2.gapi')
+def networks(*args):
+    return cv.gapi_GNetPackage(list(map(cv.detail.strip, args)))
+
+
+@register('cv2.gapi')
+def compile_args(*args):
+    return list(map(cv.GCompileArg, args))
+
+
+@register('cv2')
+def GIn(*args):
+    return [*args]
+
+
+@register('cv2')
+def GOut(*args):
+    return [*args]
+
+
+@register('cv2')
+def gin(*args):
+    return [*args]
+
+
+@register('cv2.gapi')
+def descr_of(*args):
+    return [*args]
+
+
+@register('cv2')
+class GOpaque():
+    # NB: Inheritance from c++ class cause segfault.
+    # So just aggregate cv.GOpaqueT instead of inheritance
+    def __new__(cls, argtype):
+        return cv.GOpaqueT(argtype)
+
+    class Bool():
+        def __new__(self):
+            return cv.GOpaqueT(cv.gapi.CV_BOOL)
+
+    class Int():
+        def __new__(self):
+            return cv.GOpaqueT(cv.gapi.CV_INT)
+
+    class Int64():
+        def __new__(self):
+            return cv.GOpaqueT(cv.gapi.CV_INT64)
+
+    class UInt64():
+        def __new__(self):
+            return cv.GOpaqueT(cv.gapi.CV_UINT64)
+
+    class Double():
+        def __new__(self):
+            return cv.GOpaqueT(cv.gapi.CV_DOUBLE)
+
+    class Float():
+        def __new__(self):
+            return cv.GOpaqueT(cv.gapi.CV_FLOAT)
+
+    class String():
+        def __new__(self):
+            return cv.GOpaqueT(cv.gapi.CV_STRING)
+
+    class Point():
+        def __new__(self):
+            return cv.GOpaqueT(cv.gapi.CV_POINT)
+
+    class Point2f():
+        def __new__(self):
+            return cv.GOpaqueT(cv.gapi.CV_POINT2F)
+
+    class Point3f():
+        def __new__(self):
+            return cv.GOpaqueT(cv.gapi.CV_POINT3F)
+
+    class Size():
+        def __new__(self):
+            return cv.GOpaqueT(cv.gapi.CV_SIZE)
+
+    class Rect():
+        def __new__(self):
+            return cv.GOpaqueT(cv.gapi.CV_RECT)
+
+    class Prim():
+        def __new__(self):
+            return cv.GOpaqueT(cv.gapi.CV_DRAW_PRIM)
+
+    class Any():
+        def __new__(self):
+            return cv.GOpaqueT(cv.gapi.CV_ANY)
+
+@register('cv2')
+class GArray():
+    # NB: Inheritance from c++ class cause segfault.
+    # So just aggregate cv.GArrayT instead of inheritance
+    def __new__(cls, argtype):
+        return cv.GArrayT(argtype)
+
+    class Bool():
+        def __new__(self):
+            return cv.GArrayT(cv.gapi.CV_BOOL)
+
+    class Int():
+        def __new__(self):
+            return cv.GArrayT(cv.gapi.CV_INT)
+
+    class Int64():
+        def __new__(self):
+            return cv.GArrayT(cv.gapi.CV_INT64)
+
+    class UInt64():
+        def __new__(self):
+            return cv.GArrayT(cv.gapi.CV_UINT64)
+
+    class Double():
+        def __new__(self):
+            return cv.GArrayT(cv.gapi.CV_DOUBLE)
+
+    class Float():
+        def __new__(self):
+            return cv.GArrayT(cv.gapi.CV_FLOAT)
+
+    class String():
+        def __new__(self):
+            return cv.GArrayT(cv.gapi.CV_STRING)
+
+    class Point():
+        def __new__(self):
+            return cv.GArrayT(cv.gapi.CV_POINT)
+
+    class Point2f():
+        def __new__(self):
+            return cv.GArrayT(cv.gapi.CV_POINT2F)
+
+    class Point3f():
+        def __new__(self):
+            return cv.GArrayT(cv.gapi.CV_POINT3F)
+
+    class Size():
+        def __new__(self):
+            return cv.GArrayT(cv.gapi.CV_SIZE)
+
+    class Rect():
+        def __new__(self):
+            return cv.GArrayT(cv.gapi.CV_RECT)
+
+    class Scalar():
+        def __new__(self):
+            return cv.GArrayT(cv.gapi.CV_SCALAR)
+
+    class Mat():
+        def __new__(self):
+            return cv.GArrayT(cv.gapi.CV_MAT)
+
+    class GMat():
+        def __new__(self):
+            return cv.GArrayT(cv.gapi.CV_GMAT)
+
+    class Prim():
+        def __new__(self):
+            return cv.GArray(cv.gapi.CV_DRAW_PRIM)
+
+    class Any():
+        def __new__(self):
+            return cv.GArray(cv.gapi.CV_ANY)
+
+
+# NB: Top lvl decorator takes arguments
+def op(op_id, in_types, out_types):
+
+    garray_types= {
+            cv.GArray.Bool:    cv.gapi.CV_BOOL,
+            cv.GArray.Int:     cv.gapi.CV_INT,
+            cv.GArray.Int64:   cv.gapi.CV_INT64,
+            cv.GArray.UInt64:  cv.gapi.CV_UINT64,
+            cv.GArray.Double:  cv.gapi.CV_DOUBLE,
+            cv.GArray.Float:   cv.gapi.CV_FLOAT,
+            cv.GArray.String:  cv.gapi.CV_STRING,
+            cv.GArray.Point:   cv.gapi.CV_POINT,
+            cv.GArray.Point2f: cv.gapi.CV_POINT2F,
+            cv.GArray.Point3f: cv.gapi.CV_POINT3F,
+            cv.GArray.Size:    cv.gapi.CV_SIZE,
+            cv.GArray.Rect:    cv.gapi.CV_RECT,
+            cv.GArray.Scalar:  cv.gapi.CV_SCALAR,
+            cv.GArray.Mat:     cv.gapi.CV_MAT,
+            cv.GArray.GMat:    cv.gapi.CV_GMAT,
+            cv.GArray.Prim:    cv.gapi.CV_DRAW_PRIM,
+            cv.GArray.Any:     cv.gapi.CV_ANY
+    }
+
+    gopaque_types= {
+            cv.GOpaque.Size:    cv.gapi.CV_SIZE,
+            cv.GOpaque.Rect:    cv.gapi.CV_RECT,
+            cv.GOpaque.Bool:    cv.gapi.CV_BOOL,
+            cv.GOpaque.Int:     cv.gapi.CV_INT,
+            cv.GOpaque.Int64:   cv.gapi.CV_INT64,
+            cv.GOpaque.UInt64:  cv.gapi.CV_UINT64,
+            cv.GOpaque.Double:  cv.gapi.CV_DOUBLE,
+            cv.GOpaque.Float:   cv.gapi.CV_FLOAT,
+            cv.GOpaque.String:  cv.gapi.CV_STRING,
+            cv.GOpaque.Point:   cv.gapi.CV_POINT,
+            cv.GOpaque.Point2f: cv.gapi.CV_POINT2F,
+            cv.GOpaque.Point3f: cv.gapi.CV_POINT3F,
+            cv.GOpaque.Size:    cv.gapi.CV_SIZE,
+            cv.GOpaque.Rect:    cv.gapi.CV_RECT,
+            cv.GOpaque.Prim:    cv.gapi.CV_DRAW_PRIM,
+            cv.GOpaque.Any:     cv.gapi.CV_ANY
+    }
+
+    type2str = {
+        cv.gapi.CV_BOOL:      'cv.gapi.CV_BOOL' ,
+        cv.gapi.CV_INT:       'cv.gapi.CV_INT' ,
+        cv.gapi.CV_INT64:     'cv.gapi.CV_INT64' ,
+        cv.gapi.CV_UINT64:    'cv.gapi.CV_UINT64' ,
+        cv.gapi.CV_DOUBLE:    'cv.gapi.CV_DOUBLE' ,
+        cv.gapi.CV_FLOAT:     'cv.gapi.CV_FLOAT' ,
+        cv.gapi.CV_STRING:    'cv.gapi.CV_STRING' ,
+        cv.gapi.CV_POINT:     'cv.gapi.CV_POINT' ,
+        cv.gapi.CV_POINT2F:   'cv.gapi.CV_POINT2F' ,
+        cv.gapi.CV_POINT3F:   'cv.gapi.CV_POINT3F' ,
+        cv.gapi.CV_SIZE:      'cv.gapi.CV_SIZE',
+        cv.gapi.CV_RECT:      'cv.gapi.CV_RECT',
+        cv.gapi.CV_SCALAR:    'cv.gapi.CV_SCALAR',
+        cv.gapi.CV_MAT:       'cv.gapi.CV_MAT',
+        cv.gapi.CV_GMAT:      'cv.gapi.CV_GMAT',
+        cv.gapi.CV_DRAW_PRIM: 'cv.gapi.CV_DRAW_PRIM'
+    }
+
+    # NB: Second lvl decorator takes class to decorate
+    def op_with_params(cls):
+        if not in_types:
+            raise Exception('{} operation should have at least one input!'.format(cls.__name__))
+
+        if not out_types:
+            raise Exception('{} operation should have at least one output!'.format(cls.__name__))
+
+        for i, t in enumerate(out_types):
+            if t not in [cv.GMat, cv.GScalar, *garray_types, *gopaque_types]:
+                   raise Exception('{} unsupported output type: {} in position: {}'
+                           .format(cls.__name__, t.__name__, i))
+
+        def on(*args):
+            if len(in_types) != len(args):
+                raise Exception('Invalid number of input elements!\nExpected: {}, Actual: {}'
+                        .format(len(in_types), len(args)))
+
+            for i, (t, a) in enumerate(zip(in_types, args)):
+                if t in garray_types:
+                    if not isinstance(a, cv.GArrayT):
+                        raise Exception("{} invalid type for argument {}.\nExpected: {}, Actual: {}"
+                                .format(cls.__name__, i, cv.GArrayT.__name__, type(a).__name__))
+
+                    elif a.type() != garray_types[t]:
+                        raise Exception("{} invalid GArrayT type for argument {}.\nExpected: {}, Actual: {}"
+                                .format(cls.__name__, i, type2str[garray_types[t]], type2str[a.type()]))
+
+                elif t in gopaque_types:
+                    if not isinstance(a, cv.GOpaqueT):
+                        raise Exception("{} invalid type for argument {}.\nExpected: {}, Actual: {}"
+                                .format(cls.__name__, i, cv.GOpaqueT.__name__, type(a).__name__))
+
+                    elif a.type() != gopaque_types[t]:
+                        raise Exception("{} invalid GOpaque type for argument {}.\nExpected: {}, Actual: {}"
+                                .format(cls.__name__, i, type2str[gopaque_types[t]], type2str[a.type()]))
+
+                else:
+                    if t != type(a):
+                        raise Exception('{} invalid input type for argument {}.\nExpected: {}, Actual: {}'
+                                .format(cls.__name__, i, t.__name__, type(a).__name__))
+
+            op = cv.gapi.__op(op_id, cls.outMeta, *args)
+
+            out_protos = []
+            for i, out_type in enumerate(out_types):
+                if out_type == cv.GMat:
+                    out_protos.append(op.getGMat())
+                elif out_type == cv.GScalar:
+                    out_protos.append(op.getGScalar())
+                elif out_type in gopaque_types:
+                    out_protos.append(op.getGOpaque(gopaque_types[out_type]))
+                elif out_type in garray_types:
+                    out_protos.append(op.getGArray(garray_types[out_type]))
+                else:
+                    raise Exception("""In {}: G-API operation can't produce the output with type: {} in position: {}"""
+                            .format(cls.__name__, out_type.__name__, i))
+
+            return tuple(out_protos) if len(out_protos) != 1 else out_protos[0]
+
+        # NB: Extend operation class
+        cls.id = op_id
+        cls.on = staticmethod(on)
+        return cls
+
+    return op_with_params
+
+
+def kernel(op_cls):
+    # NB: Second lvl decorator takes class to decorate
+    def kernel_with_params(cls):
+        # NB: Add new members to kernel class
+        cls.id      = op_cls.id
+        cls.outMeta = op_cls.outMeta
+        return cls
+
+    return kernel_with_params
+
+
+cv.gapi.wip.GStreamerPipeline = cv.gapi_wip_gst_GStreamerPipeline

parrot/lib/python3.10/site-packages/cv2/gapi/__init__.pyi

@@ -0,0 +1,349 @@
+__all__: list[str] = []
+
+import cv2
+import cv2.typing
+import typing as _typing
+
+
+from cv2.gapi import core as core
+from cv2.gapi import ie as ie
+from cv2.gapi import imgproc as imgproc
+from cv2.gapi import oak as oak
+from cv2.gapi import onnx as onnx
+from cv2.gapi import ot as ot
+from cv2.gapi import ov as ov
+from cv2.gapi import own as own
+from cv2.gapi import render as render
+from cv2.gapi import streaming as streaming
+from cv2.gapi import video as video
+from cv2.gapi import wip as wip
+
+
+# Enumerations
+StereoOutputFormat_DEPTH_FLOAT16: int
+STEREO_OUTPUT_FORMAT_DEPTH_FLOAT16: int
+StereoOutputFormat_DEPTH_FLOAT32: int
+STEREO_OUTPUT_FORMAT_DEPTH_FLOAT32: int
+StereoOutputFormat_DISPARITY_FIXED16_11_5: int
+STEREO_OUTPUT_FORMAT_DISPARITY_FIXED16_11_5: int
+StereoOutputFormat_DISPARITY_FIXED16_12_4: int
+STEREO_OUTPUT_FORMAT_DISPARITY_FIXED16_12_4: int
+StereoOutputFormat_DEPTH_16F: int
+STEREO_OUTPUT_FORMAT_DEPTH_16F: int
+StereoOutputFormat_DEPTH_32F: int
+STEREO_OUTPUT_FORMAT_DEPTH_32F: int
+StereoOutputFormat_DISPARITY_16Q_10_5: int
+STEREO_OUTPUT_FORMAT_DISPARITY_16Q_10_5: int
+StereoOutputFormat_DISPARITY_16Q_11_4: int
+STEREO_OUTPUT_FORMAT_DISPARITY_16Q_11_4: int
+StereoOutputFormat = int
+"""One of [StereoOutputFormat_DEPTH_FLOAT16, STEREO_OUTPUT_FORMAT_DEPTH_FLOAT16, StereoOutputFormat_DEPTH_FLOAT32, STEREO_OUTPUT_FORMAT_DEPTH_FLOAT32, StereoOutputFormat_DISPARITY_FIXED16_11_5, STEREO_OUTPUT_FORMAT_DISPARITY_FIXED16_11_5, StereoOutputFormat_DISPARITY_FIXED16_12_4, STEREO_OUTPUT_FORMAT_DISPARITY_FIXED16_12_4, StereoOutputFormat_DEPTH_16F, STEREO_OUTPUT_FORMAT_DEPTH_16F, StereoOutputFormat_DEPTH_32F, STEREO_OUTPUT_FORMAT_DEPTH_32F, StereoOutputFormat_DISPARITY_16Q_10_5, STEREO_OUTPUT_FORMAT_DISPARITY_16Q_10_5, StereoOutputFormat_DISPARITY_16Q_11_4, STEREO_OUTPUT_FORMAT_DISPARITY_16Q_11_4]"""
+
+CV_BOOL: int
+CV_INT: int
+CV_INT64: int
+CV_UINT64: int
+CV_DOUBLE: int
+CV_FLOAT: int
+CV_STRING: int
+CV_POINT: int
+CV_POINT2F: int
+CV_POINT3F: int
+CV_SIZE: int
+CV_RECT: int
+CV_SCALAR: int
+CV_MAT: int
+CV_GMAT: int
+CV_DRAW_PRIM: int
+CV_ANY: int
+ArgType = int
+"""One of [CV_BOOL, CV_INT, CV_INT64, CV_UINT64, CV_DOUBLE, CV_FLOAT, CV_STRING, CV_POINT, CV_POINT2F, CV_POINT3F, CV_SIZE, CV_RECT, CV_SCALAR, CV_MAT, CV_GMAT, CV_DRAW_PRIM, CV_ANY]"""
+
+
+
+# Classes
+class GNetParam:
+    ...
+
+class GNetPackage:
+    # Functions
+    @_typing.overload
+    def __init__(self) -> None: ...
+    @_typing.overload
+    def __init__(self, nets: _typing.Sequence[GNetParam]) -> None: ...
+
+
+
+# Functions
+def BGR2Gray(src: cv2.GMat) -> cv2.GMat: ...
+
+def BGR2I420(src: cv2.GMat) -> cv2.GMat: ...
+
+def BGR2LUV(src: cv2.GMat) -> cv2.GMat: ...
+
+def BGR2RGB(src: cv2.GMat) -> cv2.GMat: ...
+
+def BGR2YUV(src: cv2.GMat) -> cv2.GMat: ...
+
+def BayerGR2RGB(src_gr: cv2.GMat) -> cv2.GMat: ...
+
+def Canny(image: cv2.GMat, threshold1: float, threshold2: float, apertureSize: int = ..., L2gradient: bool = ...) -> cv2.GMat: ...
+
+def I4202BGR(src: cv2.GMat) -> cv2.GMat: ...
+
+def I4202RGB(src: cv2.GMat) -> cv2.GMat: ...
+
+def LUT(src: cv2.GMat, lut: cv2.typing.MatLike) -> cv2.GMat: ...
+
+def LUV2BGR(src: cv2.GMat) -> cv2.GMat: ...
+
+def Laplacian(src: cv2.GMat, ddepth: int, ksize: int = ..., scale: float = ..., delta: float = ..., borderType: int = ...) -> cv2.GMat: ...
+
+def NV12toBGR(src_y: cv2.GMat, src_uv: cv2.GMat) -> cv2.GMat: ...
+
+def NV12toGray(src_y: cv2.GMat, src_uv: cv2.GMat) -> cv2.GMat: ...
+
+def NV12toRGB(src_y: cv2.GMat, src_uv: cv2.GMat) -> cv2.GMat: ...
+
+@_typing.overload
+def RGB2Gray(src: cv2.GMat) -> cv2.GMat: ...
+@_typing.overload
+def RGB2Gray(src: cv2.GMat, rY: float, gY: float, bY: float) -> cv2.GMat: ...
+
+def RGB2HSV(src: cv2.GMat) -> cv2.GMat: ...
+
+def RGB2I420(src: cv2.GMat) -> cv2.GMat: ...
+
+def RGB2Lab(src: cv2.GMat) -> cv2.GMat: ...
+
+def RGB2YUV(src: cv2.GMat) -> cv2.GMat: ...
+
+def RGB2YUV422(src: cv2.GMat) -> cv2.GMat: ...
+
+def Sobel(src: cv2.GMat, ddepth: int, dx: int, dy: int, ksize: int = ..., scale: float = ..., delta: float = ..., borderType: int = ..., borderValue: cv2.typing.Scalar = ...) -> cv2.GMat: ...
+
+def SobelXY(src: cv2.GMat, ddepth: int, order: int, ksize: int = ..., scale: float = ..., delta: float = ..., borderType: int = ..., borderValue: cv2.typing.Scalar = ...) -> tuple[cv2.GMat, cv2.GMat]: ...
+
+def YUV2BGR(src: cv2.GMat) -> cv2.GMat: ...
+
+def YUV2RGB(src: cv2.GMat) -> cv2.GMat: ...
+
+def absDiff(src1: cv2.GMat, src2: cv2.GMat) -> cv2.GMat: ...
+
+def absDiffC(src: cv2.GMat, c: cv2.GScalar) -> cv2.GMat: ...
+
+def add(src1: cv2.GMat, src2: cv2.GMat, ddepth: int = ...) -> cv2.GMat: ...
+
+@_typing.overload
+def addC(src1: cv2.GMat, c: cv2.GScalar, ddepth: int = ...) -> cv2.GMat: ...
+@_typing.overload
+def addC(c: cv2.GScalar, src1: cv2.GMat, ddepth: int = ...) -> cv2.GMat: ...
+
+def addWeighted(src1: cv2.GMat, alpha: float, src2: cv2.GMat, beta: float, gamma: float, ddepth: int = ...) -> cv2.GMat: ...
+
+def bilateralFilter(src: cv2.GMat, d: int, sigmaColor: float, sigmaSpace: float, borderType: int = ...) -> cv2.GMat: ...
+
+@_typing.overload
+def bitwise_and(src1: cv2.GMat, src2: cv2.GMat) -> cv2.GMat: ...
+@_typing.overload
+def bitwise_and(src1: cv2.GMat, src2: cv2.GScalar) -> cv2.GMat: ...
+
+def bitwise_not(src: cv2.GMat) -> cv2.GMat: ...
+
+@_typing.overload
+def bitwise_or(src1: cv2.GMat, src2: cv2.GMat) -> cv2.GMat: ...
+@_typing.overload
+def bitwise_or(src1: cv2.GMat, src2: cv2.GScalar) -> cv2.GMat: ...
+
+@_typing.overload
+def bitwise_xor(src1: cv2.GMat, src2: cv2.GMat) -> cv2.GMat: ...
+@_typing.overload
+def bitwise_xor(src1: cv2.GMat, src2: cv2.GScalar) -> cv2.GMat: ...
+
+def blur(src: cv2.GMat, ksize: cv2.typing.Size, anchor: cv2.typing.Point = ..., borderType: int = ..., borderValue: cv2.typing.Scalar = ...) -> cv2.GMat: ...
+
+@_typing.overload
+def boundingRect(src: cv2.GMat) -> cv2.GOpaqueT: ...
+@_typing.overload
+def boundingRect(src: cv2.GArrayT) -> cv2.GOpaqueT: ...
+@_typing.overload
+def boundingRect(src: cv2.GArrayT) -> cv2.GOpaqueT: ...
+
+def boxFilter(src: cv2.GMat, dtype: int, ksize: cv2.typing.Size, anchor: cv2.typing.Point = ..., normalize: bool = ..., borderType: int = ..., borderValue: cv2.typing.Scalar = ...) -> cv2.GMat: ...
+
+def cartToPolar(x: cv2.GMat, y: cv2.GMat, angleInDegrees: bool = ...) -> tuple[cv2.GMat, cv2.GMat]: ...
+
+@_typing.overload
+def cmpEQ(src1: cv2.GMat, src2: cv2.GMat) -> cv2.GMat: ...
+@_typing.overload
+def cmpEQ(src1: cv2.GMat, src2: cv2.GScalar) -> cv2.GMat: ...
+
+@_typing.overload
+def cmpGE(src1: cv2.GMat, src2: cv2.GMat) -> cv2.GMat: ...
+@_typing.overload
+def cmpGE(src1: cv2.GMat, src2: cv2.GScalar) -> cv2.GMat: ...
+
+@_typing.overload
+def cmpGT(src1: cv2.GMat, src2: cv2.GMat) -> cv2.GMat: ...
+@_typing.overload
+def cmpGT(src1: cv2.GMat, src2: cv2.GScalar) -> cv2.GMat: ...
+
+@_typing.overload
+def cmpLE(src1: cv2.GMat, src2: cv2.GMat) -> cv2.GMat: ...
+@_typing.overload
+def cmpLE(src1: cv2.GMat, src2: cv2.GScalar) -> cv2.GMat: ...
+
+@_typing.overload
+def cmpLT(src1: cv2.GMat, src2: cv2.GMat) -> cv2.GMat: ...
+@_typing.overload
+def cmpLT(src1: cv2.GMat, src2: cv2.GScalar) -> cv2.GMat: ...
+
+@_typing.overload
+def cmpNE(src1: cv2.GMat, src2: cv2.GMat) -> cv2.GMat: ...
+@_typing.overload
+def cmpNE(src1: cv2.GMat, src2: cv2.GScalar) -> cv2.GMat: ...
+
+def combine(lhs: cv2.GKernelPackage, rhs: cv2.GKernelPackage) -> cv2.GKernelPackage: ...
+
+@_typing.overload
+def concatHor(src1: cv2.GMat, src2: cv2.GMat) -> cv2.GMat: ...
+@_typing.overload
+def concatHor(v: _typing.Sequence[cv2.GMat]) -> cv2.GMat: ...
+
+@_typing.overload
+def concatVert(src1: cv2.GMat, src2: cv2.GMat) -> cv2.GMat: ...
+@_typing.overload
+def concatVert(v: _typing.Sequence[cv2.GMat]) -> cv2.GMat: ...
+
+def convertTo(src: cv2.GMat, rdepth: int, alpha: float = ..., beta: float = ...) -> cv2.GMat: ...
+
+def copy(in_: cv2.GMat) -> cv2.GMat: ...
+
+def countNonZero(src: cv2.GMat) -> cv2.GOpaqueT: ...
+
+def crop(src: cv2.GMat, rect: cv2.typing.Rect) -> cv2.GMat: ...
+
+def dilate(src: cv2.GMat, kernel: cv2.typing.MatLike, anchor: cv2.typing.Point = ..., iterations: int = ..., borderType: int = ..., borderValue: cv2.typing.Scalar = ...) -> cv2.GMat: ...
+
+def dilate3x3(src: cv2.GMat, iterations: int = ..., borderType: int = ..., borderValue: cv2.typing.Scalar = ...) -> cv2.GMat: ...
+
+def div(src1: cv2.GMat, src2: cv2.GMat, scale: float, ddepth: int = ...) -> cv2.GMat: ...
+
+def divC(src: cv2.GMat, divisor: cv2.GScalar, scale: float, ddepth: int = ...) -> cv2.GMat: ...
+
+def divRC(divident: cv2.GScalar, src: cv2.GMat, scale: float, ddepth: int = ...) -> cv2.GMat: ...
+
+def equalizeHist(src: cv2.GMat) -> cv2.GMat: ...
+
+def erode(src: cv2.GMat, kernel: cv2.typing.MatLike, anchor: cv2.typing.Point = ..., iterations: int = ..., borderType: int = ..., borderValue: cv2.typing.Scalar = ...) -> cv2.GMat: ...
+
+def erode3x3(src: cv2.GMat, iterations: int = ..., borderType: int = ..., borderValue: cv2.typing.Scalar = ...) -> cv2.GMat: ...
+
+def filter2D(src: cv2.GMat, ddepth: int, kernel: cv2.typing.MatLike, anchor: cv2.typing.Point = ..., delta: cv2.typing.Scalar = ..., borderType: int = ..., borderValue: cv2.typing.Scalar = ...) -> cv2.GMat: ...
+
+def flip(src: cv2.GMat, flipCode: int) -> cv2.GMat: ...
+
+def gaussianBlur(src: cv2.GMat, ksize: cv2.typing.Size, sigmaX: float, sigmaY: float = ..., borderType: int = ..., borderValue: cv2.typing.Scalar = ...) -> cv2.GMat: ...
+
+def goodFeaturesToTrack(image: cv2.GMat, maxCorners: int, qualityLevel: float, minDistance: float, mask: cv2.typing.MatLike | None = ..., blockSize: int = ..., useHarrisDetector: bool = ..., k: float = ...) -> cv2.GArrayT: ...
+
+def inRange(src: cv2.GMat, threshLow: cv2.GScalar, threshUp: cv2.GScalar) -> cv2.GMat: ...
+
+@_typing.overload
+def infer(name: str, inputs: cv2.GInferInputs) -> cv2.GInferOutputs: ...
+@_typing.overload
+def infer(name: str, roi: cv2.GOpaqueT, inputs: cv2.GInferInputs) -> cv2.GInferOutputs: ...
+@_typing.overload
+def infer(name: str, rois: cv2.GArrayT, inputs: cv2.GInferInputs) -> cv2.GInferListOutputs: ...
+
+def infer2(name: str, in_: cv2.GMat, inputs: cv2.GInferListInputs) -> cv2.GInferListOutputs: ...
+
+def integral(src: cv2.GMat, sdepth: int = ..., sqdepth: int = ...) -> tuple[cv2.GMat, cv2.GMat]: ...
+
+@_typing.overload
+def kmeans(data: cv2.GMat, K: int, bestLabels: cv2.GMat, criteria: cv2.typing.TermCriteria, attempts: int, flags: cv2.KmeansFlags) -> tuple[cv2.GOpaqueT, cv2.GMat, cv2.GMat]: ...
+@_typing.overload
+def kmeans(data: cv2.GMat, K: int, criteria: cv2.typing.TermCriteria, attempts: int, flags: cv2.KmeansFlags) -> tuple[cv2.GOpaqueT, cv2.GMat, cv2.GMat]: ...
+@_typing.overload
+def kmeans(data: cv2.GArrayT, K: int, bestLabels: cv2.GArrayT, criteria: cv2.typing.TermCriteria, attempts: int, flags: cv2.KmeansFlags) -> tuple[cv2.GOpaqueT, cv2.GArrayT, cv2.GArrayT]: ...
+@_typing.overload
+def kmeans(data: cv2.GArrayT, K: int, bestLabels: cv2.GArrayT, criteria: cv2.typing.TermCriteria, attempts: int, flags: cv2.KmeansFlags) -> tuple[cv2.GOpaqueT, cv2.GArrayT, cv2.GArrayT]: ...
+
+def mask(src: cv2.GMat, mask: cv2.GMat) -> cv2.GMat: ...
+
+def max(src1: cv2.GMat, src2: cv2.GMat) -> cv2.GMat: ...
+
+def mean(src: cv2.GMat) -> cv2.GScalar: ...
+
+def medianBlur(src: cv2.GMat, ksize: int) -> cv2.GMat: ...
+
+def merge3(src1: cv2.GMat, src2: cv2.GMat, src3: cv2.GMat) -> cv2.GMat: ...
+
+def merge4(src1: cv2.GMat, src2: cv2.GMat, src3: cv2.GMat, src4: cv2.GMat) -> cv2.GMat: ...
+
+def min(src1: cv2.GMat, src2: cv2.GMat) -> cv2.GMat: ...
+
+def morphologyEx(src: cv2.GMat, op: cv2.MorphTypes, kernel: cv2.typing.MatLike, anchor: cv2.typing.Point = ..., iterations: int = ..., borderType: cv2.BorderTypes = ..., borderValue: cv2.typing.Scalar = ...) -> cv2.GMat: ...
+
+def mul(src1: cv2.GMat, src2: cv2.GMat, scale: float = ..., ddepth: int = ...) -> cv2.GMat: ...
+
+@_typing.overload
+def mulC(src: cv2.GMat, multiplier: float, ddepth: int = ...) -> cv2.GMat: ...
+@_typing.overload
+def mulC(src: cv2.GMat, multiplier: cv2.GScalar, ddepth: int = ...) -> cv2.GMat: ...
+@_typing.overload
+def mulC(multiplier: cv2.GScalar, src: cv2.GMat, ddepth: int = ...) -> cv2.GMat: ...
+
+def normInf(src: cv2.GMat) -> cv2.GScalar: ...
+
+def normL1(src: cv2.GMat) -> cv2.GScalar: ...
+
+def normL2(src: cv2.GMat) -> cv2.GScalar: ...
+
+def normalize(src: cv2.GMat, alpha: float, beta: float, norm_type: int, ddepth: int = ...) -> cv2.GMat: ...
+
+@_typing.overload
+def parseSSD(in_: cv2.GMat, inSz: cv2.GOpaqueT, confidenceThreshold: float = ..., filterLabel: int = ...) -> tuple[cv2.GArrayT, cv2.GArrayT]: ...
+@_typing.overload
+def parseSSD(in_: cv2.GMat, inSz: cv2.GOpaqueT, confidenceThreshold: float, alignmentToSquare: bool, filterOutOfBounds: bool) -> cv2.GArrayT: ...
+
+def parseYolo(in_: cv2.GMat, inSz: cv2.GOpaqueT, confidenceThreshold: float = ..., nmsThreshold: float = ..., anchors: _typing.Sequence[float] = ...) -> tuple[cv2.GArrayT, cv2.GArrayT]: ...
+
+def phase(x: cv2.GMat, y: cv2.GMat, angleInDegrees: bool = ...) -> cv2.GMat: ...
+
+def polarToCart(magnitude: cv2.GMat, angle: cv2.GMat, angleInDegrees: bool = ...) -> tuple[cv2.GMat, cv2.GMat]: ...
+
+def remap(src: cv2.GMat, map1: cv2.typing.MatLike, map2: cv2.typing.MatLike, interpolation: int, borderMode: int = ..., borderValue: cv2.typing.Scalar = ...) -> cv2.GMat: ...
+
+def resize(src: cv2.GMat, dsize: cv2.typing.Size, fx: float = ..., fy: float = ..., interpolation: int = ...) -> cv2.GMat: ...
+
+def select(src1: cv2.GMat, src2: cv2.GMat, mask: cv2.GMat) -> cv2.GMat: ...
+
+def sepFilter(src: cv2.GMat, ddepth: int, kernelX: cv2.typing.MatLike, kernelY: cv2.typing.MatLike, anchor: cv2.typing.Point, delta: cv2.typing.Scalar, borderType: int = ..., borderValue: cv2.typing.Scalar = ...) -> cv2.GMat: ...
+
+def split3(src: cv2.GMat) -> tuple[cv2.GMat, cv2.GMat, cv2.GMat]: ...
+
+def split4(src: cv2.GMat) -> tuple[cv2.GMat, cv2.GMat, cv2.GMat, cv2.GMat]: ...
+
+def sqrt(src: cv2.GMat) -> cv2.GMat: ...
+
+def sub(src1: cv2.GMat, src2: cv2.GMat, ddepth: int = ...) -> cv2.GMat: ...
+
+def subC(src: cv2.GMat, c: cv2.GScalar, ddepth: int = ...) -> cv2.GMat: ...
+
+def subRC(c: cv2.GScalar, src: cv2.GMat, ddepth: int = ...) -> cv2.GMat: ...
+
+def sum(src: cv2.GMat) -> cv2.GScalar: ...
+
+@_typing.overload
+def threshold(src: cv2.GMat, thresh: cv2.GScalar, maxval: cv2.GScalar, type: int) -> cv2.GMat: ...
+@_typing.overload
+def threshold(src: cv2.GMat, maxval: cv2.GScalar, type: int) -> tuple[cv2.GMat, cv2.GScalar]: ...
+
+def transpose(src: cv2.GMat) -> cv2.GMat: ...
+
+def warpAffine(src: cv2.GMat, M: cv2.typing.MatLike, dsize: cv2.typing.Size, flags: int = ..., borderMode: int = ..., borderValue: cv2.typing.Scalar = ...) -> cv2.GMat: ...
+
+def warpPerspective(src: cv2.GMat, M: cv2.typing.MatLike, dsize: cv2.typing.Size, flags: int = ..., borderMode: int = ..., borderValue: cv2.typing.Scalar = ...) -> cv2.GMat: ...
+
+

parrot/lib/python3.10/site-packages/cv2/gapi/wip/__init__.pyi

@@ -0,0 +1,41 @@
+__all__: list[str] = []
+
+import cv2
+import cv2.gapi
+import cv2.gapi.wip.gst
+import cv2.typing
+import typing as _typing
+
+
+from cv2.gapi.wip import draw as draw
+from cv2.gapi.wip import gst as gst
+from cv2.gapi.wip import onevpl as onevpl
+
+
+# Classes
+class GOutputs:
+    # Functions
+    def getGMat(self) -> cv2.GMat: ...
+
+    def getGScalar(self) -> cv2.GScalar: ...
+
+    def getGArray(self, type: cv2.gapi.ArgType) -> cv2.GArrayT: ...
+
+    def getGOpaque(self, type: cv2.gapi.ArgType) -> cv2.GOpaqueT: ...
+
+
+class IStreamSource:
+    ...
+
+
+# Functions
+def get_streaming_source(pipeline: cv2.gapi.wip.gst.GStreamerPipeline, appsinkName: str, outputType: cv2.gapi.wip.gst.GStreamerSource_OutputType = ...) -> IStreamSource: ...
+
+@_typing.overload
+def make_capture_src(path: str, properties: cv2.typing.map_int_and_double = ...) -> IStreamSource: ...
+@_typing.overload
+def make_capture_src(id: int, properties: cv2.typing.map_int_and_double = ...) -> IStreamSource: ...
+
+def make_gst_src(pipeline: str, outputType: cv2.gapi.wip.gst.GStreamerSource_OutputType = ...) -> IStreamSource: ...
+
+

parrot/lib/python3.10/site-packages/cv2/gapi/wip/gst/__init__.pyi

@@ -0,0 +1,17 @@
+__all__: list[str] = []
+
+GStreamerSource_OutputType_FRAME: int
+GSTREAMER_SOURCE_OUTPUT_TYPE_FRAME: int
+GStreamerSource_OutputType_MAT: int
+GSTREAMER_SOURCE_OUTPUT_TYPE_MAT: int
+GStreamerSource_OutputType = int
+"""One of [GStreamerSource_OutputType_FRAME, GSTREAMER_SOURCE_OUTPUT_TYPE_FRAME, GStreamerSource_OutputType_MAT, GSTREAMER_SOURCE_OUTPUT_TYPE_MAT]"""
+
+
+# Classes
+class GStreamerPipeline:
+    # Functions
+    def __init__(self, pipeline: str) -> None: ...
+
+
+

parrot/lib/python3.10/site-packages/cv2/ipp/__init__.pyi

@@ -0,0 +1,14 @@
+__all__: list[str] = []
+
+# Functions
+def getIppVersion() -> str: ...
+
+def setUseIPP(flag: bool) -> None: ...
+
+def setUseIPP_NotExact(flag: bool) -> None: ...
+
+def useIPP() -> bool: ...
+
+def useIPP_NotExact() -> bool: ...
+
+

parrot/lib/python3.10/site-packages/cv2/load_config_py2.py

@@ -0,0 +1,6 @@
+# flake8: noqa
+import sys
+
+if sys.version_info[:2] < (3, 0):
+    def exec_file_wrapper(fpath, g_vars, l_vars):
+        execfile(fpath, g_vars, l_vars)

parrot/lib/python3.10/site-packages/cv2/load_config_py3.py

@@ -0,0 +1,9 @@
+# flake8: noqa
+import os
+import sys
+
+if sys.version_info[:2] >= (3, 0):
+    def exec_file_wrapper(fpath, g_vars, l_vars):
+        with open(fpath) as f:
+            code = compile(f.read(), os.path.basename(fpath), 'exec')
+            exec(code, g_vars, l_vars)

parrot/lib/python3.10/site-packages/cv2/version.py

@@ -0,0 +1,5 @@
+opencv_version = "4.10.0.84"
+contrib = False
+headless = False
+rolling = False
+ci_build = True

parrot/lib/python3.10/site-packages/cycler/__init__.py

@@ -0,0 +1,573 @@
+"""
+Cycler
+======
+
+Cycling through combinations of values, producing dictionaries.
+
+You can add cyclers::
+
+    from cycler import cycler
+    cc = (cycler(color=list('rgb')) +
+          cycler(linestyle=['-', '--', '-.']))
+    for d in cc:
+        print(d)
+
+Results in::
+
+    {'color': 'r', 'linestyle': '-'}
+    {'color': 'g', 'linestyle': '--'}
+    {'color': 'b', 'linestyle': '-.'}
+
+
+You can multiply cyclers::
+
+    from cycler import cycler
+    cc = (cycler(color=list('rgb')) *
+          cycler(linestyle=['-', '--', '-.']))
+    for d in cc:
+        print(d)
+
+Results in::
+
+    {'color': 'r', 'linestyle': '-'}
+    {'color': 'r', 'linestyle': '--'}
+    {'color': 'r', 'linestyle': '-.'}
+    {'color': 'g', 'linestyle': '-'}
+    {'color': 'g', 'linestyle': '--'}
+    {'color': 'g', 'linestyle': '-.'}
+    {'color': 'b', 'linestyle': '-'}
+    {'color': 'b', 'linestyle': '--'}
+    {'color': 'b', 'linestyle': '-.'}
+"""
+
+
+from __future__ import annotations
+
+from collections.abc import Hashable, Iterable, Generator
+import copy
+from functools import reduce
+from itertools import product, cycle
+from operator import mul, add
+# Dict, List, Union required for runtime cast calls
+from typing import TypeVar, Generic, Callable, Union, Dict, List, Any, overload, cast
+
+__version__ = "0.12.1"
+
+K = TypeVar("K", bound=Hashable)
+L = TypeVar("L", bound=Hashable)
+V = TypeVar("V")
+U = TypeVar("U")
+
+
+def _process_keys(
+    left: Cycler[K, V] | Iterable[dict[K, V]],
+    right: Cycler[K, V] | Iterable[dict[K, V]] | None,
+) -> set[K]:
+    """
+    Helper function to compose cycler keys.
+
+    Parameters
+    ----------
+    left, right : iterable of dictionaries or None
+        The cyclers to be composed.
+
+    Returns
+    -------
+    keys : set
+        The keys in the composition of the two cyclers.
+    """
+    l_peek: dict[K, V] = next(iter(left)) if left != [] else {}
+    r_peek: dict[K, V] = next(iter(right)) if right is not None else {}
+    l_key: set[K] = set(l_peek.keys())
+    r_key: set[K] = set(r_peek.keys())
+    if l_key & r_key:
+        raise ValueError("Can not compose overlapping cycles")
+    return l_key | r_key
+
+
+def concat(left: Cycler[K, V], right: Cycler[K, U]) -> Cycler[K, V | U]:
+    r"""
+    Concatenate `Cycler`\s, as if chained using `itertools.chain`.
+
+    The keys must match exactly.
+
+    Examples
+    --------
+    >>> num = cycler('a', range(3))
+    >>> let = cycler('a', 'abc')
+    >>> num.concat(let)
+    cycler('a', [0, 1, 2, 'a', 'b', 'c'])
+
+    Returns
+    -------
+    `Cycler`
+        The concatenated cycler.
+    """
+    if left.keys != right.keys:
+        raise ValueError(
+            "Keys do not match:\n"
+            "\tIntersection: {both!r}\n"
+            "\tDisjoint: {just_one!r}".format(
+                both=left.keys & right.keys, just_one=left.keys ^ right.keys
+            )
+        )
+    _l = cast(Dict[K, List[Union[V, U]]], left.by_key())
+    _r = cast(Dict[K, List[Union[V, U]]], right.by_key())
+    return reduce(add, (_cycler(k, _l[k] + _r[k]) for k in left.keys))
+
+
+class Cycler(Generic[K, V]):
+    """
+    Composable cycles.
+
+    This class has compositions methods:
+
+    ``+``
+      for 'inner' products (zip)
+
+    ``+=``
+      in-place ``+``
+
+    ``*``
+      for outer products (`itertools.product`) and integer multiplication
+
+    ``*=``
+      in-place ``*``
+
+    and supports basic slicing via ``[]``.
+
+    Parameters
+    ----------
+    left, right : Cycler or None
+        The 'left' and 'right' cyclers.
+    op : func or None
+        Function which composes the 'left' and 'right' cyclers.
+    """
+
+    def __call__(self):
+        return cycle(self)
+
+    def __init__(
+        self,
+        left: Cycler[K, V] | Iterable[dict[K, V]] | None,
+        right: Cycler[K, V] | None = None,
+        op: Any = None,
+    ):
+        """
+        Semi-private init.
+
+        Do not use this directly, use `cycler` function instead.
+        """
+        if isinstance(left, Cycler):
+            self._left: Cycler[K, V] | list[dict[K, V]] = Cycler(
+                left._left, left._right, left._op
+            )
+        elif left is not None:
+            # Need to copy the dictionary or else that will be a residual
+            # mutable that could lead to strange errors
+            self._left = [copy.copy(v) for v in left]
+        else:
+            self._left = []
+
+        if isinstance(right, Cycler):
+            self._right: Cycler[K, V] | None = Cycler(
+                right._left, right._right, right._op
+            )
+        else:
+            self._right = None
+
+        self._keys: set[K] = _process_keys(self._left, self._right)
+        self._op: Any = op
+
+    def __contains__(self, k):
+        return k in self._keys
+
+    @property
+    def keys(self) -> set[K]:
+        """The keys this Cycler knows about."""
+        return set(self._keys)
+
+    def change_key(self, old: K, new: K) -> None:
+        """
+        Change a key in this cycler to a new name.
+        Modification is performed in-place.
+
+        Does nothing if the old key is the same as the new key.
+        Raises a ValueError if the new key is already a key.
+        Raises a KeyError if the old key isn't a key.
+        """
+        if old == new:
+            return
+        if new in self._keys:
+            raise ValueError(
+                f"Can't replace {old} with {new}, {new} is already a key"
+            )
+        if old not in self._keys:
+            raise KeyError(
+                f"Can't replace {old} with {new}, {old} is not a key"
+            )
+
+        self._keys.remove(old)
+        self._keys.add(new)
+
+        if self._right is not None and old in self._right.keys:
+            self._right.change_key(old, new)
+
+        # self._left should always be non-None
+        # if self._keys is non-empty.
+        elif isinstance(self._left, Cycler):
+            self._left.change_key(old, new)
+        else:
+            # It should be completely safe at this point to
+            # assume that the old key can be found in each
+            # iteration.
+            self._left = [{new: entry[old]} for entry in self._left]
+
+    @classmethod
+    def _from_iter(cls, label: K, itr: Iterable[V]) -> Cycler[K, V]:
+        """
+        Class method to create 'base' Cycler objects
+        that do not have a 'right' or 'op' and for which
+        the 'left' object is not another Cycler.
+
+        Parameters
+        ----------
+        label : hashable
+            The property key.
+
+        itr : iterable
+            Finite length iterable of the property values.
+
+        Returns
+        -------
+        `Cycler`
+            New 'base' cycler.
+        """
+        ret: Cycler[K, V] = cls(None)
+        ret._left = list({label: v} for v in itr)
+        ret._keys = {label}
+        return ret
+
+    def __getitem__(self, key: slice) -> Cycler[K, V]:
+        # TODO : maybe add numpy style fancy slicing
+        if isinstance(key, slice):
+            trans = self.by_key()
+            return reduce(add, (_cycler(k, v[key]) for k, v in trans.items()))
+        else:
+            raise ValueError("Can only use slices with Cycler.__getitem__")
+
+    def __iter__(self) -> Generator[dict[K, V], None, None]:
+        if self._right is None:
+            for left in self._left:
+                yield dict(left)
+        else:
+            if self._op is None:
+                raise TypeError(
+                    "Operation cannot be None when both left and right are defined"
+                )
+            for a, b in self._op(self._left, self._right):
+                out = {}
+                out.update(a)
+                out.update(b)
+                yield out
+
+    def __add__(self, other: Cycler[L, U]) -> Cycler[K | L, V | U]:
+        """
+        Pair-wise combine two equal length cyclers (zip).
+
+        Parameters
+        ----------
+        other : Cycler
+        """
+        if len(self) != len(other):
+            raise ValueError(
+                f"Can only add equal length cycles, not {len(self)} and {len(other)}"
+            )
+        return Cycler(
+            cast(Cycler[Union[K, L], Union[V, U]], self),
+            cast(Cycler[Union[K, L], Union[V, U]], other),
+            zip
+        )
+
+    @overload
+    def __mul__(self, other: Cycler[L, U]) -> Cycler[K | L, V | U]:
+        ...
+
+    @overload
+    def __mul__(self, other: int) -> Cycler[K, V]:
+        ...
+
+    def __mul__(self, other):
+        """
+        Outer product of two cyclers (`itertools.product`) or integer
+        multiplication.
+
+        Parameters
+        ----------
+        other : Cycler or int
+        """
+        if isinstance(other, Cycler):
+            return Cycler(
+                cast(Cycler[Union[K, L], Union[V, U]], self),
+                cast(Cycler[Union[K, L], Union[V, U]], other),
+                product
+            )
+        elif isinstance(other, int):
+            trans = self.by_key()
+            return reduce(
+                add, (_cycler(k, v * other) for k, v in trans.items())
+            )
+        else:
+            return NotImplemented
+
+    @overload
+    def __rmul__(self, other: Cycler[L, U]) -> Cycler[K | L, V | U]:
+        ...
+
+    @overload
+    def __rmul__(self, other: int) -> Cycler[K, V]:
+        ...
+
+    def __rmul__(self, other):
+        return self * other
+
+    def __len__(self) -> int:
+        op_dict: dict[Callable, Callable[[int, int], int]] = {zip: min, product: mul}
+        if self._right is None:
+            return len(self._left)
+        l_len = len(self._left)
+        r_len = len(self._right)
+        return op_dict[self._op](l_len, r_len)
+
+    # iadd and imul do not exapand the the type as the returns must be consistent with
+    # self, thus they flag as inconsistent with add/mul
+    def __iadd__(self, other: Cycler[K, V]) -> Cycler[K, V]:  # type: ignore[misc]
+        """
+        In-place pair-wise combine two equal length cyclers (zip).
+
+        Parameters
+        ----------
+        other : Cycler
+        """
+        if not isinstance(other, Cycler):
+            raise TypeError("Cannot += with a non-Cycler object")
+        # True shallow copy of self is fine since this is in-place
+        old_self = copy.copy(self)
+        self._keys = _process_keys(old_self, other)
+        self._left = old_self
+        self._op = zip
+        self._right = Cycler(other._left, other._right, other._op)
+        return self
+
+    def __imul__(self, other: Cycler[K, V] | int) -> Cycler[K, V]:  # type: ignore[misc]
+        """
+        In-place outer product of two cyclers (`itertools.product`).
+
+        Parameters
+        ----------
+        other : Cycler
+        """
+        if not isinstance(other, Cycler):
+            raise TypeError("Cannot *= with a non-Cycler object")
+        # True shallow copy of self is fine since this is in-place
+        old_self = copy.copy(self)
+        self._keys = _process_keys(old_self, other)
+        self._left = old_self
+        self._op = product
+        self._right = Cycler(other._left, other._right, other._op)
+        return self
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Cycler):
+            return False
+        if len(self) != len(other):
+            return False
+        if self.keys ^ other.keys:
+            return False
+        return all(a == b for a, b in zip(self, other))
+
+    __hash__ = None  # type: ignore
+
+    def __repr__(self) -> str:
+        op_map = {zip: "+", product: "*"}
+        if self._right is None:
+            lab = self.keys.pop()
+            itr = list(v[lab] for v in self)
+            return f"cycler({lab!r}, {itr!r})"
+        else:
+            op = op_map.get(self._op, "?")
+            msg = "({left!r} {op} {right!r})"
+            return msg.format(left=self._left, op=op, right=self._right)
+
+    def _repr_html_(self) -> str:
+        # an table showing the value of each key through a full cycle
+        output = "<table>"
+        sorted_keys = sorted(self.keys, key=repr)
+        for key in sorted_keys:
+            output += f"<th>{key!r}</th>"
+        for d in iter(self):
+            output += "<tr>"
+            for k in sorted_keys:
+                output += f"<td>{d[k]!r}</td>"
+            output += "</tr>"
+        output += "</table>"
+        return output
+
+    def by_key(self) -> dict[K, list[V]]:
+        """
+        Values by key.
+
+        This returns the transposed values of the cycler.  Iterating
+        over a `Cycler` yields dicts with a single value for each key,
+        this method returns a `dict` of `list` which are the values
+        for the given key.
+
+        The returned value can be used to create an equivalent `Cycler`
+        using only `+`.
+
+        Returns
+        -------
+        transpose : dict
+            dict of lists of the values for each key.
+        """
+
+        # TODO : sort out if this is a bottle neck, if there is a better way
+        # and if we care.
+
+        keys = self.keys
+        out: dict[K, list[V]] = {k: list() for k in keys}
+
+        for d in self:
+            for k in keys:
+                out[k].append(d[k])
+        return out
+
+    # for back compatibility
+    _transpose = by_key
+
+    def simplify(self) -> Cycler[K, V]:
+        """
+        Simplify the cycler into a sum (but no products) of cyclers.
+
+        Returns
+        -------
+        simple : Cycler
+        """
+        # TODO: sort out if it is worth the effort to make sure this is
+        # balanced.  Currently it is is
+        # (((a + b) + c) + d) vs
+        # ((a + b) + (c + d))
+        # I would believe that there is some performance implications
+        trans = self.by_key()
+        return reduce(add, (_cycler(k, v) for k, v in trans.items()))
+
+    concat = concat
+
+
+@overload
+def cycler(arg: Cycler[K, V]) -> Cycler[K, V]:
+    ...
+
+
+@overload
+def cycler(**kwargs: Iterable[V]) -> Cycler[str, V]:
+    ...
+
+
+@overload
+def cycler(label: K, itr: Iterable[V]) -> Cycler[K, V]:
+    ...
+
+
+def cycler(*args, **kwargs):
+    """
+    Create a new `Cycler` object from a single positional argument,
+    a pair of positional arguments, or the combination of keyword arguments.
+
+    cycler(arg)
+    cycler(label1=itr1[, label2=iter2[, ...]])
+    cycler(label, itr)
+
+    Form 1 simply copies a given `Cycler` object.
+
+    Form 2 composes a `Cycler` as an inner product of the
+    pairs of keyword arguments. In other words, all of the
+    iterables are cycled simultaneously, as if through zip().
+
+    Form 3 creates a `Cycler` from a label and an iterable.
+    This is useful for when the label cannot be a keyword argument
+    (e.g., an integer or a name that has a space in it).
+
+    Parameters
+    ----------
+    arg : Cycler
+        Copy constructor for Cycler (does a shallow copy of iterables).
+    label : name
+        The property key. In the 2-arg form of the function,
+        the label can be any hashable object. In the keyword argument
+        form of the function, it must be a valid python identifier.
+    itr : iterable
+        Finite length iterable of the property values.
+        Can be a single-property `Cycler` that would
+        be like a key change, but as a shallow copy.
+
+    Returns
+    -------
+    cycler : Cycler
+        New `Cycler` for the given property
+
+    """
+    if args and kwargs:
+        raise TypeError(
+            "cycler() can only accept positional OR keyword arguments -- not both."
+        )
+
+    if len(args) == 1:
+        if not isinstance(args[0], Cycler):
+            raise TypeError(
+                "If only one positional argument given, it must "
+                "be a Cycler instance."
+            )
+        return Cycler(args[0])
+    elif len(args) == 2:
+        return _cycler(*args)
+    elif len(args) > 2:
+        raise TypeError(
+            "Only a single Cycler can be accepted as the lone "
+            "positional argument. Use keyword arguments instead."
+        )
+
+    if kwargs:
+        return reduce(add, (_cycler(k, v) for k, v in kwargs.items()))
+
+    raise TypeError("Must have at least a positional OR keyword arguments")
+
+
+def _cycler(label: K, itr: Iterable[V]) -> Cycler[K, V]:
+    """
+    Create a new `Cycler` object from a property name and iterable of values.
+
+    Parameters
+    ----------
+    label : hashable
+        The property key.
+    itr : iterable
+        Finite length iterable of the property values.
+
+    Returns
+    -------
+    cycler : Cycler
+        New `Cycler` for the given property
+    """
+    if isinstance(itr, Cycler):
+        keys = itr.keys
+        if len(keys) != 1:
+            msg = "Can not create Cycler from a multi-property Cycler"
+            raise ValueError(msg)
+
+        lab = keys.pop()
+        # Doesn't need to be a new list because
+        # _from_iter() will be creating that new list anyway.
+        itr = (v[lab] for v in itr)
+
+    return Cycler._from_iter(label, itr)

parrot/lib/python3.10/site-packages/example.py

@@ -0,0 +1,169 @@
+#################################################################################
+# Copyright (c) 2020, NVIDIA Corporation.  All rights reserved.                 #
+#                                                                               #
+# Redistribution and use in source and binary forms, with or without            #
+# modification, are permitted provided that the following conditions are met:   #
+#                                                                               #
+#    * Redistributions of source code must retain the above copyright notice,   #
+#      this list of conditions and the following disclaimer.                    #
+#    * Redistributions in binary form must reproduce the above copyright        #
+#      notice, this list of conditions and the following disclaimer in the      #
+#      documentation and/or other materials provided with the distribution.     #
+#    * Neither the name of the NVIDIA Corporation nor the names of its          #
+#      contributors may be used to endorse or promote products derived from     #
+#      this software without specific prior written permission.                 #
+#                                                                               #
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"   #
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE     #
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE    #
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE     #
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR           #
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF          #
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS      #
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN       #
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)       #
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF        #
+# THE POSSIBILITY OF SUCH DAMAGE.                                               #
+#################################################################################
+
+#
+# Sample script to demonstrate the usage of NVML API python bindings
+#
+
+# To Run:
+# $ python ./example.py
+
+from pynvml import *
+
+#
+# Helper function
+#
+def StrVirt(mode):
+    if mode == NVML_GPU_VIRTUALIZATION_MODE_NONE:
+        return "None";
+    elif mode == NVML_GPU_VIRTUALIZATION_MODE_PASSTHROUGH:
+        return "Pass-Through";
+    elif mode == NVML_GPU_VIRTUALIZATION_MODE_VGPU:
+        return "VGPU";
+    elif mode == NVML_GPU_VIRTUALIZATION_MODE_HOST_VGPU:
+        return "Host VGPU";
+    elif mode == NVML_GPU_VIRTUALIZATION_MODE_HOST_VSGA:
+        return "Host VSGA";
+    else:
+        return "Unknown";
+
+#
+# Converts errors into string messages
+#
+def handleError(err):
+    if (err.value == NVML_ERROR_NOT_SUPPORTED):
+        return "N/A"
+    else:
+        return err.__str__()
+
+#######
+def deviceQuery():
+
+    strResult = ''
+    try:
+        #
+        # Initialize NVML
+        #
+        nvmlInit()
+
+        strResult += '  <driver_version>' + str(nvmlSystemGetDriverVersion()) + '</driver_version>\n'
+
+        deviceCount = nvmlDeviceGetCount()
+        strResult += '  <attached_gpus>' + str(deviceCount) + '</attached_gpus>\n'
+
+        for i in range(0, deviceCount):
+            handle = nvmlDeviceGetHandleByIndex(i)
+
+            pciInfo = nvmlDeviceGetPciInfo(handle)
+
+            strResult += '  <gpu id="%s">\n' % pciInfo.busId
+
+            strResult += '    <product_name>' + nvmlDeviceGetName(handle) + '</product_name>\n'
+
+            brandNames = {NVML_BRAND_UNKNOWN             :  "Unknown",
+                          NVML_BRAND_QUADRO              :  "Quadro",
+                          NVML_BRAND_TESLA               :  "Tesla",
+                          NVML_BRAND_NVS                 :  "NVS",
+                          NVML_BRAND_GRID                :  "Grid",
+                          NVML_BRAND_TITAN               :  "Titan",
+                          NVML_BRAND_GEFORCE             :  "GeForce",
+                          NVML_BRAND_NVIDIA_VAPPS        :  "NVIDIA Virtual Applications",
+                          NVML_BRAND_NVIDIA_VPC          :  "NVIDIA Virtual PC",
+                          NVML_BRAND_NVIDIA_VCS          :  "NVIDIA Virtual Compute Server",
+                          NVML_BRAND_NVIDIA_VWS          :  "NVIDIA RTX Virtual Workstation",
+                          NVML_BRAND_NVIDIA_CLOUD_GAMING :  "NVIDIA Cloud Gaming",
+                          NVML_BRAND_QUADRO_RTX          :  "Quadro RTX",
+                          NVML_BRAND_NVIDIA_RTX          :  "NVIDIA RTX",
+                          NVML_BRAND_NVIDIA              :  "NVIDIA",
+                          NVML_BRAND_GEFORCE_RTX         :  "GeForce RTX",
+                          NVML_BRAND_TITAN_RTX           :  "TITAN RTX",
+
+            }
+
+            try:
+                # If nvmlDeviceGetBrand() succeeds it is guaranteed to be in the dictionary
+                brandName = brandNames[nvmlDeviceGetBrand(handle)]
+            except NVMLError as err:
+                brandName = handleError(err)
+
+            strResult += '    <product_brand>' + brandName + '</product_brand>\n'
+
+            try:
+                serial = nvmlDeviceGetSerial(handle)
+            except NVMLError as err:
+                serial = handleError(err)
+
+            strResult += '    <serial>' + serial + '</serial>\n'
+
+            try:
+                uuid = nvmlDeviceGetUUID(handle)
+            except NVMLError as err:
+                uuid = handleError(err)
+
+            strResult += '    <uuid>' + uuid + '</uuid>\n'
+
+            strResult += '    <gpu_virtualization_mode>\n'
+            try:
+                mode = StrVirt(nvmlDeviceGetVirtualizationMode(handle))
+            except NVMLError as err:
+                mode = handleError(err)
+            strResult += '      <virtualization_mode>' + mode + '</virtualization_mode>\n'
+            strResult += '    </gpu_virtualization_mode>\n'
+
+            try:
+                gridLicensableFeatures = nvmlDeviceGetGridLicensableFeatures(handle)
+                if gridLicensableFeatures.isGridLicenseSupported == 1:
+                    strResult += '    <vgpu_software_licensed_product>\n'
+                    for i in range(gridLicensableFeatures.licensableFeaturesCount):
+                        if gridLicensableFeatures.gridLicensableFeatures[i].featureState == 0:
+                            if nvmlDeviceGetVirtualizationMode(handle) == NVML_GPU_VIRTUALIZATION_MODE_PASSTHROUGH:
+                                strResult += '        <licensed_product_name>' + 'NVIDIA Virtual Applications' + '</licensed_product_name>\n'
+                                strResult += '        <license_status>' + 'Licensed' + '</license_status>\n'
+                            else:
+                                strResult += '        <licensed_product_name>' + gridLicensableFeatures.gridLicensableFeatures[i].productName + '</licensed_product_name>\n'
+                                strResult += '        <license_status>' + 'Unlicensed' + '</license_status>\n'
+                        else:
+                            strResult += '        <licensed_product_name>' + gridLicensableFeatures.gridLicensableFeatures[i].productName + '</licensed_product_name>\n'
+                            strResult += '        <license_status>' + 'Licensed' + '</license_status>\n'
+                    strResult += '    </vgpu_software_licensed_product>\n'
+            except NVMLError as err:
+                gridLicensableFeatures = handleError(err)
+
+            strResult += '  </gpu>\n'
+
+    except NVMLError as err:
+        strResult += 'example.py: ' + err.__str__() + '\n'
+
+    nvmlShutdown()
+
+    return strResult
+
+# If this is not exectued when module is imported
+if __name__ == "__main__":
+    print(deviceQuery())
+

parrot/lib/python3.10/site-packages/ffmpy.py

@@ -0,0 +1,217 @@
+import errno
+import itertools
+import shlex
+import subprocess
+from typing import IO, Any, List, Mapping, Optional, Sequence, Tuple, Union
+
+
+class FFmpeg(object):
+    """Wrapper for various `FFmpeg <https://www.ffmpeg.org/>`_ related applications (ffmpeg,
+    ffprobe).
+    """
+
+    def __init__(
+        self,
+        executable: str = "ffmpeg",
+        global_options: Optional[Union[Sequence[str], str]] = None,
+        inputs: Optional[Mapping[str, Optional[Union[Sequence[str], str]]]] = None,
+        outputs: Optional[Mapping[str, Optional[Union[Sequence[str], str]]]] = None,
+    ) -> None:
+        """Initialize FFmpeg command line wrapper.
+
+        Compiles FFmpeg command line from passed arguments (executable path, options, inputs and
+        outputs). ``inputs`` and ``outputs`` are dictionares containing inputs/outputs as keys and
+        their respective options as values. One dictionary value (set of options) must be either a
+        single space separated string, or a list or strings without spaces (i.e. each part of the
+        option is a separate item of the list, the result of calling ``split()`` on the options
+        string). If the value is a list, it cannot be mixed, i.e. cannot contain items with spaces.
+        An exception are complex FFmpeg command lines that contain quotes: the quoted part must be
+        one string, even if it contains spaces (see *Examples* for more info).
+        For more info about FFmpeg command line format see `here
+        <https://ffmpeg.org/ffmpeg.html#Synopsis>`_.
+
+        :param str executable: path to ffmpeg executable; by default the ``ffmpeg`` command will be
+            searched for in the ``PATH``, but can be overridden with an absolute path to ``ffmpeg``
+            executable
+        :param iterable global_options: global options passed to ``ffmpeg`` executable (e.g.
+            ``-y``, ``-v`` etc.); can be specified either as a list/tuple/set of strings, or one
+            space-separated string; by default no global options are passed
+        :param dict inputs: a dictionary specifying one or more input arguments as keys with their
+            corresponding options (either as a list of strings or a single space separated string) as
+            values
+        :param dict outputs: a dictionary specifying one or more output arguments as keys with their
+            corresponding options (either as a list of strings or a single space separated string) as
+            values
+        """
+        self.executable = executable
+        self._cmd = [executable]
+        self._cmd += _normalize_options(global_options, split_mixed=True)
+
+        if inputs is not None:
+            self._cmd += _merge_args_opts(inputs, add_minus_i_option=True)
+
+        if outputs is not None:
+            self._cmd += _merge_args_opts(outputs)
+
+        self.cmd = subprocess.list2cmdline(self._cmd)
+        self.process: Optional[subprocess.Popen] = None
+
+    def __repr__(self) -> str:
+        return "<{0!r} {1!r}>".format(self.__class__.__name__, self.cmd)
+
+    def run(
+        self,
+        input_data: Optional[bytes] = None,
+        stdout: Optional[Union[IO, int]] = None,
+        stderr: Optional[Union[IO, int]] = None,
+        env: Optional[Mapping[str, str]] = None,
+        **kwargs: Any
+    ) -> Tuple[Optional[bytes], Optional[bytes]]:
+        """Execute FFmpeg command line.
+
+        ``input_data`` can contain input for FFmpeg in case ``pipe`` protocol is used for input.
+        ``stdout`` and ``stderr`` specify where to redirect the ``stdout`` and ``stderr`` of the
+        process. By default no redirection is done, which means all output goes to running shell
+        (this mode should normally only be used for debugging purposes). If FFmpeg ``pipe`` protocol
+        is used for output, ``stdout`` must be redirected to a pipe by passing `subprocess.PIPE` as
+        ``stdout`` argument. You can pass custom environment to ffmpeg process with ``env``.
+
+        Returns a 2-tuple containing ``stdout`` and ``stderr`` of the process. If there was no
+        redirection or if the output was redirected to e.g. `os.devnull`, the value returned will
+        be a tuple of two `None` values, otherwise it will contain the actual ``stdout`` and
+        ``stderr`` data returned by ffmpeg process.
+
+        More info about ``pipe`` protocol `here <https://ffmpeg.org/ffmpeg-protocols.html#pipe>`_.
+
+        :param str input_data: input data for FFmpeg to deal with (audio, video etc.) as bytes (e.g.
+            the result of reading a file in binary mode)
+        :param stdout: redirect FFmpeg ``stdout`` there (default is `None` which means no
+            redirection)
+        :param stderr: redirect FFmpeg ``stderr`` there (default is `None` which means no
+            redirection)
+        :param env: custom environment for ffmpeg process
+        :param kwargs: any other keyword arguments to be forwarded to `subprocess.Popen
+            <https://docs.python.org/3/library/subprocess.html#subprocess.Popen>`_
+        :return: a 2-tuple containing ``stdout`` and ``stderr`` of the process
+        :rtype: tuple
+        :raise: `FFRuntimeError` in case FFmpeg command exits with a non-zero code;
+            `FFExecutableNotFoundError` in case the executable path passed was not valid
+        """
+        try:
+            self.process = subprocess.Popen(
+                self._cmd, stdin=subprocess.PIPE, stdout=stdout, stderr=stderr, env=env, **kwargs
+            )
+        except OSError as e:
+            if e.errno == errno.ENOENT:
+                raise FFExecutableNotFoundError("Executable '{0}' not found".format(self.executable))
+            else:
+                raise
+
+        o_stdout, o_stderr = self.process.communicate(input=input_data)
+        if self.process.returncode != 0:
+            raise FFRuntimeError(self.cmd, self.process.returncode, o_stdout, o_stderr)
+
+        return o_stdout, o_stderr
+
+
+class FFprobe(FFmpeg):
+    """Wrapper for `ffprobe <https://www.ffmpeg.org/ffprobe.html>`_."""
+
+    def __init__(
+        self,
+        executable: str = "ffprobe",
+        global_options: Optional[Union[Sequence[str], str]] = None,
+        inputs: Optional[Mapping[str, Optional[Union[Sequence[str], str]]]] = None,
+    ) -> None:
+        """Create an instance of FFprobe.
+
+        Compiles FFprobe command line from passed arguments (executable path, options, inputs).
+        FFprobe executable by default is taken from ``PATH`` but can be overridden with an
+        absolute path. For more info about FFprobe command line format see
+        `here <https://ffmpeg.org/ffprobe.html#Synopsis>`_.
+
+        :param str executable: absolute path to ffprobe executable
+        :param iterable global_options: global options passed to ffmpeg executable; can be specified
+            either as a list/tuple of strings or a space-separated string
+        :param dict inputs: a dictionary specifying one or more inputs as keys with their
+            corresponding options as values
+        """
+        super(FFprobe, self).__init__(
+            executable=executable, global_options=global_options, inputs=inputs
+        )
+
+
+class FFExecutableNotFoundError(Exception):
+    """Raise when FFmpeg/FFprobe executable was not found."""
+
+
+class FFRuntimeError(Exception):
+    """Raise when FFmpeg/FFprobe command line execution returns a non-zero exit code.
+
+    The resulting exception object will contain the attributes relates to command line execution:
+    ``cmd``, ``exit_code``, ``stdout``, ``stderr``.
+    """
+
+    def __init__(self, cmd: str, exit_code: int, stdout: bytes, stderr: bytes) -> None:
+        self.cmd = cmd
+        self.exit_code = exit_code
+        self.stdout = stdout
+        self.stderr = stderr
+
+        message = "`{0}` exited with status {1}\n\nSTDOUT:\n{2}\n\nSTDERR:\n{3}".format(
+            self.cmd, exit_code, (stdout or b"").decode(), (stderr or b"").decode()
+        )
+
+        super(FFRuntimeError, self).__init__(message)
+
+
+def _merge_args_opts(
+    args_opts_dict: Mapping[str, Optional[Union[Sequence[str], str]]],
+    add_minus_i_option: bool = False,
+) -> List[str]:
+    """Merge options with their corresponding arguments.
+
+    Iterates over the dictionary holding arguments (keys) and options (values). Merges each
+    options string with its corresponding argument.
+
+    :param dict args_opts_dict: a dictionary of arguments and options
+    :param dict kwargs: *input_option* - if specified prepends ``-i`` to input argument
+    :return: merged list of strings with arguments and their corresponding options
+    :rtype: list
+    """
+    merged: List[str] = []
+
+    for arg, opt in args_opts_dict.items():
+        merged += _normalize_options(opt)
+
+        if not arg:
+            continue
+
+        if add_minus_i_option:
+            merged.append("-i")
+
+        merged.append(arg)
+
+    return merged
+
+
+def _normalize_options(
+    options: Optional[Union[Sequence[str], str]], split_mixed: bool = False
+) -> List[str]:
+    """Normalize options string or list of strings.
+
+    Splits `options` into a list of strings. If `split_mixed` is `True`, splits (flattens) mixed
+    options (i.e. list of strings with spaces) into separate items.
+
+    :param options: options string or list of strings
+    :param bool split_mixed: whether to split mixed options into separate items
+    """
+    if options is None:
+        return []
+    elif isinstance(options, str):
+        return shlex.split(options)
+    else:
+        if split_mixed:
+            return list(itertools.chain(*[shlex.split(o) for o in options]))
+        else:
+            return list(options)

parrot/lib/python3.10/site-packages/hjson/encoder.py

@@ -0,0 +1,521 @@
+"""Implementation of JSONEncoder
+"""
+from __future__ import absolute_import
+import re
+from operator import itemgetter
+from decimal import Decimal
+from .compat import u, unichr, binary_type, string_types, integer_types, PY3
+from .decoder import PosInf
+
+#ESCAPE = re.compile(ur'[\x00-\x1f\\"\b\f\n\r\t\u2028\u2029]')
+# This is required because u() will mangle the string and ur'' isn't valid
+# python3 syntax
+ESCAPE = re.compile(u'[\\x00-\\x1f\\\\"\\b\\f\\n\\r\\t\u2028\u2029]')
+ESCAPE_ASCII = re.compile(r'([\\"]|[^\ -~])')
+HAS_UTF8 = re.compile(r'[\x80-\xff]')
+ESCAPE_DCT = {
+    '\\': '\\\\',
+    '"': '\\"',
+    '\b': '\\b',
+    '\f': '\\f',
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t',
+}
+for i in range(0x20):
+    #ESCAPE_DCT.setdefault(chr(i), '\\u{0:04x}'.format(i))
+    ESCAPE_DCT.setdefault(chr(i), '\\u%04x' % (i,))
+for i in [0x2028, 0x2029]:
+    ESCAPE_DCT.setdefault(unichr(i), '\\u%04x' % (i,))
+
+FLOAT_REPR = repr
+
+def encode_basestring(s, _PY3=PY3, _q=u('"')):
+    """Return a JSON representation of a Python string
+
+    """
+    if _PY3:
+        if isinstance(s, binary_type):
+            s = s.decode('utf-8')
+    else:
+        if isinstance(s, str) and HAS_UTF8.search(s) is not None:
+            s = s.decode('utf-8')
+    def replace(match):
+        return ESCAPE_DCT[match.group(0)]
+    return _q + ESCAPE.sub(replace, s) + _q
+
+
+def py_encode_basestring_ascii(s, _PY3=PY3):
+    """Return an ASCII-only JSON representation of a Python string
+
+    """
+    if _PY3:
+        if isinstance(s, binary_type):
+            s = s.decode('utf-8')
+    else:
+        if isinstance(s, str) and HAS_UTF8.search(s) is not None:
+            s = s.decode('utf-8')
+    def replace(match):
+        s = match.group(0)
+        try:
+            return ESCAPE_DCT[s]
+        except KeyError:
+            n = ord(s)
+            if n < 0x10000:
+                #return '\\u{0:04x}'.format(n)
+                return '\\u%04x' % (n,)
+            else:
+                # surrogate pair
+                n -= 0x10000
+                s1 = 0xd800 | ((n >> 10) & 0x3ff)
+                s2 = 0xdc00 | (n & 0x3ff)
+                #return '\\u{0:04x}\\u{1:04x}'.format(s1, s2)
+                return '\\u%04x\\u%04x' % (s1, s2)
+    return '"' + str(ESCAPE_ASCII.sub(replace, s)) + '"'
+
+
+encode_basestring_ascii = (
+    py_encode_basestring_ascii)
+
+class JSONEncoder(object):
+    """Extensible JSON <http://json.org> encoder for Python data structures.
+
+    Supports the following objects and types by default:
+
+    +-------------------+---------------+
+    | Python            | JSON          |
+    +===================+===============+
+    | dict, namedtuple  | object        |
+    +-------------------+---------------+
+    | list, tuple       | array         |
+    +-------------------+---------------+
+    | str, unicode      | string        |
+    +-------------------+---------------+
+    | int, long, float  | number        |
+    +-------------------+---------------+
+    | True              | true          |
+    +-------------------+---------------+
+    | False             | false         |
+    +-------------------+---------------+
+    | None              | null          |
+    +-------------------+---------------+
+
+    To extend this to recognize other objects, subclass and implement a
+    ``.default()`` method with another method that returns a serializable
+    object for ``o`` if possible, otherwise it should call the superclass
+    implementation (to raise ``TypeError``).
+
+    """
+    item_separator = ', '
+    key_separator = ': '
+
+    def __init__(self, skipkeys=False, ensure_ascii=True,
+                 check_circular=True, sort_keys=False,
+                 indent=None, separators=None, encoding='utf-8', default=None,
+                 use_decimal=True, namedtuple_as_object=True,
+                 tuple_as_array=True, bigint_as_string=False,
+                 item_sort_key=None, for_json=False,
+                 int_as_string_bitcount=None):
+        """Constructor for JSONEncoder, with sensible defaults.
+
+        If skipkeys is false, then it is a TypeError to attempt
+        encoding of keys that are not str, int, long, float or None.  If
+        skipkeys is True, such items are simply skipped.
+
+        If ensure_ascii is true, the output is guaranteed to be str
+        objects with all incoming unicode characters escaped.  If
+        ensure_ascii is false, the output will be unicode object.
+
+        If check_circular is true, then lists, dicts, and custom encoded
+        objects will be checked for circular references during encoding to
+        prevent an infinite recursion (which would cause an OverflowError).
+        Otherwise, no such check takes place.
+
+        If sort_keys is true, then the output of dictionaries will be
+        sorted by key; this is useful for regression tests to ensure
+        that JSON serializations can be compared on a day-to-day basis.
+
+        If indent is a string, then JSON array elements and object members
+        will be pretty-printed with a newline followed by that string repeated
+        for each level of nesting. ``None`` (the default) selects the most compact
+        representation without any newlines. For backwards compatibility with
+        versions of hjson earlier than 2.1.0, an integer is also accepted
+        and is converted to a string with that many spaces.
+
+        If specified, separators should be an (item_separator, key_separator)
+        tuple.  The default is (', ', ': ') if *indent* is ``None`` and
+        (',', ': ') otherwise.  To get the most compact JSON representation,
+        you should specify (',', ':') to eliminate whitespace.
+
+        If specified, default is a function that gets called for objects
+        that can't otherwise be serialized.  It should return a JSON encodable
+        version of the object or raise a ``TypeError``.
+
+        If encoding is not None, then all input strings will be
+        transformed into unicode using that encoding prior to JSON-encoding.
+        The default is UTF-8.
+
+        If use_decimal is true (not the default), ``decimal.Decimal`` will
+        be supported directly by the encoder. For the inverse, decode JSON
+        with ``parse_float=decimal.Decimal``.
+
+        If namedtuple_as_object is true (the default), objects with
+        ``_asdict()`` methods will be encoded as JSON objects.
+
+        If tuple_as_array is true (the default), tuple (and subclasses) will
+        be encoded as JSON arrays.
+
+        If bigint_as_string is true (not the default), ints 2**53 and higher
+        or lower than -2**53 will be encoded as strings. This is to avoid the
+        rounding that happens in Javascript otherwise.
+
+        If int_as_string_bitcount is a positive number (n), then int of size
+        greater than or equal to 2**n or lower than or equal to -2**n will be
+        encoded as strings.
+
+        If specified, item_sort_key is a callable used to sort the items in
+        each dictionary. This is useful if you want to sort items other than
+        in alphabetical order by key.
+
+        If for_json is true (not the default), objects with a ``for_json()``
+        method will use the return value of that method for encoding as JSON
+        instead of the object.
+
+        """
+
+        self.skipkeys = skipkeys
+        self.ensure_ascii = ensure_ascii
+        self.check_circular = check_circular
+        self.sort_keys = sort_keys
+        self.use_decimal = use_decimal
+        self.namedtuple_as_object = namedtuple_as_object
+        self.tuple_as_array = tuple_as_array
+        self.bigint_as_string = bigint_as_string
+        self.item_sort_key = item_sort_key
+        self.for_json = for_json
+        self.int_as_string_bitcount = int_as_string_bitcount
+        if indent is not None and not isinstance(indent, string_types):
+            indent = indent * ' '
+        self.indent = indent
+        if separators is not None:
+            self.item_separator, self.key_separator = separators
+        elif indent is not None:
+            self.item_separator = ','
+        if default is not None:
+            self.default = default
+        self.encoding = encoding
+
+    def default(self, o):
+        """Implement this method in a subclass such that it returns
+        a serializable object for ``o``, or calls the base implementation
+        (to raise a ``TypeError``).
+
+        For example, to support arbitrary iterators, you could
+        implement default like this::
+
+            def default(self, o):
+                try:
+                    iterable = iter(o)
+                except TypeError:
+                    pass
+                else:
+                    return list(iterable)
+                return JSONEncoder.default(self, o)
+
+        """
+        raise TypeError(repr(o) + " is not JSON serializable")
+
+    def encode(self, o):
+        """Return a JSON string representation of a Python data structure.
+
+        >>> from hjson import JSONEncoder
+        >>> JSONEncoder().encode({"foo": ["bar", "baz"]})
+        '{"foo": ["bar", "baz"]}'
+
+        """
+        # This is for extremely simple cases and benchmarks.
+        if isinstance(o, binary_type):
+            _encoding = self.encoding
+            if (_encoding is not None and not (_encoding == 'utf-8')):
+                o = o.decode(_encoding)
+        if isinstance(o, string_types):
+            if self.ensure_ascii:
+                return encode_basestring_ascii(o)
+            else:
+                return encode_basestring(o)
+        # This doesn't pass the iterator directly to ''.join() because the
+        # exceptions aren't as detailed.  The list call should be roughly
+        # equivalent to the PySequence_Fast that ''.join() would do.
+        chunks = self.iterencode(o, _one_shot=True)
+        if not isinstance(chunks, (list, tuple)):
+            chunks = list(chunks)
+        if self.ensure_ascii:
+            return ''.join(chunks)
+        else:
+            return u''.join(chunks)
+
+    def iterencode(self, o, _one_shot=False):
+        """Encode the given object and yield each string
+        representation as available.
+
+        For example::
+
+            for chunk in JSONEncoder().iterencode(bigobject):
+                mysocket.write(chunk)
+
+        """
+        if self.check_circular:
+            markers = {}
+        else:
+            markers = None
+        if self.ensure_ascii:
+            _encoder = encode_basestring_ascii
+        else:
+            _encoder = encode_basestring
+        if self.encoding != 'utf-8':
+            def _encoder(o, _orig_encoder=_encoder, _encoding=self.encoding):
+                if isinstance(o, binary_type):
+                    o = o.decode(_encoding)
+                return _orig_encoder(o)
+
+        def floatstr(o, _repr=FLOAT_REPR, _inf=PosInf, _neginf=-PosInf):
+            # Check for specials. Note that this type of test is processor
+            # and/or platform-specific, so do tests which don't depend on
+            # the internals.
+
+            if o != o:
+                text = 'null'
+            elif o == _inf:
+                text = 'null'
+            elif o == _neginf:
+                text = 'null'
+            else:
+                return _repr(o)
+
+            return text
+
+        key_memo = {}
+        int_as_string_bitcount = (
+            53 if self.bigint_as_string else self.int_as_string_bitcount)
+        _iterencode = _make_iterencode(
+            markers, self.default, _encoder, self.indent, floatstr,
+            self.key_separator, self.item_separator, self.sort_keys,
+            self.skipkeys, _one_shot, self.use_decimal,
+            self.namedtuple_as_object, self.tuple_as_array,
+            int_as_string_bitcount,
+            self.item_sort_key, self.encoding, self.for_json,
+            Decimal=Decimal)
+        try:
+            return _iterencode(o, 0)
+        finally:
+            key_memo.clear()
+
+
+def _make_iterencode(markers, _default, _encoder, _indent, _floatstr,
+        _key_separator, _item_separator, _sort_keys, _skipkeys, _one_shot,
+        _use_decimal, _namedtuple_as_object, _tuple_as_array,
+        _int_as_string_bitcount, _item_sort_key,
+        _encoding,_for_json,
+        ## HACK: hand-optimized bytecode; turn globals into locals
+        _PY3=PY3,
+        ValueError=ValueError,
+        string_types=string_types,
+        Decimal=Decimal,
+        dict=dict,
+        float=float,
+        id=id,
+        integer_types=integer_types,
+        isinstance=isinstance,
+        list=list,
+        str=str,
+        tuple=tuple,
+    ):
+    if _item_sort_key and not callable(_item_sort_key):
+        raise TypeError("item_sort_key must be None or callable")
+    elif _sort_keys and not _item_sort_key:
+        _item_sort_key = itemgetter(0)
+
+    if (_int_as_string_bitcount is not None and
+        (_int_as_string_bitcount <= 0 or
+         not isinstance(_int_as_string_bitcount, integer_types))):
+        raise TypeError("int_as_string_bitcount must be a positive integer")
+
+    def _encode_int(value):
+        skip_quoting = (
+            _int_as_string_bitcount is None
+            or
+            _int_as_string_bitcount < 1
+        )
+        if (
+            skip_quoting or
+            (-1 << _int_as_string_bitcount)
+            < value <
+            (1 << _int_as_string_bitcount)
+        ):
+            return str(value)
+        return '"' + str(value) + '"'
+
+    def _iterencode_list(lst, _current_indent_level):
+        if not lst:
+            yield '[]'
+            return
+        if markers is not None:
+            markerid = id(lst)
+            if markerid in markers:
+                raise ValueError("Circular reference detected")
+            markers[markerid] = lst
+        buf = '['
+        if _indent is not None:
+            _current_indent_level += 1
+            newline_indent = '\n' + (_indent * _current_indent_level)
+            separator = _item_separator + newline_indent
+            buf += newline_indent
+        else:
+            newline_indent = None
+            separator = _item_separator
+        first = True
+        for value in lst:
+            if first:
+                first = False
+            else:
+                buf = separator
+            yield buf
+
+            for chunk in _iterencode(value, _current_indent_level):
+                yield chunk
+
+        if newline_indent is not None:
+            _current_indent_level -= 1
+            yield '\n' + (_indent * _current_indent_level)
+        yield ']'
+        if markers is not None:
+            del markers[markerid]
+
+    def _stringify_key(key):
+        if isinstance(key, string_types): # pragma: no cover
+            pass
+        elif isinstance(key, binary_type):
+            key = key.decode(_encoding)
+        elif isinstance(key, float):
+            key = _floatstr(key)
+        elif key is True:
+            key = 'true'
+        elif key is False:
+            key = 'false'
+        elif key is None:
+            key = 'null'
+        elif isinstance(key, integer_types):
+            key = str(key)
+        elif _use_decimal and isinstance(key, Decimal):
+            key = str(key)
+        elif _skipkeys:
+            key = None
+        else:
+            raise TypeError("key " + repr(key) + " is not a string")
+        return key
+
+    def _iterencode_dict(dct, _current_indent_level):
+        if not dct:
+            yield '{}'
+            return
+        if markers is not None:
+            markerid = id(dct)
+            if markerid in markers:
+                raise ValueError("Circular reference detected")
+            markers[markerid] = dct
+        yield '{'
+        if _indent is not None:
+            _current_indent_level += 1
+            newline_indent = '\n' + (_indent * _current_indent_level)
+            item_separator = _item_separator + newline_indent
+            yield newline_indent
+        else:
+            newline_indent = None
+            item_separator = _item_separator
+        first = True
+        if _PY3:
+            iteritems = dct.items()
+        else:
+            iteritems = dct.iteritems()
+        if _item_sort_key:
+            items = []
+            for k, v in dct.items():
+                if not isinstance(k, string_types):
+                    k = _stringify_key(k)
+                    if k is None:
+                        continue
+                items.append((k, v))
+            items.sort(key=_item_sort_key)
+        else:
+            items = iteritems
+        for key, value in items:
+            if not (_item_sort_key or isinstance(key, string_types)):
+                key = _stringify_key(key)
+                if key is None:
+                    # _skipkeys must be True
+                    continue
+            if first:
+                first = False
+            else:
+                yield item_separator
+            yield _encoder(key)
+            yield _key_separator
+
+            for chunk in _iterencode(value, _current_indent_level):
+                yield chunk
+
+        if newline_indent is not None:
+            _current_indent_level -= 1
+            yield '\n' + (_indent * _current_indent_level)
+        yield '}'
+        if markers is not None:
+            del markers[markerid]
+
+    def _iterencode(o, _current_indent_level):
+        if (isinstance(o, string_types) or
+            (_PY3 and isinstance(o, binary_type))):
+            yield _encoder(o)
+        elif o is None:
+            yield 'null'
+        elif o is True:
+            yield 'true'
+        elif o is False:
+            yield 'false'
+        elif isinstance(o, integer_types):
+            yield _encode_int(o)
+        elif isinstance(o, float):
+            yield _floatstr(o)
+        else:
+            for_json = _for_json and getattr(o, 'for_json', None)
+            if for_json and callable(for_json):
+                for chunk in _iterencode(for_json(), _current_indent_level):
+                    yield chunk
+            elif isinstance(o, list):
+                for chunk in _iterencode_list(o, _current_indent_level):
+                    yield chunk
+            else:
+                _asdict = _namedtuple_as_object and getattr(o, '_asdict', None)
+                if _asdict and callable(_asdict):
+                    for chunk in _iterencode_dict(_asdict(), _current_indent_level):
+                        yield chunk
+                elif (_tuple_as_array and isinstance(o, tuple)):
+                    for chunk in _iterencode_list(o, _current_indent_level):
+                        yield chunk
+                elif isinstance(o, dict):
+                    for chunk in _iterencode_dict(o, _current_indent_level):
+                        yield chunk
+                elif _use_decimal and isinstance(o, Decimal):
+                    yield str(o)
+                else:
+                    if markers is not None:
+                        markerid = id(o)
+                        if markerid in markers:
+                            raise ValueError("Circular reference detected")
+                        markers[markerid] = o
+                    o = _default(o)
+                    for chunk in _iterencode(o, _current_indent_level):
+                        yield chunk
+                    if markers is not None:
+                        del markers[markerid]
+
+    return _iterencode

parrot/lib/python3.10/site-packages/hjson/tests/__init__.py

@@ -0,0 +1,61 @@
+from __future__ import absolute_import
+import unittest
+import doctest
+import sys
+
+
+def additional_tests(suite=None):
+    import hjson
+    import hjson.encoder
+    import hjson.decoder
+    if suite is None:
+        suite = unittest.TestSuite()
+    for mod in (hjson, hjson.encoder, hjson.decoder):
+        suite.addTest(doctest.DocTestSuite(mod))
+    return suite
+
+
+def all_tests_suite():
+    def get_suite():
+        return additional_tests(
+            unittest.TestLoader().loadTestsFromNames([
+                'hjson.tests.test_hjson',
+                'hjson.tests.test_bitsize_int_as_string',
+                'hjson.tests.test_bigint_as_string',
+                'hjson.tests.test_check_circular',
+                'hjson.tests.test_decode',
+                'hjson.tests.test_default',
+                'hjson.tests.test_dump',
+                'hjson.tests.test_encode_basestring_ascii',
+                'hjson.tests.test_errors',
+                'hjson.tests.test_fail',
+                'hjson.tests.test_float',
+                'hjson.tests.test_indent',
+                'hjson.tests.test_pass1',
+                'hjson.tests.test_pass2',
+                'hjson.tests.test_pass3',
+                'hjson.tests.test_recursion',
+                'hjson.tests.test_scanstring',
+                'hjson.tests.test_separators',
+                'hjson.tests.test_unicode',
+                'hjson.tests.test_decimal',
+                'hjson.tests.test_tuple',
+                'hjson.tests.test_namedtuple',
+                #'hjson.tests.test_tool', # fails on windows
+                'hjson.tests.test_for_json',
+            ]))
+    suite = get_suite()
+    return suite
+
+
+def main():
+    runner = unittest.TextTestRunner(verbosity=1 + sys.argv.count('-v'))
+    suite = all_tests_suite()
+    raise SystemExit(not runner.run(suite).wasSuccessful())
+
+
+if __name__ == '__main__':
+    import os
+    import sys
+    sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+    main()

parrot/lib/python3.10/site-packages/hjson/tests/test_bigint_as_string.py

@@ -0,0 +1,67 @@
+from unittest import TestCase
+
+import hjson as json
+
+
+class TestBigintAsString(TestCase):
+    # Python 2.5, at least the one that ships on Mac OS X, calculates
+    # 2 ** 53 as 0! It manages to calculate 1 << 53 correctly.
+    values = [(200, 200),
+              ((1 << 53) - 1, 9007199254740991),
+              ((1 << 53), '9007199254740992'),
+              ((1 << 53) + 1, '9007199254740993'),
+              (-100, -100),
+              ((-1 << 53), '-9007199254740992'),
+              ((-1 << 53) - 1, '-9007199254740993'),
+              ((-1 << 53) + 1, -9007199254740991)]
+
+    options = (
+        {"bigint_as_string": True},
+        {"int_as_string_bitcount": 53}
+    )
+
+    def test_ints(self):
+        for opts in self.options:
+            for val, expect in self.values:
+                self.assertEqual(
+                    val,
+                    json.loads(json.dumpsJSON(val)))
+                self.assertEqual(
+                    expect,
+                    json.loads(json.dumpsJSON(val, **opts)))
+
+    def test_lists(self):
+        for opts in self.options:
+            for val, expect in self.values:
+                val = [val, val]
+                expect = [expect, expect]
+                self.assertEqual(
+                    val,
+                    json.loads(json.dumpsJSON(val)))
+                self.assertEqual(
+                    expect,
+                    json.loads(json.dumpsJSON(val, **opts)))
+
+    def test_dicts(self):
+        for opts in self.options:
+            for val, expect in self.values:
+                val = {'k': val}
+                expect = {'k': expect}
+                self.assertEqual(
+                    val,
+                    json.loads(json.dumpsJSON(val)))
+                self.assertEqual(
+                    expect,
+                    json.loads(json.dumpsJSON(val, **opts)))
+
+    def test_dict_keys(self):
+        for opts in self.options:
+            for val, _ in self.values:
+                expect = {str(val): 'value'}
+                val = {val: 'value'}
+                self.assertEqual(
+                    expect,
+                    json.loads(json.dumpsJSON(val)))
+                self.assertEqual(
+                    expect,
+                    json.loads(json.dumpsJSON(val, **opts)))

parrot/lib/python3.10/site-packages/hjson/tests/test_bitsize_int_as_string.py

@@ -0,0 +1,73 @@
+from unittest import TestCase
+
+import hjson as json
+
+
+class TestBitSizeIntAsString(TestCase):
+    # Python 2.5, at least the one that ships on Mac OS X, calculates
+    # 2 ** 31 as 0! It manages to calculate 1 << 31 correctly.
+    values = [
+        (200, 200),
+        ((1 << 31) - 1, (1 << 31) - 1),
+        ((1 << 31), str(1 << 31)),
+        ((1 << 31) + 1, str((1 << 31) + 1)),
+        (-100, -100),
+        ((-1 << 31), str(-1 << 31)),
+        ((-1 << 31) - 1, str((-1 << 31) - 1)),
+        ((-1 << 31) + 1, (-1 << 31) + 1),
+    ]
+
+    def test_invalid_counts(self):
+        for n in ['foo', -1, 0, 1.0]:
+            self.assertRaises(
+                TypeError,
+                json.dumpsJSON, 0, int_as_string_bitcount=n)
+
+    def test_ints_outside_range_fails(self):
+        self.assertNotEqual(
+            str(1 << 15),
+            json.loads(json.dumpsJSON(1 << 15, int_as_string_bitcount=16)),
+            )
+
+    def test_ints(self):
+        for val, expect in self.values:
+            self.assertEqual(
+                val,
+                json.loads(json.dumpsJSON(val)))
+            self.assertEqual(
+                expect,
+                json.loads(json.dumpsJSON(val, int_as_string_bitcount=31)),
+                )
+
+    def test_lists(self):
+        for val, expect in self.values:
+            val = [val, val]
+            expect = [expect, expect]
+            self.assertEqual(
+                val,
+                json.loads(json.dumpsJSON(val)))
+            self.assertEqual(
+                expect,
+                json.loads(json.dumpsJSON(val, int_as_string_bitcount=31)))
+
+    def test_dicts(self):
+        for val, expect in self.values:
+            val = {'k': val}
+            expect = {'k': expect}
+            self.assertEqual(
+                val,
+                json.loads(json.dumpsJSON(val)))
+            self.assertEqual(
+                expect,
+                json.loads(json.dumpsJSON(val, int_as_string_bitcount=31)))
+
+    def test_dict_keys(self):
+        for val, _ in self.values:
+            expect = {str(val): 'value'}
+            val = {val: 'value'}
+            self.assertEqual(
+                expect,
+                json.loads(json.dumpsJSON(val)))
+            self.assertEqual(
+                expect,
+                json.loads(json.dumpsJSON(val, int_as_string_bitcount=31)))

parrot/lib/python3.10/site-packages/hjson/tests/test_check_circular.py

@@ -0,0 +1,30 @@
+from unittest import TestCase
+import hjson as json
+
+def default_iterable(obj):
+    return list(obj)
+
+class TestCheckCircular(TestCase):
+    def test_circular_dict(self):
+        dct = {}
+        dct['a'] = dct
+        self.assertRaises(ValueError, json.dumpsJSON, dct)
+
+    def test_circular_list(self):
+        lst = []
+        lst.append(lst)
+        self.assertRaises(ValueError, json.dumpsJSON, lst)
+
+    def test_circular_composite(self):
+        dct2 = {}
+        dct2['a'] = []
+        dct2['a'].append(dct2)
+        self.assertRaises(ValueError, json.dumpsJSON, dct2)
+
+    def test_circular_default(self):
+        json.dumpsJSON([set()], default=default_iterable)
+        self.assertRaises(TypeError, json.dumpsJSON, [set()])
+
+    def test_circular_off_default(self):
+        json.dumpsJSON([set()], default=default_iterable, check_circular=False)
+        self.assertRaises(TypeError, json.dumpsJSON, [set()], check_circular=False)

parrot/lib/python3.10/site-packages/hjson/tests/test_decimal.py

@@ -0,0 +1,71 @@
+import decimal
+from decimal import Decimal
+from unittest import TestCase
+from hjson.compat import StringIO, reload_module
+
+import hjson as json
+
+class TestDecimal(TestCase):
+    NUMS = "1.0", "10.00", "1.1", "1234567890.1234567890", "500"
+    def dumps(self, obj, **kw):
+        sio = StringIO()
+        json.dumpJSON(obj, sio, **kw)
+        res = json.dumpsJSON(obj, **kw)
+        self.assertEqual(res, sio.getvalue())
+        return res
+
+    def loads(self, s, **kw):
+        sio = StringIO(s)
+        res = json.loads(s, **kw)
+        self.assertEqual(res, json.load(sio, **kw))
+        return res
+
+    def test_decimal_encode(self):
+        for d in map(Decimal, self.NUMS):
+            self.assertEqual(self.dumps(d, use_decimal=True), str(d))
+
+    def test_decimal_decode(self):
+        for s in self.NUMS:
+            self.assertEqual(self.loads(s, parse_float=Decimal), Decimal(s))
+
+    def test_stringify_key(self):
+        for d in map(Decimal, self.NUMS):
+            v = {d: d}
+            self.assertEqual(
+                self.loads(
+                    self.dumps(v, use_decimal=True), parse_float=Decimal),
+                {str(d): d})
+
+    def test_decimal_roundtrip(self):
+        for d in map(Decimal, self.NUMS):
+            # The type might not be the same (int and Decimal) but they
+            # should still compare equal.
+            for v in [d, [d], {'': d}]:
+                self.assertEqual(
+                    self.loads(
+                        self.dumps(v, use_decimal=True), parse_float=Decimal),
+                    v)
+
+    def test_decimal_defaults(self):
+        d = Decimal('1.1')
+        # use_decimal=True is the default
+        self.assertRaises(TypeError, json.dumpsJSON, d, use_decimal=False)
+        self.assertEqual('1.1', json.dumpsJSON(d))
+        self.assertEqual('1.1', json.dumpsJSON(d, use_decimal=True))
+        self.assertRaises(TypeError, json.dumpJSON, d, StringIO(),
+                          use_decimal=False)
+        sio = StringIO()
+        json.dumpJSON(d, sio)
+        self.assertEqual('1.1', sio.getvalue())
+        sio = StringIO()
+        json.dumpJSON(d, sio, use_decimal=True)
+        self.assertEqual('1.1', sio.getvalue())
+
+    def test_decimal_reload(self):
+        # Simulate a subinterpreter that reloads the Python modules but not
+        # the C code https://github.com/simplejson/simplejson/issues/34
+        global Decimal
+        Decimal = reload_module(decimal).Decimal
+        import hjson.encoder
+        hjson.encoder.Decimal = Decimal
+        self.test_decimal_roundtrip()

parrot/lib/python3.10/site-packages/hjson/tests/test_default.py

@@ -0,0 +1,9 @@
+from unittest import TestCase
+
+import hjson as json
+
+class TestDefault(TestCase):
+    def test_default(self):
+        self.assertEqual(
+            json.dumpsJSON(type, default=repr),
+            json.dumpsJSON(repr(type)))

parrot/lib/python3.10/site-packages/hjson/tests/test_dump.py

@@ -0,0 +1,130 @@
+from unittest import TestCase
+from hjson.compat import StringIO, long_type, b, binary_type, PY3
+import hjson as json
+
+def as_text_type(s):
+    if PY3 and isinstance(s, binary_type):
+        return s.decode('ascii')
+    return s
+
+class TestDump(TestCase):
+    def test_dump(self):
+        sio = StringIO()
+        json.dumpJSON({}, sio)
+        self.assertEqual(sio.getvalue(), '{}')
+
+    def test_constants(self):
+        for c in [None, True, False]:
+            self.assertTrue(json.loads(json.dumpsJSON(c)) is c)
+            self.assertTrue(json.loads(json.dumpsJSON([c]))[0] is c)
+            self.assertTrue(json.loads(json.dumpsJSON({'a': c}))['a'] is c)
+
+    def test_stringify_key(self):
+        items = [(b('bytes'), 'bytes'),
+                 (1.0, '1.0'),
+                 (10, '10'),
+                 (True, 'true'),
+                 (False, 'false'),
+                 (None, 'null'),
+                 (long_type(100), '100')]
+        for k, expect in items:
+            self.assertEqual(
+                json.loads(json.dumpsJSON({k: expect})),
+                {expect: expect})
+            self.assertEqual(
+                json.loads(json.dumpsJSON({k: expect}, sort_keys=True)),
+                {expect: expect})
+        self.assertRaises(TypeError, json.dumpsJSON, {json: 1})
+        for v in [{}, {'other': 1}, {b('derp'): 1, 'herp': 2}]:
+            for sort_keys in [False, True]:
+                v0 = dict(v)
+                v0[json] = 1
+                v1 = dict((as_text_type(key), val) for (key, val) in v.items())
+                self.assertEqual(
+                    json.loads(json.dumpsJSON(v0, skipkeys=True, sort_keys=sort_keys)),
+                    v1)
+                self.assertEqual(
+                    json.loads(json.dumpsJSON({'': v0}, skipkeys=True, sort_keys=sort_keys)),
+                    {'': v1})
+                self.assertEqual(
+                    json.loads(json.dumpsJSON([v0], skipkeys=True, sort_keys=sort_keys)),
+                    [v1])
+
+    def test_dumps(self):
+        self.assertEqual(json.dumpsJSON({}), '{}')
+
+    def test_encode_truefalse(self):
+        self.assertEqual(json.dumpsJSON(
+                 {True: False, False: True}, sort_keys=True),
+                 '{"false": true, "true": false}')
+        self.assertEqual(
+            json.dumpsJSON(
+                {2: 3.0,
+                 4.0: long_type(5),
+                 False: 1,
+                 long_type(6): True,
+                 "7": 0},
+                sort_keys=True),
+            '{"2": 3.0, "4.0": 5, "6": true, "7": 0, "false": 1}')
+
+    def test_ordered_dict(self):
+        # http://bugs.python.org/issue6105
+        items = [('one', 1), ('two', 2), ('three', 3), ('four', 4), ('five', 5)]
+        s = json.dumpsJSON(json.OrderedDict(items))
+        self.assertEqual(
+            s,
+            '{"one": 1, "two": 2, "three": 3, "four": 4, "five": 5}')
+
+    def test_indent_unknown_type_acceptance(self):
+        """
+        A test against the regression mentioned at `github issue 29`_.
+
+        The indent parameter should accept any type which pretends to be
+        an instance of int or long when it comes to being multiplied by
+        strings, even if it is not actually an int or long, for
+        backwards compatibility.
+
+        .. _github issue 29:
+           http://github.com/simplejson/simplejson/issue/29
+        """
+
+        class AwesomeInt(object):
+            """An awesome reimplementation of integers"""
+
+            def __init__(self, *args, **kwargs):
+                if len(args) > 0:
+                    # [construct from literals, objects, etc.]
+                    # ...
+
+                    # Finally, if args[0] is an integer, store it
+                    if isinstance(args[0], int):
+                        self._int = args[0]
+
+            # [various methods]
+
+            def __mul__(self, other):
+                # [various ways to multiply AwesomeInt objects]
+                # ... finally, if the right-hand operand is not awesome enough,
+                # try to do a normal integer multiplication
+                if hasattr(self, '_int'):
+                    return self._int * other
+                else:
+                    raise NotImplementedError("To do non-awesome things with"
+                        " this object, please construct it from an integer!")
+
+        s = json.dumpsJSON([0, 1, 2], indent=AwesomeInt(3))
+        self.assertEqual(s, '[\n   0,\n   1,\n   2\n]')
+
+    def test_accumulator(self):
+        # the C API uses an accumulator that collects after 100,000 appends
+        lst = [0] * 100000
+        self.assertEqual(json.loads(json.dumpsJSON(lst)), lst)
+
+    def test_sort_keys(self):
+        # https://github.com/simplejson/simplejson/issues/106
+        for num_keys in range(2, 32):
+            p = dict((str(x), x) for x in range(num_keys))
+            sio = StringIO()
+            json.dumpJSON(p, sio, sort_keys=True)
+            self.assertEqual(sio.getvalue(), json.dumpsJSON(p, sort_keys=True))
+            self.assertEqual(json.loads(sio.getvalue()), p)

parrot/lib/python3.10/site-packages/hjson/tests/test_encode_basestring_ascii.py

@@ -0,0 +1,42 @@
+from unittest import TestCase
+
+import hjson.encoder
+from hjson.compat import b
+
+CASES = [
+    (u'/\\"\ucafe\ubabe\uab98\ufcde\ubcda\uef4a\x08\x0c\n\r\t`1~!@#$%^&*()_+-=[]{}|;:\',./<>?', '"/\\\\\\"\\ucafe\\ubabe\\uab98\\ufcde\\ubcda\\uef4a\\b\\f\\n\\r\\t`1~!@#$%^&*()_+-=[]{}|;:\',./<>?"'),
+    (u'\u0123\u4567\u89ab\ucdef\uabcd\uef4a', '"\\u0123\\u4567\\u89ab\\ucdef\\uabcd\\uef4a"'),
+    (u'controls', '"controls"'),
+    (u'\x08\x0c\n\r\t', '"\\b\\f\\n\\r\\t"'),
+    (u'{"object with 1 member":["array with 1 element"]}', '"{\\"object with 1 member\\":[\\"array with 1 element\\"]}"'),
+    (u' s p a c e d ', '" s p a c e d "'),
+    (u'\U0001d120', '"\\ud834\\udd20"'),
+    (u'\u03b1\u03a9', '"\\u03b1\\u03a9"'),
+    (b('\xce\xb1\xce\xa9'), '"\\u03b1\\u03a9"'),
+    (u'\u03b1\u03a9', '"\\u03b1\\u03a9"'),
+    (b('\xce\xb1\xce\xa9'), '"\\u03b1\\u03a9"'),
+    (u'\u03b1\u03a9', '"\\u03b1\\u03a9"'),
+    (u'\u03b1\u03a9', '"\\u03b1\\u03a9"'),
+    (u"`1~!@#$%^&*()_+-={':[,]}|;.</>?", '"`1~!@#$%^&*()_+-={\':[,]}|;.</>?"'),
+    (u'\x08\x0c\n\r\t', '"\\b\\f\\n\\r\\t"'),
+    (u'\u0123\u4567\u89ab\ucdef\uabcd\uef4a', '"\\u0123\\u4567\\u89ab\\ucdef\\uabcd\\uef4a"'),
+]
+
+class TestEncodeBaseStringAscii(TestCase):
+    def test_py_encode_basestring_ascii(self):
+        self._test_encode_basestring_ascii(hjson.encoder.encode_basestring_ascii)
+
+    def _test_encode_basestring_ascii(self, encode_basestring_ascii):
+        fname = encode_basestring_ascii.__name__
+        for input_string, expect in CASES:
+            result = encode_basestring_ascii(input_string)
+            #self.assertEqual(result, expect,
+            #    '{0!r} != {1!r} for {2}({3!r})'.format(
+            #        result, expect, fname, input_string))
+            self.assertEqual(result, expect,
+                '%r != %r for %s(%r)' % (result, expect, fname, input_string))
+
+    def test_sorted_dict(self):
+        items = [('one', 1), ('two', 2), ('three', 3), ('four', 4), ('five', 5)]
+        s = hjson.dumpsJSON(dict(items), sort_keys=True)
+        self.assertEqual(s, '{"five": 5, "four": 4, "one": 1, "three": 3, "two": 2}')

parrot/lib/python3.10/site-packages/hjson/tests/test_errors.py

@@ -0,0 +1,51 @@
+import sys, pickle
+from unittest import TestCase
+
+import hjson as json
+from hjson.compat import u, b
+
+class TestErrors(TestCase):
+    def test_string_keys_error(self):
+        data = [{'a': 'A', 'b': (2, 4), 'c': 3.0, ('d',): 'D tuple'}]
+        self.assertRaises(TypeError, json.dumpsJSON, data)
+
+    def test_decode_error(self):
+        err = None
+        try:
+            json.loads('{}\na\nb')
+        except json.HjsonDecodeError:
+            err = sys.exc_info()[1]
+        else:
+            self.fail('Expected HjsonDecodeError')
+        self.assertEqual(err.lineno, 2)
+        self.assertEqual(err.colno, 1)
+        self.assertEqual(err.endlineno, 3)
+        self.assertEqual(err.endcolno, 2)
+
+    def test_scan_error(self):
+        err = None
+        for t in (u, b):
+            try:
+                json.loads(t('{"asdf": "'))
+            except json.HjsonDecodeError:
+                err = sys.exc_info()[1]
+            else:
+                self.fail('Expected HjsonDecodeError')
+            self.assertEqual(err.lineno, 1)
+            self.assertEqual(err.colno, 10)
+
+    def test_error_is_pickable(self):
+        err = None
+        try:
+            json.loads('{}\na\nb')
+        except json.HjsonDecodeError:
+            err = sys.exc_info()[1]
+        else:
+            self.fail('Expected HjsonDecodeError')
+        s = pickle.dumps(err)
+        e = pickle.loads(s)
+
+        self.assertEqual(err.msg, e.msg)
+        self.assertEqual(err.doc, e.doc)
+        self.assertEqual(err.pos, e.pos)
+        self.assertEqual(err.end, e.end)

parrot/lib/python3.10/site-packages/hjson/tests/test_fail.py

@@ -0,0 +1,143 @@
+import sys
+from unittest import TestCase
+
+import hjson as json
+
+# 2007-10-05
+JSONDOCS = [
+    # http://json.org/JSON_checker/test/fail1.json
+    # '"A JSON payload should be an object or array, not a string."',
+    # http://json.org/JSON_checker/test/fail2.json
+    '["Unclosed array"',
+    # http://json.org/JSON_checker/test/fail3.json
+    #'{unquoted_key: "keys must be quoted"}',
+    # http://json.org/JSON_checker/test/fail4.json
+    # '["extra comma",]',
+    # http://json.org/JSON_checker/test/fail5.json
+    '["double extra comma",,]',
+    # http://json.org/JSON_checker/test/fail6.json
+    '[   , "<-- missing value"]',
+    # http://json.org/JSON_checker/test/fail7.json
+    '["Comma after the close"],',
+    # http://json.org/JSON_checker/test/fail8.json
+    '["Extra close"]]',
+    # http://json.org/JSON_checker/test/fail9.json
+    # '{"Extra comma": true,}',
+    # http://json.org/JSON_checker/test/fail10.json
+    '{"Extra value after close": true} "misplaced quoted value"',
+    # http://json.org/JSON_checker/test/fail11.json
+    '{"Illegal expression": 1 + 2}',
+    # http://json.org/JSON_checker/test/fail12.json
+    '{"Illegal invocation": alert()}',
+    # http://json.org/JSON_checker/test/fail13.json
+    '{"Numbers cannot have leading zeroes": 013}',
+    # http://json.org/JSON_checker/test/fail14.json
+    '{"Numbers cannot be hex": 0x14}',
+    # http://json.org/JSON_checker/test/fail15.json
+    '["Illegal backslash escape: \\x15"]',
+    # http://json.org/JSON_checker/test/fail16.json
+    '[\\naked]',
+    # http://json.org/JSON_checker/test/fail17.json
+    '["Illegal backslash escape: \\017"]',
+    # http://json.org/JSON_checker/test/fail18.json
+    # '[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]',
+    # http://json.org/JSON_checker/test/fail19.json
+    '{"Missing colon" null}',
+    # http://json.org/JSON_checker/test/fail20.json
+    '{"Double colon":: null}',
+    # http://json.org/JSON_checker/test/fail21.json
+    '{"Comma instead of colon", null}',
+    # http://json.org/JSON_checker/test/fail22.json
+    '["Colon instead of comma": false]',
+    # http://json.org/JSON_checker/test/fail23.json
+    '["Bad value", truth]',
+    # http://json.org/JSON_checker/test/fail24.json
+    #"['single quote']",
+    # http://json.org/JSON_checker/test/fail25.json
+    '["\ttab\tcharacter\tin\tstring\t"]',
+    # http://json.org/JSON_checker/test/fail26.json
+    '["tab\\   character\\   in\\  string\\  "]',
+    # http://json.org/JSON_checker/test/fail27.json
+    '["line\nbreak"]',
+    # http://json.org/JSON_checker/test/fail28.json
+    '["line\\\nbreak"]',
+    # http://json.org/JSON_checker/test/fail29.json
+    '[0e]',
+    # http://json.org/JSON_checker/test/fail30.json
+    '[0e+]',
+    # http://json.org/JSON_checker/test/fail31.json
+    '[0e+-1]',
+    # http://json.org/JSON_checker/test/fail32.json
+    '{"Comma instead if closing brace": true,',
+    # http://json.org/JSON_checker/test/fail33.json
+    '["mismatch"}',
+    # http://code.google.com/p/simplejson/issues/detail?id=3
+    u'["A\u001FZ control characters in string"]',
+    # misc based on coverage
+    '{',
+    '{]',
+    '{"foo": "bar"]',
+    '{"foo": "bar"',
+]
+
+class TestFail(TestCase):
+    def test_failures(self):
+        for idx, doc in enumerate(JSONDOCS):
+            idx = idx + 1
+            try:
+                json.loads(doc)
+            except json.HjsonDecodeError:
+                pass
+            else:
+                self.fail("Expected failure for fail%d.json: %r" % (idx, doc))
+
+    def test_array_decoder_issue46(self):
+        # http://code.google.com/p/simplejson/issues/detail?id=46
+        for doc in [u'[,]', '[,]']:
+            try:
+                json.loads(doc)
+            except json.HjsonDecodeError:
+                pass
+            except Exception:
+                e = sys.exc_info()[1]
+                self.fail("Unexpected exception raised %r %s" % (e, e))
+            else:
+                self.fail("Unexpected success parsing '[,]'")
+
+    def test_truncated_input(self):
+        test_cases = [
+            ('[', "End of input while parsing an array", 1),
+            # ('[42', "Expecting ',' delimiter", 3),
+            ('[42,', 'Expecting value', 4),
+            ('["', 'Unterminated string starting at', 1),
+            ('["spam', 'Unterminated string starting at', 1),
+            # ('["spam"', "Expecting ',' delimiter", 7),
+            ('["spam",', 'Expecting value', 8),
+            ('{', 'Bad key name (eof)', 1),
+            ('{"', 'Unterminated string starting at', 1),
+            ('{"spam', 'Unterminated string starting at', 1),
+            ('{"spam"', "Expecting ':' delimiter", 7),
+            ('{"spam":', 'Expecting value', 8),
+            # ('{"spam":42', "Expecting ',' delimiter", 10),
+            ('{"spam":42,', 'Bad key name (eof)', 11),
+            ('"', 'Unterminated string starting at', 0),
+            ('"spam', 'Unterminated string starting at', 0),
+            ('[,', "Found a punctuator character", 1),
+        ]
+        for data, msg, idx in test_cases:
+            try:
+                json.loads(data)
+            except json.HjsonDecodeError:
+                e = sys.exc_info()[1]
+                self.assertEqual(
+                    e.msg[:len(msg)],
+                    msg,
+                    "%r doesn't start with %r for %r" % (e.msg, msg, data))
+                self.assertEqual(
+                    e.pos, idx,
+                    "pos %r != %r for %r" % (e.pos, idx, data))
+            except Exception:
+                e = sys.exc_info()[1]
+                self.fail("Unexpected exception raised %r %s" % (e, e))
+            else:
+                self.fail("Unexpected success parsing '%r'" % (data,))

parrot/lib/python3.10/site-packages/hjson/tests/test_float.py

@@ -0,0 +1,25 @@
+import math
+from unittest import TestCase
+from hjson.compat import long_type, text_type
+import hjson as json
+from hjson.decoder import NaN, PosInf, NegInf
+
+class TestFloat(TestCase):
+
+    def test_degenerates_ignore(self):
+        for f in (PosInf, NegInf, NaN):
+            self.assertEqual(json.loads(json.dumpsJSON(f)), None)
+
+    def test_floats(self):
+        for num in [1617161771.7650001, math.pi, math.pi**100,
+                    math.pi**-100, 3.1]:
+            self.assertEqual(float(json.dumpsJSON(num)), num)
+            self.assertEqual(json.loads(json.dumpsJSON(num)), num)
+            self.assertEqual(json.loads(text_type(json.dumpsJSON(num))), num)
+
+    def test_ints(self):
+        for num in [1, long_type(1), 1<<32, 1<<64]:
+            self.assertEqual(json.dumpsJSON(num), str(num))
+            self.assertEqual(int(json.dumpsJSON(num)), num)
+            self.assertEqual(json.loads(json.dumpsJSON(num)), num)
+            self.assertEqual(json.loads(text_type(json.dumpsJSON(num))), num)

parrot/lib/python3.10/site-packages/hjson/tests/test_for_json.py

@@ -0,0 +1,97 @@
+import unittest
+import hjson as json
+
+
+class ForJson(object):
+    def for_json(self):
+        return {'for_json': 1}
+
+
+class NestedForJson(object):
+    def for_json(self):
+        return {'nested': ForJson()}
+
+
+class ForJsonList(object):
+    def for_json(self):
+        return ['list']
+
+
+class DictForJson(dict):
+    def for_json(self):
+        return {'alpha': 1}
+
+
+class ListForJson(list):
+    def for_json(self):
+        return ['list']
+
+
+class TestForJson(unittest.TestCase):
+    def assertRoundTrip(self, obj, other, for_json=True):
+        if for_json is None:
+            # None will use the default
+            s = json.dumpsJSON(obj)
+        else:
+            s = json.dumpsJSON(obj, for_json=for_json)
+        self.assertEqual(
+            json.loads(s),
+            other)
+
+    def test_for_json_encodes_stand_alone_object(self):
+        self.assertRoundTrip(
+            ForJson(),
+            ForJson().for_json())
+
+    def test_for_json_encodes_object_nested_in_dict(self):
+        self.assertRoundTrip(
+            {'hooray': ForJson()},
+            {'hooray': ForJson().for_json()})
+
+    def test_for_json_encodes_object_nested_in_list_within_dict(self):
+        self.assertRoundTrip(
+            {'list': [0, ForJson(), 2, 3]},
+            {'list': [0, ForJson().for_json(), 2, 3]})
+
+    def test_for_json_encodes_object_nested_within_object(self):
+        self.assertRoundTrip(
+            NestedForJson(),
+            {'nested': {'for_json': 1}})
+
+    def test_for_json_encodes_list(self):
+        self.assertRoundTrip(
+            ForJsonList(),
+            ForJsonList().for_json())
+
+    def test_for_json_encodes_list_within_object(self):
+        self.assertRoundTrip(
+            {'nested': ForJsonList()},
+            {'nested': ForJsonList().for_json()})
+
+    def test_for_json_encodes_dict_subclass(self):
+        self.assertRoundTrip(
+            DictForJson(a=1),
+            DictForJson(a=1).for_json())
+
+    def test_for_json_encodes_list_subclass(self):
+        self.assertRoundTrip(
+            ListForJson(['l']),
+            ListForJson(['l']).for_json())
+
+    def test_for_json_ignored_if_not_true_with_dict_subclass(self):
+        for for_json in (None, False):
+            self.assertRoundTrip(
+                DictForJson(a=1),
+                {'a': 1},
+                for_json=for_json)
+
+    def test_for_json_ignored_if_not_true_with_list_subclass(self):
+        for for_json in (None, False):
+            self.assertRoundTrip(
+                ListForJson(['l']),
+                ['l'],
+                for_json=for_json)
+
+    def test_raises_typeerror_if_for_json_not_true_with_object(self):
+        self.assertRaises(TypeError, json.dumpsJSON, ForJson())
+        self.assertRaises(TypeError, json.dumpsJSON, ForJson(), for_json=False)

parrot/lib/python3.10/site-packages/hjson/tests/test_hjson.py

@@ -0,0 +1,65 @@
+from __future__ import with_statement
+
+import os
+import sys
+import subprocess
+import tempfile
+import codecs # dump
+
+from unittest import TestCase
+
+import hjson
+
+class TestAssets(TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestAssets, self).__init__(*args, **kwargs)
+        self.assetsDir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "assets")
+        self.assets = self.load('testlist.txt', False).split('\n')
+        self.maxDiff = None
+        self.verma, self.vermi = sys.version_info[0:2]
+
+    def load(self, name, cr):
+        name = os.path.join(self.assetsDir, name)
+        with open(name, 'rb') as f:
+            text = f.read().decode('utf-8')
+            text = text.replace('\r', '')
+            if cr: text = text.replace('\n', '\r\n')
+            return text
+
+    def check(self, name, file, inputCr):
+        text = self.load(file, inputCr)
+        shouldFail = name[0:4] == "fail"
+
+        try:
+            data = hjson.loads(text)
+            self.assertFalse(shouldFail, file)
+
+            text1 = hjson.dumpsJSON(data)
+            hjson1 = hjson.dumps(data, ensure_ascii=False);
+            result = hjson.loads(self.load(name + "_result.json", inputCr))
+            text2 = hjson.dumpsJSON(result)
+            hjson2 = self.load(name + "_result.hjson", False)
+
+            # dbg
+            # with open(name + "_dbg1.txt", "w") as tmp: tmp.write(hjson1.encode("utf-8"))
+            # with open(name + "_dbg2.txt", "w") as tmp: tmp.write(hjson2.encode("utf-8"))
+            # with codecs.open(name + "_dbg3.txt", 'w', 'utf-8') as tmp: hjson.dump(data, tmp)
+
+            if self.verma>2 or self.vermi>6:
+                # final check fails on py2.6 because of string formatting issues
+                self.assertEqual(text2, text1, file)
+                self.assertEqual(hjson2, hjson1, file)
+
+        except hjson.HjsonDecodeError as e:
+            if not shouldFail:
+                self.fail("raised error on parsing %s: %r" % (file, e))
+
+    def test_files(self):
+        for file in self.assets:
+            name, sep, ext = file.partition("_test.")
+            if name.startswith("stringify/quotes") or \
+                name.startswith("extra/"): continue # ignore/not supported
+
+            self.check(name, file, True)
+            self.check(name, file, False)

parrot/lib/python3.10/site-packages/hjson/tests/test_indent.py

@@ -0,0 +1,86 @@
+from unittest import TestCase
+import textwrap
+
+import hjson as json
+from hjson.compat import StringIO
+
+class TestIndent(TestCase):
+    def test_indent(self):
+        h = [['blorpie'], ['whoops'], [], 'd-shtaeou', 'd-nthiouh',
+             'i-vhbjkhnth',
+             {'nifty': 87}, {'field': 'yes', 'morefield': False} ]
+
+        expect = textwrap.dedent("""\
+        [
+        \t[
+        \t\t"blorpie"
+        \t],
+        \t[
+        \t\t"whoops"
+        \t],
+        \t[],
+        \t"d-shtaeou",
+        \t"d-nthiouh",
+        \t"i-vhbjkhnth",
+        \t{
+        \t\t"nifty": 87
+        \t},
+        \t{
+        \t\t"field": "yes",
+        \t\t"morefield": false
+        \t}
+        ]""")
+
+
+        d1 = json.dumpsJSON(h)
+        d2 = json.dumpsJSON(h, indent='\t', sort_keys=True, separators=(',', ': '))
+        d3 = json.dumpsJSON(h, indent='  ', sort_keys=True, separators=(',', ': '))
+        d4 = json.dumpsJSON(h, indent=2, sort_keys=True, separators=(',', ': '))
+
+        h1 = json.loads(d1)
+        h2 = json.loads(d2)
+        h3 = json.loads(d3)
+        h4 = json.loads(d4)
+
+        self.assertEqual(h1, h)
+        self.assertEqual(h2, h)
+        self.assertEqual(h3, h)
+        self.assertEqual(h4, h)
+        self.assertEqual(d3, expect.replace('\t', '  '))
+        self.assertEqual(d4, expect.replace('\t', '  '))
+        # NOTE: Python 2.4 textwrap.dedent converts tabs to spaces,
+        #       so the following is expected to fail. Python 2.4 is not a
+        #       supported platform in hjson 2.1.0+.
+        self.assertEqual(d2, expect)
+
+    def test_indent0(self):
+        h = {3: 1}
+        def check(indent, expected):
+            d1 = json.dumpsJSON(h, indent=indent)
+            self.assertEqual(d1, expected)
+
+            sio = StringIO()
+            json.dumpJSON(h, sio, indent=indent)
+            self.assertEqual(sio.getvalue(), expected)
+
+        # indent=0 should emit newlines
+        check(0, '{\n"3": 1\n}')
+        # indent=None is more compact
+        check(None, '{"3": 1}')
+
+    def test_separators(self):
+        lst = [1,2,3,4]
+        expect = '[\n1,\n2,\n3,\n4\n]'
+        expect_spaces = '[\n1, \n2, \n3, \n4\n]'
+        # Ensure that separators still works
+        self.assertEqual(
+            expect_spaces,
+            json.dumpsJSON(lst, indent=0, separators=(', ', ': ')))
+        # Force the new defaults
+        self.assertEqual(
+            expect,
+            json.dumpsJSON(lst, indent=0, separators=(',', ': ')))
+        # Added in 2.1.4
+        self.assertEqual(
+            expect,
+            json.dumpsJSON(lst, indent=0))