simpleble 0.0.1

data/vendor/simpleble/simplepyble/src/wrap_adapter.cpp

@@ -0,0 +1,106 @@
+#include <pybind11/functional.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "simpleble/SimpleBLE.h"
+
+namespace py = pybind11;
+
+constexpr auto kDocsAdapter = R"pbdoc(
+    Adapter
+)pbdoc";
+
+constexpr auto kDocsAdapterBluetoothEnabled = R"pbdoc(
+    Whether Bluetooth is enabled
+)pbdoc";
+
+constexpr auto kDocsAdapterGetAdapters = R"pbdoc(
+    Get all available adapters
+)pbdoc";
+
+constexpr auto kDocsAdapterInitialized = R"pbdoc(
+    Whether the adapter is initialized
+)pbdoc";
+
+constexpr auto kDocsAdapterIdentifier = R"pbdoc(
+    Identifier of the adapter
+)pbdoc";
+
+constexpr auto kDocsAdapterAddress = R"pbdoc(
+    Address of the adapter
+)pbdoc";
+
+constexpr auto kDocsAdapterPowerOn = R"pbdoc(
+    Power on the adapter
+)pbdoc";
+
+constexpr auto kDocsAdapterPowerOff = R"pbdoc(
+    Power off the adapter
+)pbdoc";
+
+constexpr auto kDocsAdapterIsPowered = R"pbdoc(
+    Whether the adapter is powered
+)pbdoc";
+
+constexpr auto kDocsAdapterScanStart = R"pbdoc(
+    Start scanning for peripherals
+)pbdoc";
+
+constexpr auto kDocsAdapterScanStop = R"pbdoc(
+    Stop scanning for peripherals
+)pbdoc";
+
+constexpr auto kDocsAdapterScanIsActive = R"pbdoc(
+    Whether the adapter is scanning
+)pbdoc";
+
+constexpr auto kDocsAdapterScanFor = R"pbdoc(
+    Scan for peripherals for a given duration
+)pbdoc";
+
+constexpr auto kDocsAdapterScanGetResults = R"pbdoc(
+    Get the results of the last scan
+)pbdoc";
+
+constexpr auto kDocsAdapterSetCallbackOnScanStart = R"pbdoc(
+    Set the callback to be called when scanning starts
+)pbdoc";
+
+constexpr auto kDocsAdapterSetCallbackOnScanStop = R"pbdoc(
+    Set the callback to be called when scanning stops
+)pbdoc";
+
+constexpr auto kDocsAdapterSetCallbackOnScanFound = R"pbdoc(
+    Set the callback to be called when a peripheral is found
+)pbdoc";
+
+constexpr auto kDocsAdapterSetCallbackOnScanUpdated = R"pbdoc(
+    Set the callback to be called when a peripheral is updated
+)pbdoc";
+
+constexpr auto kDocsAdapterGetPairedPeripherals = R"pbdoc(
+    Get all paired peripherals
+)pbdoc";
+
+void wrap_adapter(py::module& m) {
+    // TODO: Add __str__ and __repr__ methods
+    py::class_<SimpleBLE::Adapter>(m, "Adapter")
+        .def("bluetooth_enabled", &SimpleBLE::Adapter::bluetooth_enabled, kDocsAdapterBluetoothEnabled)
+        .def("get_adapters", &SimpleBLE::Adapter::get_adapters, kDocsAdapterGetAdapters)
+        .def("initialized", &SimpleBLE::Adapter::initialized, kDocsAdapterInitialized)
+        .def("identifier", &SimpleBLE::Adapter::identifier, kDocsAdapterIdentifier)
+        .def("address", &SimpleBLE::Adapter::address, kDocsAdapterAddress)
+        .def("power_on", &SimpleBLE::Adapter::power_on, kDocsAdapterPowerOn)
+        .def("power_off", &SimpleBLE::Adapter::power_off, kDocsAdapterPowerOff)
+        .def("is_powered", &SimpleBLE::Adapter::is_powered, kDocsAdapterIsPowered)
+        .def("scan_start", &SimpleBLE::Adapter::scan_start, kDocsAdapterScanStart)
+        .def("scan_stop", &SimpleBLE::Adapter::scan_stop, kDocsAdapterScanStop)
+        .def("scan_is_active", &SimpleBLE::Adapter::scan_is_active, kDocsAdapterScanIsActive)
+        .def("scan_for", &SimpleBLE::Adapter::scan_for, py::call_guard<py::gil_scoped_release>(), kDocsAdapterScanFor)
+        .def("scan_get_results", &SimpleBLE::Adapter::scan_get_results, kDocsAdapterScanGetResults)
+        .def("set_callback_on_scan_start", &SimpleBLE::Adapter::set_callback_on_scan_start, py::keep_alive<1, 2>(), kDocsAdapterSetCallbackOnScanStart)
+        .def("set_callback_on_scan_stop", &SimpleBLE::Adapter::set_callback_on_scan_stop, py::keep_alive<1, 2>(), kDocsAdapterSetCallbackOnScanStop)
+        .def("set_callback_on_scan_found", &SimpleBLE::Adapter::set_callback_on_scan_found, py::keep_alive<1, 2>(), kDocsAdapterSetCallbackOnScanFound)
+        .def("set_callback_on_scan_updated", &SimpleBLE::Adapter::set_callback_on_scan_updated, py::keep_alive<1, 2>(), kDocsAdapterSetCallbackOnScanUpdated)
+        .def("get_paired_peripherals", &SimpleBLE::Adapter::get_paired_peripherals, kDocsAdapterGetPairedPeripherals);
+}

