robotpy-cscore 2023.4.3.0__cp39-cp39-win_amd64.whl → 2024.0.0b2.post1__cp39-cp39-win_amd64.whl

cscore/cvnp/cvnp.cpp

@@ -64,6 +64,20 @@ namespace cvnp
             };
         }
 
+        std::vector<std::size_t> determine_strides(const cv::Mat& m) {
+            if (m.channels() == 1) {
+                return {
+                    static_cast<size_t>(m.step[0]), // row stride (in bytes)
+                    static_cast<size_t>(m.step[1])  // column stride (in bytes)
+                };
+            }
+            return {
+                static_cast<size_t>(m.step[0]), // row stride (in bytes)
+                static_cast<size_t>(m.step[1]), // column stride (in bytes)
+                static_cast<size_t>(m.elemSize1()) // channel stride (in bytes)
+            };
+        }
+ 
         py::capsule make_capsule_mat(const cv::Mat& m)
         {
             return py::capsule(new cv::Mat(m)
@@ -74,22 +88,14 @@ namespace cvnp
 
     } // namespace detail
 
-    pybind11::array mat_to_nparray(const cv::Mat& m, bool share_memory)
+    pybind11::array mat_to_nparray(const cv::Mat& m)
     {
-        // note: empty mats aren't continuous
-        if (!m.isContinuous() && !m.empty())
-            throw std::invalid_argument("cvnp::mat_to_nparray / Only contiguous Mats supported / You can clone() your matrix to obtain a contiguous copy.");
-        if (share_memory)
-            return pybind11::array(detail::determine_np_dtype(m.depth())
-                , detail::determine_shape(m)
-                , m.data
-                , detail::make_capsule_mat(m)
-                );
-        else
-            return pybind11::array(detail::determine_np_dtype(m.depth())
-                , detail::determine_shape(m)
-                , m.data
-                );
+        return pybind11::array(detail::determine_np_dtype(m.depth())
+            , detail::determine_shape(m)
+            , detail::determine_strides(m)
+            , m.data
+            , detail::make_capsule_mat(m)
+            );
     }
 
 
@@ -124,4 +130,36 @@ namespace cvnp
         return m;
     }
 
+    // this version tries to handles strides and submatrices
+    // this is WIP, currently broken, and not used
+    cv::Mat nparray_to_mat_with_strides_broken(pybind11::array& a)
+    {
+        int depth = detail::determine_cv_depth(a.dtype());
+        int type = detail::determine_cv_type(a, depth);
+        cv::Size size = detail::determine_cv_size(a);
+
+        auto buffer_info = a.request();
+
+        // Get the array strides (convert from pybind11::ssize_t to size_t)
+        std::vector<size_t> strides;
+        for (auto v : buffer_info.strides)
+            strides.push_back(static_cast<size_t>(v));
+
+        // Get the number of dimensions
+        int ndims = static_cast<int>(buffer_info.ndim);
+        //if ((ndims != 2) && (ndims != 3))
+        //    throw std::invalid_argument("nparray_to_mat needs support only 2 or 3 dimension matrices");
+
+        // Convert the shape (sizes) to a vector of int
+        std::vector<int> sizes;
+        for (auto v : buffer_info.shape)
+            sizes.push_back(static_cast<int>(v));
+
+        // Create the cv::Mat with the specified strides (steps)
+        // We are calling this Mat constructor:
+        //     Mat(const std::vector<int>& sizes, int type, void* data, const size_t* steps=0)
+        cv::Mat m(sizes, type, a.mutable_data(0), strides.data());
+        return m;
+    }
+
 } // namespace cvnp

cscore/cvnp/cvnp.h

@@ -1,6 +1,5 @@
 #pragma once
 #include "cvnp/cvnp_synonyms.h"
-#include "cvnp/cvnp_shared_mat.h"
 
 #include <opencv2/core/core.hpp>
 #include <pybind11/numpy.h>
@@ -18,12 +17,15 @@ namespace cvnp
     //
     // Public interface
     //
-    pybind11::array mat_to_nparray(const cv::Mat& m, bool share_memory);
+
+    // For cv::Mat (*with* shared memory)
+    pybind11::array mat_to_nparray(const cv::Mat& m);
     cv::Mat         nparray_to_mat(pybind11::array& a);
 
