functional python interop

.vscode/settings.json

@@ -1,5 +1,9 @@
 {
     "files.associations": {
         "ostream": "cpp"
-    }
+    },
+    "rust-analyzer.diagnostics.disabled": [
+        "macro-error",
+        "unresolved-macro-call",
+    ]
 }

odm/__main__.py

@@ -1,10 +1,15 @@
 import argparse
 import sys
+import logging
 import os
 
+FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'
+logging.basicConfig(format=FORMAT)
+logging.getLogger().setLevel(logging.DEBUG)
+
 # Load in libodm
-sys.path.append(os.getcwd() + "/target/debug/")
+sys.path.append(os.getcwd() + "/target/debug")
-import pylibodm
+import libpylibodm as pylibodm
 
 def main() -> int:
     # Handle program arguments

pylibodm/Cargo.toml

@@ -11,6 +11,7 @@ crate-type = ["cdylib"]
 
 [dependencies]
 libodm = { version = "0.1.0", path = "../libodm"}
+pyo3-log = "0.3.1"
 
 [dependencies.pyo3]
 version = "0.13.2"

pylibodm/src/lib.rs

@@ -2,32 +2,28 @@ use libodm::leapmotion::device::LeapMotionDevice;
 
 pub(crate) static mut DEVICE_INSTANCE: Option<LeapMotionDevice> = None;
 
-mod errors {
+use libodm::leapmotion::device::DeviceError;
-    use libodm::leapmotion::device::DeviceError;
+use pyo3::{exceptions::PyOSError, prelude::*};
-    use pyo3::{exceptions::PyOSError, prelude::*};
 
-    #[derive(Debug)]
+#[derive(Debug)]
-    pub struct PyDeviceError(DeviceError);
+pub struct PyDeviceError(DeviceError);
 
-    impl From<DeviceError> for PyDeviceError {
+impl From<DeviceError> for PyDeviceError {
-        fn from(e: DeviceError) -> Self {
+    fn from(e: DeviceError) -> Self {
-            Self { 0: e }
+        Self { 0: e }
-        }
     }
+}
 
-    impl std::convert::From<PyDeviceError> for PyErr {
+impl std::convert::From<PyDeviceError> for PyErr {
-        fn from(err: PyDeviceError) -> PyErr {
+    fn from(err: PyDeviceError) -> PyErr {
-            PyOSError::new_err(format!("{:?}", err.0))
+        PyOSError::new_err(format!("{:?}", err.0))
-        }
     }
 }
 
 use std::time::Duration;
 
 use libodm::{image::Image, leapmotion::device::DeviceFrame};
-use pyo3::prelude::*;
+use pyo3::wrap_pyfunction;
-
-use crate::errors::PyDeviceError;
 
 #[pyclass]
 struct PyImage {
@@ -63,47 +59,52 @@ impl IntoPy<PyDeviceFrame> for DeviceFrame<'_> {
     }
 }
 
-#[pymodule]
+#[pyfunction]
-pub fn pylibodm(py: Python, m: &PyModule) -> PyResult<()> {
+fn connect(timeout_secs: u64) -> Result<(), PyDeviceError> {
-    #[pyfn(m, "connect")]
+    // Create a leap device
-    fn connect(timeout_secs: u64) -> Result<(), PyDeviceError> {
+    let device = LeapMotionDevice::create_device(Duration::from_secs(timeout_secs))?;
-        // Create a leap device
-        let device = LeapMotionDevice::create_device(Duration::from_secs(timeout_secs))?;
 
-        // Override the instance
+    // Override the instance
-        unsafe {
+    unsafe {
-            DEVICE_INSTANCE = Some(device);
+        DEVICE_INSTANCE = Some(device);
-        }
-
-        Ok(())
-    }
-
-    #[pyfn(m, "set_cameras_flipped")]
-    fn set_cameras_flipped(flipped: bool) -> PyResult<()> {
-        unsafe {
-            DEVICE_INSTANCE
-                .as_mut()
-                .unwrap()
-                .set_cameras_flipped(flipped);
-        }
-
-        Ok(())
-    }
-
-    #[pyfn(m, "get_cameras_flipped")]
-    fn get_cameras_flipped() -> PyResult<bool> {
-        Ok(unsafe { DEVICE_INSTANCE.as_ref().unwrap().cameras_flipped() })
-    }
-
-    #[pyfn(m, "has_frame")]
-    fn has_frame() -> PyResult<bool> {
-        Ok(unsafe { DEVICE_INSTANCE.as_mut().unwrap().has_frame() })
-    }
-
-    #[pyfn(m, "get_frame")]
-    fn get_frame(py: Python) -> Result<PyDeviceFrame, PyDeviceError> {
-        Ok(unsafe { DEVICE_INSTANCE.as_mut().unwrap().get_frame()?.into_py(py) })
     }
 
     Ok(())
 }
+
+#[pyfunction]
+fn set_cameras_flipped(flipped: bool) {
+    unsafe {
+        DEVICE_INSTANCE
+            .as_mut()
+            .unwrap()
+            .set_cameras_flipped(flipped);
+    }
+}
+
+#[pyfunction]
+fn get_cameras_flipped() -> bool {
+    unsafe { DEVICE_INSTANCE.as_ref().unwrap().cameras_flipped() }
+}
+
+#[pyfunction]
+fn has_frame() -> bool {
+    unsafe { DEVICE_INSTANCE.as_mut().unwrap().has_frame() }
+}
+
+#[pyfunction]
+fn get_frame(py: Python) -> Result<PyDeviceFrame, PyDeviceError> {
+    Ok(unsafe { DEVICE_INSTANCE.as_mut().unwrap().get_frame()?.into_py(py) })
+}
+
+/// Python wrapper for libodm
+#[pymodule]
+fn libpylibodm(py: Python<'_>, m: &PyModule) -> PyResult<()> {
+    pyo3_log::init();
+    m.add_function(wrap_pyfunction!(get_frame, m)?)?;
+    m.add_function(wrap_pyfunction!(has_frame, m)?)?;
+    m.add_function(wrap_pyfunction!(get_cameras_flipped, m)?)?;
+    m.add_function(wrap_pyfunction!(set_cameras_flipped, m)?)?;
+    m.add_function(wrap_pyfunction!(connect, m)?)?;
+    Ok(())
+}

pyproject.toml

@@ -0,0 +1,2 @@
+[build-system]
+requires = ["setuptools>=41.0.0", "wheel", "setuptools_rust>=0.10.2"]

scripts/odm.sh

@@ -0,0 +1,13 @@
+#! /bin/bash
+# This is a small wrapper script to handle configuring your library path before executing ODM
+
+set -e
+
+echo "Enabling core dumps"
+ulimit -c unlimited
+
+echo "Building deps"
+cargo build
+
+echo "Starting python with new flags"
+LD_LIBRARY_PATH="$(pwd)/libodm/dist:$LD_LIBRARY_PATH" python3 odm $@

setup.py

@@ -4,7 +4,7 @@ from setuptools_rust import RustExtension
 
 setup(
     name="odm",
-    version="0.1.0",
+    version="0.1.1",
     classifiers=[
         "Development Status :: 3 - Alpha",
         "Intended Audience :: Developers",