data/vendor/simpleble/simplepyble/src/wrap_characteristic.cpp

@@ -0,0 +1,56 @@
+#include <pybind11/functional.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "simpleble/Characteristic.h"
+
+namespace py = pybind11;
+
+constexpr auto kDocsCharacteristic = R"pbdoc(
+    Characteristic
+)pbdoc";
+
+constexpr auto kDocsCharacteristicUuid = R"pbdoc(
+    UUID of the characteristic
+)pbdoc";
+
+constexpr auto kDocsCharacteristicDescriptors = R"pbdoc(
+    Descriptors of the characteristic
+)pbdoc";
+
+constexpr auto kDocsCharacteristicCapabilities = R"pbdoc(
+    Capabilities of the characteristic
+)pbdoc";
+
+constexpr auto kDocsCharacteristicCanRead = R"pbdoc(
+    Whether the characteristic can be read
+)pbdoc";
+
+constexpr auto kDocsCharacteristicCanWriteRequest = R"pbdoc(
+    Whether the characteristic can be written with a request
+)pbdoc";
+
+constexpr auto kDocsCharacteristicCanWriteCommand = R"pbdoc(
+    Whether the characteristic can be written with a command
+)pbdoc";
+
+constexpr auto kDocsCharacteristicCanNotify = R"pbdoc(
+    Whether the characteristic can be notified
+)pbdoc";
+
+constexpr auto kDocsCharacteristicCanIndicate = R"pbdoc(
+    Whether the characteristic can be indicated
+)pbdoc";
+
+void wrap_characteristic(py::module& m) {
+    // TODO: Add __str__ and __repr__ methods
+    py::class_<SimpleBLE::Characteristic>(m, "Characteristic", kDocsCharacteristic)
+        .def("uuid", &SimpleBLE::Characteristic::uuid, kDocsCharacteristicUuid)
+        .def("descriptors", &SimpleBLE::Characteristic::descriptors, kDocsCharacteristicDescriptors)
+        .def("capabilities", &SimpleBLE::Characteristic::capabilities, kDocsCharacteristicCapabilities)
+        .def("can_read", &SimpleBLE::Characteristic::can_read, kDocsCharacteristicCanRead)
+        .def("can_write_request", &SimpleBLE::Characteristic::can_write_request, kDocsCharacteristicCanWriteRequest)
+        .def("can_write_command", &SimpleBLE::Characteristic::can_write_command, kDocsCharacteristicCanWriteCommand)
+        .def("can_notify", &SimpleBLE::Characteristic::can_notify, kDocsCharacteristicCanNotify)
+        .def("can_indicate", &SimpleBLE::Characteristic::can_indicate, kDocsCharacteristicCanIndicate);
+}