-        template<typename _Tp, int _rows, int _cols>
-    pybind11::array matx_to_nparray(const cv::Matx<_Tp, _rows, _cols>& m, bool share_memory);
-        template<typename _Tp, int _rows, int _cols>
+    // For cv::Matx (*without* shared memory)
+    template<typename _Tp, int _rows, int _cols>
+    pybind11::array matx_to_nparray(const cv::Matx<_Tp, _rows, _cols>& m);
+    template<typename _Tp, int _rows, int _cols>
     void            nparray_to_matx(pybind11::array &a, cv::Matx<_Tp, _rows, _cols>& out_matrix);
 
 
@@ -42,21 +44,13 @@ namespace cvnp
     } // namespace detail
 
     template<typename _Tp, int _rows, int _cols>
-    pybind11::array matx_to_nparray(const cv::Matx<_Tp, _rows, _cols>& m, bool share_memory)
+    pybind11::array matx_to_nparray(const cv::Matx<_Tp, _rows, _cols>& m)
     {
-        if (share_memory)
-            return pybind11::array(
-                pybind11::dtype::of<_Tp>()
-                , std::vector<std::size_t> {_rows, _cols}
-                , m.val
-                , detail::make_capsule_matx<_Tp, _rows, _cols>(m)
-                );
-        else
-            return pybind11::array(
-                pybind11::dtype::of<_Tp>()
-                , std::vector<std::size_t> {_rows, _cols}
-                , m.val
-            );
+        return pybind11::array(
+            pybind11::dtype::of<_Tp>()
+            , std::vector<std::size_t> {_rows, _cols}
+            , m.val
+        );
     }
 
     template<typename _Tp, int _rows, int _cols>
