Merge branch 'typing_support' into main

Author: themarpe

CMakeLists.txt

@@ -29,7 +29,7 @@ endif()
 
 # Pybindings project
 set(TARGET_NAME depthai)
-project(depthai VERSION "0") # revision of bindings [depthai-core].[rev]
+project(depthai VERSION "1") # revision of bindings [depthai-core].[rev]
 
 # Set default build type depending on context
 set(default_build_type "Release")

pyproject.toml

@@ -1,2 +1,2 @@
 [build-system]
-requires = ["setuptools", "wheel"] # Must be preinstalled "cmake>=3.2.0"
+requires = ["setuptools", "wheel", "mypy"] # Must be preinstalled "cmake>=3.2.0"

setup.py

@@ -11,6 +11,8 @@
 from setuptools.command.build_ext import build_ext
 from distutils.version import LooseVersion
 
+### NAME
+MODULE_NAME = 'depthai'
 
 ### VERSION
 here = os.path.abspath(os.path.dirname(__file__))
@@ -171,10 +173,35 @@ def build_extension(self, ext):
         subprocess.check_call(['cmake', ext.sourcedir] + cmake_args, cwd=self.build_temp, env=env)
         subprocess.check_call(['cmake', '--build', '.'] + build_args, cwd=self.build_temp)
 