data/vendor/simpleble/simplepyble/src/wrap_config.cpp

@@ -0,0 +1,136 @@
+#include <pybind11/pybind11.h>
+#include "simpleble/Config.h"
+
+namespace py = pybind11;
+
+// Wrapper classes for Python bindings (not exposed to C++)
+namespace PyWrappers {
+    struct WinRT {
+        static bool get_experimental_use_own_mta_apartment() {
+            return SimpleBLE::Config::WinRT::experimental_use_own_mta_apartment;
+        }
+        static void set_experimental_use_own_mta_apartment(bool value) {
+            SimpleBLE::Config::WinRT::experimental_use_own_mta_apartment = value;
+        }
+        static bool get_experimental_reinitialize_winrt_apartment_on_main_thread() {
+            return SimpleBLE::Config::WinRT::experimental_reinitialize_winrt_apartment_on_main_thread;
+        }
+        static void set_experimental_reinitialize_winrt_apartment_on_main_thread(bool value) {
+            SimpleBLE::Config::WinRT::experimental_reinitialize_winrt_apartment_on_main_thread = value;
+        }
+
+        static void reset() {
+            SimpleBLE::Config::WinRT::reset();
+        }
+    };
+
+    struct SimpleBluez {
+        static void reset() {
+            SimpleBLE::Config::SimpleBluez::reset();
+        }
+    };
+
+    struct CoreBluetooth {
+        static void reset() {
+            SimpleBLE::Config::CoreBluetooth::reset();
+        }
+    };
+
+    struct Android {
+        static void reset() {
+            SimpleBLE::Config::Android::reset();
+        }
+    };
+
+    struct Base {
+        static void reset_all() {
+            SimpleBLE::Config::Base::reset_all();
+        }
+    };
+}
+
+// Documentation strings
+constexpr auto kDocsConfigModule = R"pbdoc(
+    Configuration options for SimpleBLE
+)pbdoc";
+
+constexpr auto kDocsConfigWinRTClass = R"pbdoc(
+    WinRT-specific configuration options
+)pbdoc";
+
+constexpr auto kDocsConfigSimpleBluezClass = R"pbdoc(
+    SimpleBluez-specific configuration options
+)pbdoc";
+
+constexpr auto kDocsConfigCoreBluetoothClass = R"pbdoc(
+    CoreBluetooth-specific configuration options
+)pbdoc";
+
+constexpr auto kDocsConfigAndroidClass = R"pbdoc(
+    Android-specific configuration options
+)pbdoc";
+
+constexpr auto kDocsConfigBaseClass = R"pbdoc(
+    Base configuration options
+)pbdoc";
+
+constexpr auto kDocsConfigWinRTExperimentalMTA = R"pbdoc(
+    Use own MTA apartment (experimental)
+)pbdoc";
+
+constexpr auto kDocsConfigWinRTExperimentalReinitializeMTAOnMainThread = R"pbdoc(
+    Reinitialize the WinRT apartment on the main thread (experimental)
+)pbdoc";
+
+constexpr auto kDocsConfigWinRTReset = R"pbdoc(
+    Reset WinRT configuration options to their default values
+)pbdoc";
+
+constexpr auto kDocsConfigSimpleBluezReset = R"pbdoc(
+    Reset SimpleBluez configuration options to their default values
+)pbdoc";
+
+constexpr auto kDocsConfigCoreBluetoothReset = R"pbdoc(
+    Reset CoreBluetooth configuration options to their default values
+)pbdoc";
+
+constexpr auto kDocsConfigAndroidReset = R"pbdoc(
+    Reset Android configuration options to their default values
+)pbdoc";
+
+constexpr auto kDocsConfigBaseResetAll = R"pbdoc(
+    Reset all configuration options to their default values
+)pbdoc";
+
+void wrap_config(py::module& m) {
+    auto config = m.def_submodule("config", kDocsConfigModule);
+
+    // Define classes directly under config
+    py::class_<PyWrappers::WinRT> winrt_config(config, "winrt", kDocsConfigWinRTClass, py::metaclass());
+    winrt_config
+        .def_property_static("experimental_use_own_mta_apartment",
+            [](py::object) { return PyWrappers::WinRT::get_experimental_use_own_mta_apartment(); },
+            [](py::object, bool value) { PyWrappers::WinRT::set_experimental_use_own_mta_apartment(value); },
+            kDocsConfigWinRTExperimentalMTA)
+        .def_property_static("experimental_reinitialize_winrt_apartment_on_main_thread",
+            [](py::object) { return PyWrappers::WinRT::get_experimental_reinitialize_winrt_apartment_on_main_thread(); },
+            [](py::object, bool value) { PyWrappers::WinRT::set_experimental_reinitialize_winrt_apartment_on_main_thread(value); },
+            kDocsConfigWinRTExperimentalReinitializeMTAOnMainThread)
+        .def_static("reset", &PyWrappers::WinRT::reset, kDocsConfigWinRTReset);
+
+    py::class_<PyWrappers::SimpleBluez> simplebluez_config(config, "simplebluez", kDocsConfigSimpleBluezClass, py::metaclass());
+    simplebluez_config
+        .def_static("reset", &PyWrappers::SimpleBluez::reset, kDocsConfigSimpleBluezReset);
+
+    py::class_<PyWrappers::CoreBluetooth> corebluetooth_config(config, "corebluetooth", kDocsConfigCoreBluetoothClass, py::metaclass());
+    corebluetooth_config
+        .def_static("reset", &PyWrappers::CoreBluetooth::reset, kDocsConfigCoreBluetoothReset);
+
+    py::class_<PyWrappers::Android> android_config(config, "android", kDocsConfigAndroidClass, py::metaclass());
+    android_config
+        .def_static("reset", &PyWrappers::Android::reset, kDocsConfigAndroidReset);
+
+    py::class_<PyWrappers::Base> base_config(config, "base", kDocsConfigBaseClass, py::metaclass());
+    base_config
+        .def_static("reset_all", &PyWrappers::Base::reset_all, kDocsConfigBaseResetAll);
+}