@@ -84,18 +78,16 @@ namespace pybind11
     namespace detail
     {
         //
-        // Cast between cvnp::Mat_shared and numpy.ndarray
+        // Cast between cv::Mat and numpy.ndarray
         // The cast between cv::Mat and numpy.ndarray works
         //   - *with* shared memory when going from C++ to Python
         //   - *with* shared memory when going from Python to C++
-        //   any modification to the Matrix size, type, and values is immediately
-        //   impacted on both sides.
-        //
+        //   any modification to the Matrix size, type, and values is immediately impacted on both sides.
         template<>
-        struct type_caster<cvnp::Mat_shared>
+        struct type_caster<cv::Mat>
         {
         public:
-        PYBIND11_TYPE_CASTER(cvnp::Mat_shared, _("numpy.ndarray"));
+        PYBIND11_TYPE_CASTER(cv::Mat, _("numpy.ndarray"));
 
             /**
              * Conversion part 1 (Python->C++):
@@ -104,12 +96,12 @@ namespace pybind11
              */
             bool load(handle src, bool)
             {
-                if (!isinstance<array>(src)) {
+                if (!isinstance<array>(src))
                     return false;
-                }
+
                 auto a = reinterpret_borrow<array>(src);
-                auto new_mat = cv::Mat(cvnp::nparray_to_mat(a));
-                value.Value = new_mat;
+                auto new_mat = cvnp::nparray_to_mat(a);
+                value = new_mat;
                 return true;
             }
 
@@ -119,25 +111,25 @@ namespace pybind11
              * (for ``return_value_policy::reference_internal``) and are generally
              * ignored by implicit casters.
              */
-            static handle cast(const cvnp::Mat_shared &m, return_value_policy, handle defval)
+            static handle cast(const cv::Mat &m, return_value_policy, handle defval)
             {
-                auto a = cvnp::mat_to_nparray(m.Value, true);
+                auto a = cvnp::mat_to_nparray(m);
                 return a.release();
             }
         };
 
-
         //
-        // Cast between cv::Mat and numpy.ndarray
-        // The cast between cv::Mat and numpy.ndarray works *without* shared memory.
-        //   - *without* shared memory when going from C++ to Python
+        // Cast between cv::Mat_ and numpy.ndarray
+        // The cast between cv::Mat_ and numpy.ndarray works
+        //   - *with* shared memory when going from C++ to Python
         //   - *with* shared memory when going from Python to C++
-        //
-        template<>
-        struct type_caster<cv::Mat>
+        //   any modification to the Matrix size, type, and values is immediately impacted on both sides.
+        template<typename _Tp>
+        struct type_caster<cv::Mat_<_Tp>>
         {
+            using MatTp = cv::Mat_<_Tp>;
         public:
-        PYBIND11_TYPE_CASTER(cv::Mat, _("numpy.ndarray"));
+        PYBIND11_TYPE_CASTER(MatTp, _("numpy.ndarray"));
 
             /**
              * Conversion part 1 (Python->C++):
@@ -146,9 +138,9 @@ namespace pybind11
              */
             bool load(handle src, bool)
             {
-                if (!isinstance<array>(src)) {
+                if (!isinstance<array>(src))
                     return false;
-                }
+
                 auto a = reinterpret_borrow<array>(src);
                 auto new_mat = cvnp::nparray_to_mat(a);
                 value = new_mat;
@@ -161,87 +153,75 @@ namespace pybind11
              * (for ``return_value_policy::reference_internal``) and are generally
              * ignored by implicit casters.
              */
-            static handle cast(const cv::Mat &m, return_value_policy, handle defval)
+            static handle cast(const MatTp &m, return_value_policy, handle defval)
             {
-                auto a = cvnp::mat_to_nparray(m, false);
+                auto a = cvnp::mat_to_nparray(m);
                 return a.release();
             }
         };
 
 
-        //
-        // Cast between cvnp::Matx_shared<_rows,_cols> (aka Matx33d, Matx21d, etc) + Vec<_rows> (aka Vec1d, Vec2f, etc) and numpy.ndarray
-        // The cast between cvnp::Matx_shared, cvnp::Vec_shared and numpy.ndarray works *with* shared memory:
-        //   any modification to the Matrix size, type, and values is immediately
-        //   impacted on both sides.
-        //   - *with* shared memory when going from C++ to Python
-        //   - *with* shared memory when going from Python to C++
-        //
+
+        // Cast between cv::Matx<_rows,_cols> (aka Matx33d, Matx21d, etc) and numpy.ndarray
+        // *without* shared memory.
         template<typename _Tp, int _rows, int _cols>
-        struct type_caster<cvnp::Matx_shared<_Tp, _rows, _cols> >
+        struct type_caster<cv::Matx<_Tp, _rows, _cols> >
         {
-            using Matshared_xxx = cvnp::Matx_shared<_Tp, _rows, _cols>;
+            using Matxxx = cv::Matx<_Tp, _rows, _cols>;
 
         public:
-        PYBIND11_TYPE_CASTER(Matshared_xxx, _("numpy.ndarray"));
+        PYBIND11_TYPE_CASTER(Matxxx, _("numpy.ndarray"));
 
             // Conversion part 1 (Python->C++)
             bool load(handle src, bool)
             {
-                if (!isinstance<array>(src)) {
+                if (!isinstance<array>(src))
                     return false;
-                }
 
                 auto a = reinterpret_borrow<array>(src);
-                cvnp::nparray_to_matx<_Tp, _rows, _cols>(a, value.Value);
+                cvnp::nparray_to_matx<_Tp, _rows, _cols>(a, value);
                 return true;
             }
 
             // Conversion part 2 (C++ -> Python)
-            static handle cast(const Matshared_xxx &m, return_value_policy, handle defval)
+            static handle cast(const Matxxx &m, return_value_policy, handle defval)
             {
-                auto a = cvnp::matx_to_nparray<_Tp, _rows, _cols>(m.Value, true);
+                auto a = cvnp::matx_to_nparray<_Tp, _rows, _cols>(m);
                 return a.release();
             }
         };
 
 
-        //
-        // Cast between cv::Matx<_rows,_cols> (aka Matx33d, Matx21d, etc) + Vec<_rows> (aka Vec1d, Vec2f, etc) and numpy.ndarray
-        // The cast between cv::Matx, cv::Vec and numpy.ndarray works *without* shared memory.
-        //   - *without* shared memory when going from C++ to Python
-        //   - *with* shared memory when going from Python to C++
-        //
-        template<typename _Tp, int _rows, int _cols>
-        struct type_caster<cv::Matx<_Tp, _rows, _cols> >
+        // Cast between cv::Vec<_rows> and numpy.ndarray
+        // *without* shared memory.
+        template<typename _Tp, int _rows>
+        struct type_caster<cv::Vec<_Tp, _rows> >
         {
-            using Matxxx = cv::Matx<_Tp, _rows, _cols>;
+            using Vecxxx = cv::Vec<_Tp, _rows>;
 
         public:
-        PYBIND11_TYPE_CASTER(Matxxx, _("numpy.ndarray"));
+        PYBIND11_TYPE_CASTER(Vecxxx, _("numpy.ndarray"));
 
             // Conversion part 1 (Python->C++)
             bool load(handle src, bool)
             {
-                if (!isinstance<array>(src)) {
+                if (!isinstance<array>(src))
                     return false;
-                }
 
                 auto a = reinterpret_borrow<array>(src);
-                cvnp::nparray_to_matx<_Tp, _rows, _cols>(a, value);
+                cvnp::nparray_to_matx<_Tp, _rows, 1>(a, value);
                 return true;
             }
 
             // Conversion part 2 (C++ -> Python)
-            static handle cast(const Matxxx &m, return_value_policy, handle defval)
+            static handle cast(const Vecxxx &m, return_value_policy, handle defval)
             {
-                auto a = cvnp::matx_to_nparray<_Tp, _rows, _cols>(m, false);
+                auto a = cvnp::matx_to_nparray<_Tp, _rows, 1>(m);
                 return a.release();
             }
         };
 
 
-
         //
         // Cast between cv::Size and a simple python tuple.
         // No shared memory, you cannot modify the width or the height without
@@ -258,9 +238,8 @@ namespace pybind11
             // Conversion part 1 (Python->C++, i.e tuple -> Size)
             bool load(handle src, bool)
             {
-                if (!isinstance<pybind11::tuple>(src)) {
+                if (!isinstance<pybind11::tuple>(src))
                     return false;
-                }
 
                 auto tuple = pybind11::reinterpret_borrow<pybind11::tuple>(src);
                 if (tuple.size() != 2)
@@ -299,9 +278,8 @@ namespace pybind11
             // Conversion part 1 (Python->C++)
             bool load(handle src, bool)
             {
-                if (!isinstance<pybind11::tuple>(src)) {
+                if (!isinstance<pybind11::tuple>(src))
                     return false;
-                }
 
                 auto tuple = pybind11::reinterpret_borrow<pybind11::tuple>(src);
                 if (tuple.size() != 2)
@@ -324,7 +302,6 @@ namespace pybind11
         };
 
 
-
         //
         // Point3
         // No shared memory
@@ -340,9 +317,8 @@ namespace pybind11
             // Conversion part 1 (Python->C++)
             bool load(handle src, bool)
             {
-                if (!isinstance<pybind11::tuple>(src)) {
+                if (!isinstance<pybind11::tuple>(src))
                     return false;
-                }
 
                 auto tuple = pybind11::reinterpret_borrow<pybind11::tuple>(src);
                 if (tuple.size() != 3)
@@ -365,6 +341,92 @@ namespace pybind11
             }
         };
 
+        //
+        // Scalar
+        // No shared memory
+        //
+        template<typename _Tp>
+        struct type_caster<cv::Scalar_<_Tp>>
+        {
+            using ScalarTp = cv::Scalar_<_Tp>;
+
+        public:
+        PYBIND11_TYPE_CASTER(ScalarTp , _("tuple"));
+
+            // Conversion part 1 (Python->C++)
+            bool load(handle src, bool)
+            {
+                if (!isinstance<pybind11::tuple>(src))
+                    return false;
+
+                auto tuple = pybind11::reinterpret_borrow<pybind11::tuple>(src);
+                const auto tupleSize = tuple.size();
+                if (tupleSize > 4)
+                    throw std::invalid_argument("Scalar should be a tuple with at most 4 elements. Got " + std::to_string(tupleSize));
+
+                ScalarTp r;
+                if (tupleSize == 1)
+                    r = ScalarTp(tuple[0].cast<_Tp>());
+                else if (tupleSize == 2)
+                    r = ScalarTp(tuple[0].cast<_Tp>(), tuple[1].cast<_Tp>());
+                else if (tupleSize == 3)
+                    r = ScalarTp(tuple[0].cast<_Tp>(), tuple[1].cast<_Tp>(), tuple[2].cast<_Tp>());
+                else if (tupleSize == 4)
+                    r = ScalarTp(tuple[0].cast<_Tp>(), tuple[1].cast<_Tp>(), tuple[2].cast<_Tp>(), tuple[3].cast<_Tp>());
+
+                value = r;
+                return true;
+            }
+
+            // Conversion part 2 (C++ -> Python)
+            static handle cast(const ScalarTp &value, return_value_policy, handle defval)
+            {
+                auto result = pybind11::make_tuple(value[0], value[1], value[2], value[3]);
+                return result.release();
+            }
+        };
+
+        //
+        // Rect_
+        // No shared memory
+        //
+        template<typename _Tp>
+        struct type_caster<cv::Rect_<_Tp>>
+        {
+            using RectTp = cv::Rect_<_Tp>;
+
+        public:
+        PYBIND11_TYPE_CASTER(RectTp , _("tuple"));
+
+            // Conversion part 1 (Python->C++)
+            bool load(handle src, bool)
+            {
+                if (!isinstance<pybind11::tuple>(src))
+                    return false;
+
+                auto tuple = pybind11::reinterpret_borrow<pybind11::tuple>(src);
+                const auto tupleSize = tuple.size();
+                if (tupleSize != 4)
+                    throw std::invalid_argument("Rect should be a tuple with 4 elements. Got " + std::to_string(tupleSize));
+
+                RectTp r;
+                r.x = tuple[0].cast<_Tp>();
+                r.y = tuple[1].cast<_Tp>();
+                r.width = tuple[2].cast<_Tp>();
+                r.height = tuple[3].cast<_Tp>();
+
+                value = r;
+                return true;
+            }
+
+            // Conversion part 2 (C++ -> Python)
+            static handle cast(const RectTp &value, return_value_policy, handle defval)
+            {
+                auto result = pybind11::make_tuple(value.x, value.y, value.width, value.height);
+                return result.release();
+            }
+        };
+
 
     }  // namespace detail
 }  // namespace pybind11

