Swift and Python Interop using Dynamic Member Lookup

# Check the /usr/include folder for the Python umbrella header.
$ ls /usr/include/python2.7/Python.h -l

# -*- coding: utf-8 -*-
#
 
import os, sys
import numpy as np
 
class compute:
 
    def __init__(self, dynamic_text, numeric_list):
        self.dynamic_text = dynamic_text
        self.static_text = "Hello from Python"
        self.numeric_list = numeric_list
 
    def get_static_text(self):
        return self.static_text
 
    def get_dynamic_text(self):
        return self.dynamic_text
 
    def add_to_list(self, added_values):
        self.numeric_list = self.numeric_list + added_values
 
 
    def get_mean(self):
    	if self.numeric_list.count > 0:
    		return np.mean(self.numeric_list)
    	else:
    		return -1
 
    def get_median(self):
    	if self.numeric_list.count > 0:
    		return np.median(self.numeric_list)
    	else:
    		return -1
 
    def get_min(self):
    	if self.numeric_list.count > 0:
    		return np.amin(self.numeric_list)
    	else:
    		return -1
 
    def get_max(self):
    	if self.numeric_list.count > 0:
    		return np.amax(self.numeric_list)
    	else:
    		return -1
 
    def get_standard_deviation(self):
    	if self.numeric_list.count > 0:
    		return np.std(self.numeric_list)
    	else:
    		return -1
 
    def get_square_root(self):
    	if self.numeric_list.count > 0:
    		return np.sqrt(self.numeric_list)
    	else:
    		return [-1]

// Point to the Python.h header file on Linux or macOS.
#ifdef __linux__
#include "/usr/include/python2.7/Python.h"
#elif __APPLE__
#include "/usr/include/python2.7/Python.h"
#else
#error Was not able to detect the operating system properly.
#endif

import CPython
 
...
 
public let Python = PythonInterface()
 
public struct PythonInterface {
  /// This is a hash table of the builtins provided by the Python language.
  public let builtins : PyVal
 
  init() {
    Py_Initialize()   // Initialize python
    builtins = PyVal(borrowed: PyEval_GetBuiltins())
  }
 
  public func `import`(_ name: String) -> PyVal {
    guard let pyModule = PyImport_ImportModule(name) else {
      fatalError("Could not import Python module \(name)")
    }
    return PyVal(owned: pyModule)
  }
 
 
  // TODO: Make the PythonInterface type itself `DynamicCallable`, so that
  // things like Python.open" naturally resolve to Python.get(member: "open")
  // and all the builtin functions are therefore available naturally and don't
  // have to be enumerated here.
  public var isinstance : PyVal { return builtins["isinstance"] }
  public var len : PyVal { return builtins["len"] }
  public var open : PyVal { return builtins["open"] }
  public var print : PyVal { return builtins["print"] }
  public var repr : PyVal { return builtins["repr"] }
  public var str : PyVal { return builtins["str"] }
  public var type : PyVal { return builtins["type"] }
}

/// This is the currency type for Python object references.  It is passed to and
/// returned from Python calls and member references, and is overloaded to
/// support the standard operations that Python supports.
@dynamicMemberLookup
public struct PyVal {
  /// This is the actual handle to a Python value that we represent.
  fileprivate var state : PyRef
 
  init(_ value : PyRef) {
    state = value
  }
  public init(owned: OwnedPyObject) {
    state = PyRef(owned: owned)
  }
  public init(borrowed: UnsafeMutablePointer<PyObject>) {
    state = PyRef(borrowed: borrowed)
  }
 
  fileprivate var borrowedPyObject : UnsafeMutablePointer<PyObject> {
    return state.borrowedPyObject
  }
  fileprivate var ownedPyObject : OwnedPyObject {
    return state.ownedPyObject
  }
 