data/vendor/simpleble/simplepyble/src/wrap_descriptor.cpp

@@ -0,0 +1,21 @@
+#include <pybind11/functional.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "simpleble/Descriptor.h"
+
+namespace py = pybind11;
+
+constexpr auto kDocsDescriptor = R"pbdoc(
+    Descriptor
+)pbdoc";
+
+constexpr auto kDocsDescriptorUuid = R"pbdoc(
+    UUID of the descriptor
+)pbdoc";
+
+void wrap_descriptor(py::module& m) {
+    // TODO: Add __str__ and __repr__ methods
+    py::class_<SimpleBLE::Descriptor>(m, "Descriptor", kDocsDescriptor)
+        .def("uuid", &SimpleBLE::Descriptor::uuid, kDocsDescriptorUuid);
+}

data/vendor/simpleble/simplepyble/src/wrap_peripheral.cpp

@@ -0,0 +1,217 @@
+#include <pybind11/functional.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "simpleble/Peripheral.h"
+
+namespace py = pybind11;
+
+constexpr auto kDocsPeripheral = R"pbdoc(
+    Peripheral
+)pbdoc";
+
+constexpr auto kDocsPeripheralInitialized = R"pbdoc(
+    Whether the peripheral is initialized
+)pbdoc";
+
+constexpr auto kDocsPeripheralIdentifier = R"pbdoc(
+    Identifier of the peripheral
+)pbdoc";
+
+constexpr auto kDocsPeripheralAddress = R"pbdoc(
+    Address of the peripheral
+)pbdoc";
+
+constexpr auto kDocsPeripheralAddressType = R"pbdoc(
+    Address Type of the peripheral
+)pbdoc";
+
+constexpr auto kDocsPeripheralRSSI = R"pbdoc(
+    RSSI of the peripheral
+)pbdoc";
+
+constexpr auto kDocsPeripheralTxPower = R"pbdoc(
+    Transit Power of the peripheral in dBm
+)pbdoc";
+
+constexpr auto kDocsPeripheralMtu = R"pbdoc(
+    Get the negotiated MTU value
+)pbdoc";
+
+constexpr auto kDocsPeripheralConnect = R"pbdoc(
+    Connect to the peripheral
+)pbdoc";
+
+constexpr auto kDocsPeripheralDisconnect = R"pbdoc(
+    Disconnect from the peripheral
+)pbdoc";
+
+constexpr auto kDocsPeripheralIsConnected = R"pbdoc(
+    Whether the peripheral is connected
+)pbdoc";
+
+constexpr auto kDocsPeripheralIsConnectable = R"pbdoc(
+    Whether the peripheral is connectable
+)pbdoc";
+
+constexpr auto kDocsPeripheralIsPaired = R"pbdoc(
+    Whether the peripheral is paired
+)pbdoc";
+
+constexpr auto kDocsPeripheralUnpair = R"pbdoc(
+    Unpair the peripheral
+)pbdoc";
+
+constexpr auto kDocsPeripheralServices = R"pbdoc(
+    Services of the peripheral
+)pbdoc";
+
+constexpr auto kDocsPeripheralManufacturerData = R"pbdoc(
+    Manufacturer data of the peripheral
+)pbdoc";
+
+constexpr auto kDocsPeripheralReadCharacteristic = R"pbdoc(
+    Read a characteristic from the peripheral
+)pbdoc";
+
+constexpr auto kDocsPeripheralWriteRequest = R"pbdoc(
+    Write a request to the peripheral
+)pbdoc";
+
+constexpr auto kDocsPeripheralWriteCommand = R"pbdoc(
+    Write a command to the peripheral
+)pbdoc";
+
+constexpr auto kDocsPeripheralNotify = R"pbdoc(
+    Notify a characteristic from the peripheral
+)pbdoc";
+
+constexpr auto kDocsPeripheralIndicate = R"pbdoc(
+    Indicate a characteristic from the peripheral
+)pbdoc";
+
+constexpr auto kDocsPeripheralUnsubscribe = R"pbdoc(
+    Unsubscribe a characteristic from the peripheral
+)pbdoc";
+
+constexpr auto kDocsPeripheralDescriptorRead = R"pbdoc(
+    Read a descriptor from the peripheral
+)pbdoc";
+
+constexpr auto kDocsPeripheralDescriptorWrite = R"pbdoc(
+    Write a descriptor to the peripheral
+)pbdoc";
+
+constexpr auto kDocsPeripheralSetCallbackOnConnected = R"pbdoc(
+    Set callback on connected
+)pbdoc";
+
+constexpr auto kDocsPeripheralSetCallbackOnDisconnected = R"pbdoc(
+    Set callback on disconnected
+)pbdoc";
+
+// clang-format off
+
+void wrap_peripheral(py::module& m) {
+    // TODO: Add __str__ and __repr__ methods
+    py::class_<SimpleBLE::Peripheral>(m, "Peripheral", kDocsPeripheral)
+        .def("initialized", &SimpleBLE::Peripheral::initialized, kDocsPeripheralInitialized)
+        .def("identifier", &SimpleBLE::Peripheral::identifier, kDocsPeripheralIdentifier)
+        .def("address", &SimpleBLE::Peripheral::address, kDocsPeripheralAddress)
+        .def("address_type", &SimpleBLE::Peripheral::address_type, kDocsPeripheralAddressType)
+        .def("rssi", &SimpleBLE::Peripheral::rssi, kDocsPeripheralRSSI)
+        .def("tx_power", &SimpleBLE::Peripheral::tx_power, kDocsPeripheralTxPower)
+        .def("mtu", &SimpleBLE::Peripheral::mtu, kDocsPeripheralMtu)
+        .def("connect", &SimpleBLE::Peripheral::connect, py::call_guard<py::gil_scoped_release>(),
+             kDocsPeripheralConnect)
+        .def("disconnect", &SimpleBLE::Peripheral::disconnect, kDocsPeripheralDisconnect)
+        .def("is_connected", &SimpleBLE::Peripheral::is_connected, kDocsPeripheralIsConnected)
+        .def("is_connectable", &SimpleBLE::Peripheral::is_connectable, kDocsPeripheralIsConnectable)
+        .def("is_paired", &SimpleBLE::Peripheral::is_paired, kDocsPeripheralIsPaired)
+        .def("unpair", &SimpleBLE::Peripheral::unpair, kDocsPeripheralUnpair)
+        .def("services", &SimpleBLE::Peripheral::services, kDocsPeripheralServices)
+        .def(
+            "manufacturer_data",
+            [](SimpleBLE::Peripheral& p) {
+                std::map<uint16_t, py::bytes> ret;
+                for (auto& kv : p.manufacturer_data()) {
+                    ret[kv.first] = py::bytes(kv.second);
+                }
+                return ret;
+            },
+            kDocsPeripheralManufacturerData)
+        .def(
+            "read",
+            [](SimpleBLE::Peripheral& p, std::string const& service, std::string const& characteristic) {
+                SimpleBLE::ByteArray cpp_payload = p.read(service, characteristic);
+                py::gil_scoped_acquire gil;
+                return py::bytes(cpp_payload);
+            },
+            py::call_guard<py::gil_scoped_release>(),
+            kDocsPeripheralReadCharacteristic)
+        .def(
+            "write_request",
+            [](SimpleBLE::Peripheral& p, std::string service, std::string characteristic, py::bytes payload) {
+                // Note py::bytes implicitly converts to std::string
+                SimpleBLE::ByteArray cpp_payload(payload);
+                py::gil_scoped_release release;
+                p.write_request(service, characteristic, cpp_payload);
+            },
+            kDocsPeripheralWriteRequest)
+        .def(
+            "write_command",
+            [](SimpleBLE::Peripheral& p, std::string service, std::string characteristic, py::bytes payload) {
+                // Note py::bytes implicitly converts to std::string
+                SimpleBLE::ByteArray cpp_payload(payload);
+                py::gil_scoped_release release;
+                p.write_command(service, characteristic, cpp_payload);
+            },
+            kDocsPeripheralWriteCommand)
+        .def(
+            "notify",
+            [](SimpleBLE::Peripheral& p, std::string service, std::string characteristic, std::function<void(py::bytes payload)> cb) {
+                p.notify(service, characteristic, [cb](SimpleBLE::ByteArray payload) {
+                    py::gil_scoped_acquire gil;
+                    cb(py::bytes(payload));
+                });
+            },
+            py::call_guard<py::gil_scoped_release>(),
+            kDocsPeripheralNotify)
+        .def(
+            "indicate",
+            [](SimpleBLE::Peripheral& p, std::string service, std::string characteristic, std::function<void(py::bytes payload)> cb) {
+                p.indicate(service, characteristic, [cb](SimpleBLE::ByteArray payload) {
+                    py::gil_scoped_acquire gil;
+                    cb(py::bytes(payload));
+                });
+            },
+            py::call_guard<py::gil_scoped_release>(),
+            kDocsPeripheralIndicate)
+        .def("unsubscribe", &SimpleBLE::Peripheral::unsubscribe, py::call_guard<py::gil_scoped_release>(), kDocsPeripheralUnsubscribe)
+
+        .def(
+            "descriptor_read",
+            [](SimpleBLE::Peripheral& p, std::string const& service, std::string const& characteristic, std::string const& descriptor) {
+                SimpleBLE::ByteArray cpp_payload = p.read(service, characteristic, descriptor);
+                py::gil_scoped_acquire gil;
+                return py::bytes(cpp_payload);
+            },
+            py::call_guard<py::gil_scoped_release>(),
+            kDocsPeripheralDescriptorRead)
+        .def(
+            "descriptor_write",
+            [](SimpleBLE::Peripheral& p, std::string service, std::string characteristic, std::string const& descriptor, py::bytes payload) {
+                // Note py::bytes implicitly converts to std::string
+                SimpleBLE::ByteArray cpp_payload(payload);
+                py::gil_scoped_release release;
+                p.write(service, characteristic, descriptor, cpp_payload);
+            },
+            kDocsPeripheralDescriptorWrite)
+
+        .def("set_callback_on_connected", &SimpleBLE::Peripheral::set_callback_on_connected,
+             py::keep_alive<1, 2>(), kDocsPeripheralSetCallbackOnConnected)
+        .def("set_callback_on_disconnected", &SimpleBLE::Peripheral::set_callback_on_disconnected,
+             py::keep_alive<1, 2>(), kDocsPeripheralSetCallbackOnDisconnected);
+}
+
+// clang-format on