cscore/version.py

@@ -1,4 +1,4 @@
 # file generated by setuptools_scm
 # don't change, don't track in version control
-__version__ = version = '2023.4.3.0'
-__version_tuple__ = version_tuple = (2023, 4, 3, 0)
+__version__ = version = '2024.0.0b2.post1'
+__version_tuple__ = version_tuple = (2024, 0, 0)

{robotpy_cscore-2023.4.3.0.dist-info → robotpy_cscore-2024.0.0b2.post1.dist-info}/METADATA

@@ -1,18 +1,18 @@
 Metadata-Version: 2.1
 Name: robotpy-cscore
-Version: 2023.4.3.0
+Version: 2024.0.0b2.post1
 Summary: RobotPy bindings for cscore image processing library
 Home-page: https://github.com/robotpy/robotpy-cscore
 Author: RobotPy Development Team
 Author-email: robotpy@googlegroups.com
 License: BSD-3-Clause
 Platform: UNKNOWN
-Requires-Python: >=3.6
+Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: robotpy-wpiutil (~=2023.4.3)
-Requires-Dist: robotpy-wpinet (~=2023.4.3)
-Requires-Dist: pyntcore (~=2023.4.3)
+Requires-Dist: robotpy-wpiutil ~=2024.0.0b2
+Requires-Dist: robotpy-wpinet ~=2024.0.0b2
+Requires-Dist: pyntcore ~=2024.0.0b2
 
 robotpy-cscore
 ==============