+        # Create stubs, add PYTHONPATH to find the build module
+        # CWD to to extdir where the built module can be found to extract the types
+        subprocess.check_call(['stubgen', '-p', MODULE_NAME, '-o', f'{extdir}'], cwd=extdir)
+
+        # Add py.typed
+        open(f'{extdir}/depthai/py.typed', 'a').close()
+
+        # imports and overloads
+        with open(f'{extdir}/depthai/__init__.pyi' ,'r+') as file:
+            # Read
+            contents = file.read()
+
+            # Add imports
+            stubs_import = 'import depthai.node as node\nimport typing\nimport json\n' + contents
+            # Create 'create' overloads
+            nodes = re.findall('def \S*\(self\) -> node.(\S*):', stubs_import)
+            overloads = ''
+            for node in nodes:
+                overloads = overloads + f'\\1@overload\\1def create(self, arg0: typing.Type[node.{node}]) -> node.{node}: ...'
+            print(f'{overloads}')
+            final_stubs = re.sub(r"([\s]*)def create\(self, arg0: object\) -> Node: ...", f'{overloads}', stubs_import)
+
+            # Writeout changes
+            file.seek(0)
+            file.write(final_stubs)
 
 
 setup(
-    name='depthai',
+    name=MODULE_NAME,
     version=__version__,
     author='Luxonis',
     author_email='[email protected]',
@@ -183,7 +210,7 @@ def build_extension(self, ext):
     long_description=long_description,
     long_description_content_type="text/markdown",
     url="https://github.com/luxonis/depthai-python",
-    ext_modules=[CMakeExtension('depthai')],
+    ext_modules=[CMakeExtension(MODULE_NAME)],
     cmdclass={
         'build_ext': CMakeBuild
     },

src/DeviceBindings.cpp

@@ -212,7 +212,7 @@ void DeviceBindings::bind(pybind11::module& m, void* pCallstack){
     // Bind the rest
     deviceBase
         // Python only methods
-        .def("__enter__", [](py::object obj){ return obj; })
+        .def("__enter__", [](DeviceBase& d) -> DeviceBase& { return d; })
         .def("__exit__", [](DeviceBase& d, py::object type, py::object value, py::object traceback) {
             py::gil_scoped_release release;
             d.close();

src/DeviceBootloaderBindings.cpp

@@ -110,14 +110,14 @@ void DeviceBootloaderBindings::bind(pybind11::module& m, void* pCallstack){
 
     deviceBootloader
       // Python only methods
-        .def("__enter__", [](py::object obj){ return obj; })
+        .def("__enter__", [](DeviceBootloader& d) -> DeviceBootloader& { return d; })
         .def("__exit__", [](DeviceBootloader& bl, py::object type, py::object value, py::object traceback) { bl.close(); })
         .def("close", &DeviceBootloader::close, "Closes the connection to device. Better alternative is the usage of context manager: `with depthai.DeviceBootloader(deviceInfo) as bootloader:`")
 
         .def_static("getFirstAvailableDevice", &DeviceBootloader::getFirstAvailableDevice, DOC(dai, DeviceBootloader, getFirstAvailableDevice))
         .def_static("getAllAvailableDevices", &DeviceBootloader::getAllAvailableDevices, DOC(dai, DeviceBootloader, getAllAvailableDevices))
         .def_static("saveDepthaiApplicationPackage", py::overload_cast<std::string, const Pipeline&, std::string, bool>(&DeviceBootloader::saveDepthaiApplicationPackage), py::arg("path"), py::arg("pipeline"), py::arg("pathToCmd") = "", py::arg("compress") = false, DOC(dai, DeviceBootloader, saveDepthaiApplicationPackage))
-        .def_static("saveDepthaiApplicationPackage", py::overload_cast<std::string, const Pipeline&, bool>(&DeviceBootloader::saveDepthaiApplicationPackage), py::arg("path"), py::arg("pipeline"), py::arg("compress") = false, DOC(dai, DeviceBootloader, saveDepthaiApplicationPackage, 2))
+        .def_static("saveDepthaiApplicationPackage", py::overload_cast<std::string, const Pipeline&, bool>(&DeviceBootloader::saveDepthaiApplicationPackage), py::arg("path"), py::arg("pipeline"), py::arg("compress"), DOC(dai, DeviceBootloader, saveDepthaiApplicationPackage, 2))
         .def_static("createDepthaiApplicationPackage", py::overload_cast<const Pipeline&, std::string, bool>(&DeviceBootloader::createDepthaiApplicationPackage), py::arg("pipeline"), py::arg("pathToCmd") = "", py::arg("compress") = false, DOC(dai, DeviceBootloader, createDepthaiApplicationPackage))
         .def_static("createDepthaiApplicationPackage", py::overload_cast<const Pipeline&, bool>(&DeviceBootloader::createDepthaiApplicationPackage), py::arg("pipeline"), py::arg("compress"), DOC(dai, DeviceBootloader, createDepthaiApplicationPackage, 2))
         .def_static("getEmbeddedBootloaderVersion", &DeviceBootloader::getEmbeddedBootloaderVersion, DOC(dai, DeviceBootloader, getEmbeddedBootloaderVersion))

src/pipeline/CommonBindings.cpp

@@ -13,6 +13,7 @@
 #include "depthai-shared/common/Point3f.hpp"
 #include "depthai-shared/common/Size2f.hpp"
 #include "depthai-shared/common/UsbSpeed.hpp"
+#include "depthai-shared/common/DetectionNetworkType.hpp"
 
 void CommonBindings::bind(pybind11::module& m, void* pCallstack){
 
@@ -34,6 +35,7 @@ void CommonBindings::bind(pybind11::module& m, void* pCallstack){
     py::class_<EepromData> eepromData(m, "EepromData", DOC(dai, EepromData));
     py::enum_<UsbSpeed> usbSpeed(m, "UsbSpeed", DOC(dai, UsbSpeed));
     py::enum_<ProcessorType> processorType(m, "ProcessorType");
+    py::enum_<DetectionNetworkType> detectionNetworkType(m, "DetectionNetworkType");
 
 
     ///////////////////////////////////////////////////////////////////////
@@ -184,4 +186,8 @@ void CommonBindings::bind(pybind11::module& m, void* pCallstack){
         .value("LEON_MSS", ProcessorType::LEON_MSS)
     ;
 
+    detectionNetworkType
+        .value("YOLO", DetectionNetworkType::YOLO)
+        .value("MOBILENET", DetectionNetworkType::MOBILENET)
+    ;
 }

src/pipeline/NodeBindings.cpp

@@ -479,18 +479,18 @@ void NodeBindings::bind(pybind11::module& m, void* pCallstack){
         .value("SSender", Node::Output::Type::SSender)
     ;
     pyOutput
-        .def("canConnect", &Node::Output::canConnect, py::arg("in"), DOC(dai, Node, Output, canConnect))
-        .def("link", &Node::Output::link, py::arg("in"), DOC(dai, Node, Output, link))
-        .def("unlink", &Node::Output::unlink, py::arg("in"), DOC(dai, Node, Output, unlink))
+        .def("canConnect", &Node::Output::canConnect, py::arg("input"), DOC(dai, Node, Output, canConnect))
+        .def("link", &Node::Output::link, py::arg("input"), DOC(dai, Node, Output, link))
+        .def("unlink", &Node::Output::unlink, py::arg("input"), DOC(dai, Node, Output, unlink))
         .def("getConnections", &Node::Output::getConnections, DOC(dai, Node, Output, getConnections))
     ;
 
 
     nodeConnection
-        .def_property("outputId", [](Node::Connection& conn) { return conn.outputId; }, [](Node::Connection& conn, Node::Id id) {conn.outputId = id; }, DOC(dai, Node, Connection, outputId))
-        .def_property("outputName", [](Node::Connection& conn) { return conn.outputName; }, [](Node::Connection& conn, std::string name) {conn.outputName = name; }, DOC(dai, Node, Connection, outputName))
-        .def_property("inputId", [](Node::Connection& conn) { return conn.inputId; }, [](Node::Connection& conn, Node::Id id) {conn.inputId = id; }, DOC(dai, Node, Connection, inputId))
-        .def_property("inputName", [](Node::Connection& conn) { return conn.inputName; }, [](Node::Connection& conn, std::string name) {conn.inputName = name; }, DOC(dai, Node, Connection, inputName))
+        .def_property("outputId", [](Node::Connection& conn) -> Node::Id& { return conn.outputId; }, [](Node::Connection& conn, Node::Id id) {conn.outputId = id; }, DOC(dai, Node, Connection, outputId))
+        .def_property("outputName", [](Node::Connection& conn) -> std::string& { return conn.outputName; }, [](Node::Connection& conn, std::string name) {conn.outputName = name; }, DOC(dai, Node, Connection, outputName))
+        .def_property("inputId", [](Node::Connection& conn) -> Node::Id& { return conn.inputId; }, [](Node::Connection& conn, Node::Id id) {conn.inputId = id; }, DOC(dai, Node, Connection, inputId))
+        .def_property("inputName", [](Node::Connection& conn) -> std::string& { return conn.inputName; }, [](Node::Connection& conn, std::string name) {conn.inputName = name; }, DOC(dai, Node, Connection, inputName))
     ;
 
     pyNode