data/vendor/simpleble/simplepyble/src/wrap_service.cpp

@@ -0,0 +1,32 @@
+#include <pybind11/functional.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "simpleble/Service.h"
+
+namespace py = pybind11;
+
+constexpr auto kDocsService = R"pbdoc(
+    Service
+)pbdoc";
+
+constexpr auto kDocsServiceUuid = R"pbdoc(
+    UUID of the service
+)pbdoc";
+
+constexpr auto kDocsServiceData = R"pbdoc(
+    Advertised service data
+)pbdoc";
+
+constexpr auto kDocsServiceCharacteristics = R"pbdoc(
+    Characteristics of the service
+)pbdoc";
+
+void wrap_service(py::module& m) {
+    // TODO: Add __str__ and __repr__ methods
+    py::class_<SimpleBLE::Service>(m, "Service", kDocsService)
+        .def("uuid", &SimpleBLE::Service::uuid, kDocsServiceUuid)
+        .def(
+            "data", [](SimpleBLE::Service& s) { return py::bytes(s.data()); }, kDocsServiceData)
+        .def("characteristics", &SimpleBLE::Service::characteristics, kDocsServiceCharacteristics);
+}

data/vendor/simpleble/simplepyble/src/wrap_types.cpp

@@ -0,0 +1,21 @@
+#include <pybind11/functional.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "simpleble/Types.h"
+
+namespace py = pybind11;
+
+void wrap_types(py::module& m) {
+    py::enum_<SimpleBLE::OperatingSystem>(m, "OperatingSystem")
+        .value("WINDOWS", SimpleBLE::OperatingSystem::WINDOWS)
+        .value("MACOS", SimpleBLE::OperatingSystem::MACOS)
+        .value("LINUX", SimpleBLE::OperatingSystem::LINUX)
+        .export_values();
+
+    py::enum_<SimpleBLE::BluetoothAddressType>(m, "BluetoothAddressType")
+        .value("PUBLIC", SimpleBLE::BluetoothAddressType::PUBLIC)
+        .value("RANDOM", SimpleBLE::BluetoothAddressType::RANDOM)
+        .value("UNSPECIFIED", SimpleBLE::BluetoothAddressType::UNSPECIFIED)
+        .export_values();
+}