9.0b1 Release (#2559)

Author: TobyRoseman

coremlpython/CoreMLPython.h

@@ -20,8 +20,11 @@
 #import <optional>
 
 #ifndef BUILT_WITH_MACOS15_SDK
-#define BUILT_WITH_MACOS15_SDK \
-  !(TARGET_OS_OSX && (!defined(__MAC_15_0) || __MAC_OS_X_VERSION_MAX_ALLOWED < __MAC_15_0))
+#if TARGET_OS_OSX && defined(__MAC_15_0) && __MAC_OS_X_VERSION_MAX_ALLOWED >= __MAC_15_0
+#define BUILT_WITH_MACOS15_SDK 1
+#else
+#define BUILT_WITH_MACOS15_SDK 0
+#endif
 #endif
 
 // Print BUILT_WITH_MACOS15_SDK value
@@ -67,6 +70,11 @@ namespace CoreML {
                 return (MLState *)m_impl;
             }
 #endif
+            // Retrieves the value of the specified state variable from the model.
+            py::object readState(const std::string& stateName) const;
+
+            // Sets the value of the specified state variable in the model.
+            void writeState(const std::string& stateName, py::object value);
 
             private:
              // Type erase `m_impl` otherwise it will result in a compiler warning.

coremlpython/CoreMLPython.mm

@@ -1,3 +1,8 @@
+// Copyright (c) 2025, Apple Inc. All rights reserved.
+//
+// Use of this source code is governed by a BSD-3-clause license that can be
+// found in the LICENSE.txt file or at https://opensource.org/licenses/BSD-3-Clause
+
 #import "CoreMLPythonArray.h"
 
 @implementation PybindCompatibleArray
@@ -6,15 +11,22 @@ + (MLMultiArrayDataType)dataTypeOf:(py::array)array {
     const auto& dt = array.dtype();
     char kind = dt.kind();
     size_t itemsize = dt.itemsize();
-    
+
+
     if(kind == 'i' && itemsize == 4) {
         return MLMultiArrayDataTypeInt32;
-    } else if(kind == 'f' && itemsize == 4) {
+    }
+#if BUILT_WITH_MACOS26_SDK
+    else if (kind == 'i' && itemsize == 1) {
+        return MLMultiArrayDataTypeInt8;
+    }
+#endif
+    else if(kind == 'f' && itemsize == 4) {
         return MLMultiArrayDataTypeFloat32;
     } else if( (kind == 'f' || kind == 'd') && itemsize == 8) {
         return MLMultiArrayDataTypeDouble;
     }
-    
+
     throw std::runtime_error("Unsupported array type: " + std::to_string(kind) + " with itemsize = " + std::to_string(itemsize));
 }
 
@@ -29,7 +41,7 @@ + (MLMultiArrayDataType)dataTypeOf:(py::array)array {
 + (NSArray<NSNumber *> *)stridesOf:(py::array)array {
     // numpy strides is in bytes.
     // this type must return number of ELEMENTS! (as per mlkit)
-    
+
     NSMutableArray<NSNumber *> *ret = [[NSMutableArray alloc] init];
     for (size_t i=0; i<array.ndim(); i++) {
         size_t stride = array.strides(i) / array.itemsize();

coremlpython/CoreMLPythonArray.mm

@@ -11,21 +11,10 @@
 
 #import <Accelerate/Accelerate.h>
 
-#if PY_MAJOR_VERSION < 3
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wmacro-redefined"
-#define PyBytes_Check(name) PyString_Check(name)
-#pragma clang diagnostic pop
-#define PyAnyInteger_Check(name) (PyLong_Check(name) || PyInt_Check(name))
-
-#else
-
 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
 #include <numpy/arrayobject.h>
-#define PyAnyInteger_Check(name) (PyLong_Check(name) || (_import_array(), PyArray_IsScalar(name, Integer)))
 
-#endif
+#define PyAnyInteger_Check(name) (PyLong_Check(name) || (_import_array(), PyArray_IsScalar(name, Integer)))
 
 using namespace CoreML::Python;
 
@@ -59,14 +48,14 @@
 
     @autoreleasepool {
         NSMutableDictionary<NSString *, NSObject *> *inputDict = [[NSMutableDictionary<NSString *, NSObject *> alloc] init];
-        
+
         for (const auto element : dict) {
             std::string key = element.first.cast<std::string>();
             NSString *nsKey = [NSString stringWithUTF8String:key.c_str()];
             id nsValue = Utils::convertValueToObjC(element.second);
             inputDict[nsKey] = nsValue;
         }
-        
+
         feautreProvider = [[MLDictionaryFeatureProvider alloc] initWithDictionary:inputDict error:&localError];
     }
 
@@ -134,17 +123,17 @@
 }
 
 static MLFeatureValue * convertValueToDictionary(const py::handle& handle) {
-    
+
     if(!PyDict_Check(handle.ptr())) {
         throw std::runtime_error("Not a dictionary.");
     }
-    
+
     // Get the first value in the dictionary; use that as a hint.
     PyObject *key = nullptr, *value = nullptr;
     Py_ssize_t pos = 0;
-    
+
     int has_values = PyDict_Next(handle.ptr(), &pos, &key, &value);
-    
+
     // Is it an empty dict?  If so, just return an empty dictionary.
     if(!has_values) {
         return [MLFeatureValue featureValueWithDictionary:@{} error:nullptr];
@@ -222,12 +211,12 @@ static void handleCVReturn(CVReturn status) {
 static MLFeatureValue * convertValueToImage(const py::handle& handle) {
     // assumes handle is a valid PIL image!
     CVPixelBufferRef pixelBuffer = nil;
-    
+
     size_t width = handle.attr("width").cast<size_t>();
     size_t height = handle.attr("height").cast<size_t>();
     OSType format;
     std::string formatStr = handle.attr("mode").cast<std::string>();
-    
+
     if (formatStr == "RGB") {
         format = kCVPixelFormatType_32BGRA;
     } else if (formatStr == "RGBA") {
@@ -242,18 +231,18 @@ static void handleCVReturn(CVReturn status) {
         msg << "Supported types are: RGB, RGBA, L.";
         throw std::runtime_error(msg.str());
     }
-    
+
     CVReturn status = CVPixelBufferCreate(kCFAllocatorDefault, width, height, format, NULL, &pixelBuffer);
     handleCVReturn(status);
-    
+
     // get bytes out of the PIL image
     py::object tobytes = handle.attr("tobytes");
     py::object bytesResult = tobytes();
     assert(PyBytes_Check(bytesResult.ptr()));
     Py_ssize_t bytesLength = PyBytes_Size(bytesResult.ptr());
     assert(bytesLength >= 0);
     const char *bytesPtr = PyBytes_AsString(bytesResult.ptr());
-    
+
     // copy data into the CVPixelBuffer
     status = CVPixelBufferLockBaseAddress(pixelBuffer, 0);
     handleCVReturn(status);
@@ -268,33 +257,33 @@ static void handleCVReturn(CVReturn status) {
     srcBuffer.data = const_cast<char *>(srcPointer);
     srcBuffer.width = width;
     srcBuffer.height = height;
-    
+
     vImage_Buffer dstBuffer;
     memset(&dstBuffer, 0, sizeof(dstBuffer));
     dstBuffer.data = baseAddress;
     dstBuffer.width = width;
     dstBuffer.height = height;
 
     if (formatStr == "RGB") {
-        
+
         // convert RGB to BGRA
         assert(bytesLength == width * height * 3);
 
         srcBuffer.rowBytes = width * 3;
         dstBuffer.rowBytes = bytesPerRow;
         vImageConvert_RGB888toBGRA8888(&srcBuffer, NULL, 255, &dstBuffer, false, 0);
-        
+
     } else if (formatStr == "RGBA") {
-        
+
         // convert RGBA to BGRA
         assert(bytesLength == width * height * 4);
         srcBuffer.rowBytes = width * 4;
         dstBuffer.rowBytes = bytesPerRow;
         uint8_t permuteMap[4] = { 2, 1, 0, 3 };
         vImagePermuteChannels_ARGB8888(&srcBuffer, &dstBuffer, permuteMap, 0);
-        
+
     } else if (formatStr == "L") {
-        
+
         // 8 bit grayscale.
         assert(bytesLength == width * height);
 
@@ -303,7 +292,7 @@ static void handleCVReturn(CVReturn status) {
         vImageCopyBuffer(&srcBuffer, &dstBuffer, 1, 0);
 
     } else if (formatStr == "F") {
-        
+
         // convert Float32 to Float16.
         assert(bytesLength == width * height * sizeof(Float32));
 
@@ -317,14 +306,14 @@ static void handleCVReturn(CVReturn status) {
         msg << "Supported types are: RGB, RGBA, L.";
         throw std::runtime_error(msg.str());
     }
-    
+
 #ifdef COREML_SHOW_PIL_IMAGES
     if (formatStr == "RGB") {
         // for debugging purposes, convert back to PIL image and show it
         py::object scope = py::module::import("__main__").attr("__dict__");
         py::eval<py::eval_single_statement>("import PIL.Image", scope);
         py::object pilImage = py::eval<py::eval_expr>("PIL.Image");
-        
+
         std::string cvPixelStr(count, 0);
         const char *basePtr = static_cast<char *>(baseAddress);
         for (size_t row = 0; row < height; row++) {
@@ -334,7 +323,7 @@ static void handleCVReturn(CVReturn status) {
                 }
             }
         }
-        
+
         py::bytes cvPixelBytes = py::bytes(cvPixelStr);
         py::object frombytes = pilImage.attr("frombytes");
         py::str mode = "RGB";
@@ -343,62 +332,62 @@ static void handleCVReturn(CVReturn status) {
         img.attr("show")();
     }
 #endif
-    
+
     status = CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
     handleCVReturn(status);
 
     MLFeatureValue *fv = [MLFeatureValue featureValueWithPixelBuffer:pixelBuffer];
     CVPixelBufferRelease(pixelBuffer);
-    
+
     return fv;
 }
 
 static bool IsPILImage(const py::handle& handle) {
     // TODO put try/catch around this?
-    
+
     try {
         py::module::import("PIL.Image");
     } catch(...) {
         return false;
     }
-    
+
     py::object scope = py::module::import("__main__").attr("__dict__");
     py::eval<py::eval_single_statement>("import PIL.Image", scope);
     py::handle imageTypeHandle = py::eval<py::eval_expr>("PIL.Image.Image", scope);
     assert(PyType_Check(imageTypeHandle.ptr())); // should be a Python type
-    
+
     return PyObject_TypeCheck(handle.ptr(), (PyTypeObject *)(imageTypeHandle.ptr()));
 }
 
 MLFeatureValue * Utils::convertValueToObjC(const py::handle& handle) {
-    
+
     if (PyAnyInteger_Check(handle.ptr())) {
         try {
             int64_t val = handle.cast<int64_t>();
             return [MLFeatureValue featureValueWithInt64:val];
         } catch(...) {}
     }
-    
+
     if (PyFloat_Check(handle.ptr())) {
         try {
             double val = handle.cast<double>();
             return [MLFeatureValue featureValueWithDouble:val];
         } catch(...) {}
     }
-    
+
     if (PyBytes_Check(handle.ptr()) || PyUnicode_Check(handle.ptr())) {
         try {
             std::string val = handle.cast<std::string>();
             return [MLFeatureValue featureValueWithString:[NSString stringWithUTF8String:val.c_str()]];
         } catch(...) {}
     }
-    
+
     if (PyDict_Check(handle.ptr())) {
         try {
             return convertValueToDictionary(handle);
         } catch(...) {}
     }
-    
+
     if(PyList_Check(handle.ptr()) || PyTuple_Check(handle.ptr())) {
         try {
             return convertValueToSequence(handle);
@@ -410,11 +399,11 @@ static bool IsPILImage(const py::handle& handle) {
             return convertValueToArray(handle);
         } catch(...) {}
     }
-    
+
     if (IsPILImage(handle)) {
         return convertValueToImage(handle);
     }
-    
+
     py::print("Error: value type not convertible:");
     py::print(handle);
     throw std::runtime_error("value type not convertible");
@@ -474,6 +463,11 @@ static size_t sizeOfArrayElement(MLMultiArrayDataType type) {
     __block py::object array;
     [value getBytesWithHandler:^(const void *bytes, NSInteger size) {
         switch (type) {
+#if BUILT_WITH_MACOS26_SDK
+            case MLMultiArrayDataTypeInt8:
+                array = py::array(shape, strides, reinterpret_cast<const int8_t *>(bytes));
+                break;
+#endif
             case MLMultiArrayDataTypeInt32:
                 array = py::array(shape, strides, reinterpret_cast<const int32_t *>(bytes));
                 break;
@@ -508,7 +502,7 @@ static size_t sizeOfArrayElement(MLMultiArrayDataType type) {
             NSString *nskey = static_cast<NSString *>(key);
             pykey = py::str([nskey UTF8String]);
         }
-        
+
         NSNumber *value = dict[key];
         ret[pykey] = py::float_([value doubleValue]);
     }
@@ -519,7 +513,7 @@ static size_t sizeOfArrayElement(MLMultiArrayDataType type) {
     if (CVPixelBufferIsPlanar(value)) {
         throw std::runtime_error("Only non-planar CVPixelBuffers are currently supported by this Python binding.");
     }
-    
+
     // supports grayscale and BGRA format types
     auto formatType = CVPixelBufferGetPixelFormatType(value);
     assert(formatType == kCVPixelFormatType_32BGRA
@@ -553,10 +547,10 @@ static size_t sizeOfArrayElement(MLMultiArrayDataType type) {
 
     auto result = CVPixelBufferLockBaseAddress(value, kCVPixelBufferLock_ReadOnly);
     assert(result == kCVReturnSuccess);
-    
+
     uint8_t *src = reinterpret_cast<uint8_t*>(CVPixelBufferGetBaseAddress(value));
     assert(src != nullptr);
-    
+
     size_t srcBytesPerRow = CVPixelBufferGetBytesPerRow(value);
 
     // Prepare for vImage blitting
@@ -587,10 +581,10 @@ static size_t sizeOfArrayElement(MLMultiArrayDataType type) {
         msg << "Unsupported pixel format type: " << std::hex << std::setfill('0') << std::setw(4) << formatType << ". ";
         throw std::runtime_error(msg.str());
     }
-    
+
     result = CVPixelBufferUnlockBaseAddress(value, kCVPixelBufferLock_ReadOnly);
     assert(result == kCVReturnSuccess);
-    
+
     py::object scope = py::module::import("__main__").attr("__dict__");
     py::eval<py::eval_single_statement>("import PIL.Image", scope);
     py::object pilImage = py::eval<py::eval_expr>("PIL.Image", scope);