robotpy_cscore-2024.0.0b2.post1.dist-info/RECORD

@@ -0,0 +1,28 @@
+cscore/__init__.py,sha256=VaZBAeqPudG-P5ca41SS9q7UNjEyfAM08xaXba1Q-uk,1091
+cscore/__main__.py,sha256=JmC0gHCGkRWCrwjvp28hZlhr24b9Mol3lwlS1UF3Cls,4393
+cscore/_cscore.cp39-win_amd64.pyd,sha256=3eD7tdR_zWlhL24TzsDnWYpy0FKOcDYfl0RklbZYa0Q,3532800
+cscore/_cscore.pyi,sha256=YfRqCjW2j2zkz0_KqrBShq_tU7A4gzg79ZurM4ZTwpc,48747
+cscore/_init_cscore.py,sha256=IJoWfQi1FpW48Uez-o9vS8SVCArHlmCAGt1BZkmbZmY,267
+cscore/_logging.py,sha256=uv1Shlu49aPgQpRn5yD2ybT4N8ewJS3qUFOn8YTffwg,333
+cscore/grip.py,sha256=qC6MbWvVllpnnsm10f31gqq4_PMWI_G9GKt3PfOaUpo,1042
+cscore/imagewriter.py,sha256=RAWRRhL3DLNampZJjdd7Ye_8P1AmiYAZsWhnwov5id0,4537
+cscore/pkgcfg.py,sha256=nkuqOy-Oy0Kw0pi8YXX9KfQCviwNliFZZlSOi2slsiw,791
+cscore/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cscore/version.py,sha256=DanI4SMo27Ol-LhGJpo64n5wVW9DyAZH2keeQt7Zc-0,178
+cscore/__pycache__/__init__.cpython-39.pyc,sha256=oDK_BbvbCJDhWnnTZUkMIxihdor-tWY6NmHcj8ywEb4,986
+cscore/__pycache__/_init_cscore.cpython-39.pyc,sha256=m2va8AB-349tz4mWsw8DLtL9M4RtyCaLNdK6vWBoZmA,433
+cscore/__pycache__/_logging.cpython-39.pyc,sha256=OPou89jMZS-hiFjOgZ1_Tehsr6J9bl-NeHpcG-_XECQ,678
+cscore/__pycache__/version.cpython-39.pyc,sha256=dpN1C72aL76UKHnB-MIziLtnh7td6v0UTCk7-js6ung,294
+cscore/cvnp/README.md,sha256=197MQ-gG-pZf9YAUZqcHXLKk8au8WtxXrfFf7lnwHAo,1175
+cscore/cvnp/cvnp.cpp,sha256=Zo-8jL2qRbH9SG0605vQ0-I1NjQKRfVqLyV7YxJEfqU,6247
+cscore/cvnp/cvnp.h,sha256=4ymsVQgp8nOJqVazCtENVMgfTJ32M_j0ShfltPxL5aw,14852
+cscore/cvnp/cvnp_shared_mat.h,sha256=xNsaRqfhi_D4yxCZF55Or96MOTsLyg_Mn9gLeOPin88,3576
+cscore/cvnp/cvnp_synonyms.cpp,sha256=ZpLZzmK5ZcrIgLfi_j7eJ_NXLNtcb8ymDWehYuVVHvo,2419
+cscore/cvnp/cvnp_synonyms.h,sha256=MgU4yOOXMhGGLrKb06dX4nsQLtqkq_1gDE6ToR3mjFo,589
+cscore/src/main.cpp,sha256=H7WmA3wj-1pZduYdFBsrH1Ayfir4ur-bYsFhySe4Beo,532
+robotpy_cscore-2024.0.0b2.post1.dist-info/LICENSE,sha256=eday0nHMlO9Rc7a6n0ONgNEe6N20r5xNWivVL5n-fN4,3138
+robotpy_cscore-2024.0.0b2.post1.dist-info/METADATA,sha256=5M_-Arlp7YhEameDqqcOn-nIgZ_BQDig8LdjrSlNDoc,1128
+robotpy_cscore-2024.0.0b2.post1.dist-info/WHEEL,sha256=QEPhY-QL5bUCGe8xLO1ow2Nlf5beRmRJkZ8YmG0I2hM,100
+robotpy_cscore-2024.0.0b2.post1.dist-info/entry_points.txt,sha256=hFrjQmvJC8KIGhuinIdAazBPJW2oCe301Q9ZaIHVCe4,39
+robotpy_cscore-2024.0.0b2.post1.dist-info/top_level.txt,sha256=yKRnfRQe07G2XO6XXYgsj9CN2obAQX3D3gsGvcewpVw,7
+robotpy_cscore-2024.0.0b2.post1.dist-info/RECORD,,