  // This usage is taken right from the proposal exmaple.
  // https://github.com/apple/swift-evolution/blob/master/proposals/0195-dynamic-member-lookup.md#example-usage
  subscript(dynamicMember member: String) -> PyVal {
    get {
      let result = PyObject_GetAttrString(borrowedPyObject, member)!
      return PyVal(owned: result)
    }
    set {
      PyObject_SetAttrString(borrowedPyObject, member,
                             newValue.borrowedPyObject)
    }
  }
}

import XCTest
@testable import PythonBridge
 
final class PythonBridgeTests: XCTestCase {
 
    let computeModule = Python.import("Compute.compute")
    let swiftArray: [Int] = [2, 4, 6, 8, 10]
    var computedInstance: PyVal?
 
 
    override func setUp() {
        super.setUp()
        // Transform a Swift array to a PyVal that can be read as a list.
        let numeric_list: PyVal = PyVal(arrayContentsOf: self.swiftArray)
        // Subscript a member of the computeModule to create a compute object.
        // Upon construction of the object, pass in a string and list.
        self.computedInstance = computeModule.get(member: "compute").call(args: "Python Bridge", numeric_list)
    }
 
    ...
}

func testComputeMembers() {
 
    // The first test below is designed to call into computedInstance
    // and test the equality of a member using an explicit lookup.
    // 
    // The second test is designed to also test equality but using the 
    // dot syntax with the @dynamicMemberLookup functionality instead.
 
    // ## Test: 1
    // Test that we can get static data from the computedInstance.
    // Accessing this member does not use dot syntax.
    let pyValStaticText = computedInstance?.get(member: "static_text")
    XCTAssertEqual(pyValStaticText?.asString(), "Hello from Python")
 
    // ## Test: 2
    // Test that we can call a dynamic member in the compute class
    // and use @dynamicMemberLookup to access this member with the dot syntax.
    // This specific example is grabbing a string.
    let pyValDynamicMemberText = computedInstance?.static_text
    XCTAssertEqual(pyValDynamicMemberText, "Hello from Python")
 
    // ## Test: 3 - Also using @dynamicMemberLookup.
    // This test also uses the dot syntax but instead grabs a numeric list/array.
    // A subscript is used to then compare two values.
    guard let swiftArray = computedInstance?.numeric_list else {
	XCTFail("Numeric List was not unwrapped properly")
	return
    }
    XCTAssertEqual(swiftArray[2], 6)
 
}

func testComputeMethods() {
 
    // The tests below are to provide examples of calling methods of the
    // computedInstance and checking the return values.
    // The return values are cast to numeric values in the PythonBridge instead 
    // of the currency PyVal object.
    //
    // The proposal for @dynamicCallable will make the below example possible.
    // Until then .call() method will need to be used to explicitly call members
    // of the PyVal object.
    // let v = computedInstance.get_mean()
    // 
 
    // ## Test: 1
    // Test that we can get the mean back from NumPy and test it in Swift
    // Provids a PyVal object that contains the mean
    let pyValMean = computedInstance?.get(member: "get_mean").call()
    XCTAssertEqual(pyValMean?.asDouble(), 6.0)
 
    // ## Test: 2
    // Test the min value received back from NumPy
    // Provids a PyVal object that contains the min
    let pyValMin = computedInstance?.get(member: "get_min").call()
    XCTAssertEqual(pyValMin?.asInteger(), 2)
 
    // ## Test: 3
    // Test adding values to the numeric list and then recomputing the mean.
    let swiftPrimes = [19, 23, 29]
    let pyValPrimeList: PyVal = PyVal(arrayContentsOf: swiftPrimes)
    computedInstance?.get(member: "add_to_list").call(args: pyValPrimeList)
 
    // The new recomputed means as a double or integer
    let pyValNewMean = computedInstance?.get(member: "get_mean").call()
    XCTAssertEqual(pyValNewMean?.asInteger(), 12)
    XCTAssertEqual(pyValNewMean?.asDouble(), 12.625)
 
}