{robotpy_cscore-2023.4.3.0.dist-info → robotpy_cscore-2024.0.0b2.post1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.40.0)
+Generator: bdist_wheel (0.41.3)
 Root-Is-Purelib: false
 Tag: cp39-cp39-win_amd64
 

robotpy_cscore-2023.4.3.0.dist-info/RECORD

@@ -1,28 +0,0 @@
-cscore/__init__.py,sha256=VaZBAeqPudG-P5ca41SS9q7UNjEyfAM08xaXba1Q-uk,1091
-cscore/__main__.py,sha256=JmC0gHCGkRWCrwjvp28hZlhr24b9Mol3lwlS1UF3Cls,4393
-cscore/_cscore.cp39-win_amd64.pyd,sha256=YKc7C6IlR4i8LhkYULbvcJWuJ-483ooaQWBpXq6wp4o,3401728
-cscore/_init_cscore.py,sha256=IJoWfQi1FpW48Uez-o9vS8SVCArHlmCAGt1BZkmbZmY,267
-cscore/_logging.py,sha256=uv1Shlu49aPgQpRn5yD2ybT4N8ewJS3qUFOn8YTffwg,333
-cscore/grip.py,sha256=qC6MbWvVllpnnsm10f31gqq4_PMWI_G9GKt3PfOaUpo,1042
-cscore/imagewriter.py,sha256=RAWRRhL3DLNampZJjdd7Ye_8P1AmiYAZsWhnwov5id0,4537
-cscore/pkgcfg.py,sha256=nkuqOy-Oy0Kw0pi8YXX9KfQCviwNliFZZlSOi2slsiw,791
-cscore/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cscore/version.py,sha256=aMmkAteYZjbJfZ43WF8Lt7EqRicJGj3mDI7c1j5iuWE,175
-cscore/__pycache__/__init__.cpython-39.pyc,sha256=6x_ii2F04-GsOvOGqb1DT8gjUb7UIEp9xn6rH6R65Xs,965
-cscore/__pycache__/_init_cscore.cpython-39.pyc,sha256=JuXD8m5B9YdvGQNHC8758i-4L8A8EpBHZZo5aW3aMew,412
-cscore/__pycache__/_logging.cpython-39.pyc,sha256=vw5VfPy5tnPwie--OQ8xbQBC0RU6i9pmbkDlkdRNha8,657
-cscore/__pycache__/version.cpython-39.pyc,sha256=1P-PvrwYjk4iL18_6067BkyUb9IrUmgDoG4swKUa2_Q,272
-cscore/_cscore/__init__.pyi,sha256=B17Jn5y05zBRErbjBkalwAAJLo-kw1bi7IoEQTGI340,47184
-cscore/cvnp/README.md,sha256=197MQ-gG-pZf9YAUZqcHXLKk8au8WtxXrfFf7lnwHAo,1175
-cscore/cvnp/cvnp.cpp,sha256=us_1aHeh63La0gXdmrxoBgZupmQknGCEapEbiwTgmzA,4719
-cscore/cvnp/cvnp.h,sha256=93ALp2KIgnLlyJpqlyASnRm81m3QEHQqv7w0RAqNyFE,12952
-cscore/cvnp/cvnp_shared_mat.h,sha256=xNsaRqfhi_D4yxCZF55Or96MOTsLyg_Mn9gLeOPin88,3576
-cscore/cvnp/cvnp_synonyms.cpp,sha256=ZpLZzmK5ZcrIgLfi_j7eJ_NXLNtcb8ymDWehYuVVHvo,2419
-cscore/cvnp/cvnp_synonyms.h,sha256=MgU4yOOXMhGGLrKb06dX4nsQLtqkq_1gDE6ToR3mjFo,589
-cscore/src/main.cpp,sha256=H7WmA3wj-1pZduYdFBsrH1Ayfir4ur-bYsFhySe4Beo,532
-robotpy_cscore-2023.4.3.0.dist-info/LICENSE,sha256=eday0nHMlO9Rc7a6n0ONgNEe6N20r5xNWivVL5n-fN4,3138
-robotpy_cscore-2023.4.3.0.dist-info/METADATA,sha256=W80tx5DX8EoNy5sXFEFt6TlhLJwxYOg6Jo48hFZrFT4,1122
-robotpy_cscore-2023.4.3.0.dist-info/WHEEL,sha256=eep6QWEFiQfg2wcclssb_WY-D33AnLYLnEKGA9Rn-VU,100
-robotpy_cscore-2023.4.3.0.dist-info/entry_points.txt,sha256=hFrjQmvJC8KIGhuinIdAazBPJW2oCe301Q9ZaIHVCe4,39
-robotpy_cscore-2023.4.3.0.dist-info/top_level.txt,sha256=yKRnfRQe07G2XO6XXYgsj9CN2obAQX3D3gsGvcewpVw,7
-robotpy_cscore-2023.4.3.0.dist-info/RECORD,,