Initial commit

Author: miriamkw

.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+/.build
+/Packages
+xcuserdata/
+DerivedData/
+.swiftpm/configuration/registries.json
+.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
+.netrc

.swiftpm/xcode/package.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>

Package.resolved

@@ -0,0 +1,35 @@
+// swift-tools-version: 5.10
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "LoopAlgorithmToPython",
+    platforms: [
+        .macOS(.v13),
+        .iOS(.v15),
+        .tvOS(.v15),
+        .watchOS(.v8)
+    ],
+    products: [
+        // Products define the executables and libraries a package produces, making them visible to other packages.
+        .library(
+            name: "LoopAlgorithmToPython",
+            type: .dynamic,
+            targets: ["LoopAlgorithmToPython"]),
+    ],
+    dependencies: [
+        .package(url: "https://github.com/tidepool-org/LoopAlgorithm.git", branch: "main"),
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package, defining a module or a test suite.
+        // Targets can depend on other targets in this package and products from dependencies.
+        .target(
+            name: "LoopAlgorithmToPython",
+            dependencies: ["LoopAlgorithm"]
+        ),
+        .testTarget(
+            name: "LoopAlgorithmToPythonTests",
+            dependencies: ["LoopAlgorithmToPython"]),
+    ]
+)

Package.swift

@@ -0,0 +1,90 @@
+# LoopAlgorithmToPython
+
+This Swift module uses LoopAlgorithm to create C functions for generating predictions and prediction dates from JSON data.
+
+How?
+I create a foreign function interface (FFI) in Swift by using the unofficial @_cdecl Swift function. This interfaces the Swift code with C. Then we can create a dynamic library, import it into a Python (or other) repositories, and use for example ctypes to compile the C code.
+
+
+## Installation
+
+1. Clone the repository
+2. Build the dynamic library:
+
+```
+swift package clean
+swift build --configuration release
+```
+Check if the dynamic library got properly generated and print the path:
+```
+find .build -name "libLoopAlgorithmToPython.dylib"
+```
+Output should be something like: /release/libLoopAlgorithmToPython.dylib
+
+Copy that file into your repository.
+
+
+## Exposed functions
+
+You can find the C-exposed functions in the file `LoopAlgorithmToPython.swift`.
+
+
+
+## Usage in Python
+
+Here's how you can use the dynamic library (`libLoopAlgorithmToPython.dylib`) in Python to call the exposed functions:
+
+```
+import ctypes
+import json
+
+json_file_path = 'some_file.json'
+
+# Load the shared library
+swift_lib = ctypes.CDLL('./libLoopAlgorithmToPython.dylib')
+
+# Specify the argument types and return type of the Swift function
+swift_lib.generatePrediction.argtypes = [ctypes.c_char_p]
+swift_lib.generatePrediction.restype = ctypes.POINTER(ctypes.c_double)
+
+# Read JSON file
+def read_json_file(file_path):
+    with open(file_path, 'r') as f:
+        data = json.load(f)
+    return data
+
+json_data = read_json_file(json_file_path) # Read JSON file
+json_str = json.dumps(json_data) # Convert JSON data to JSON string
+json_bytes = json_str.encode('utf-8') # Convert JSON string to bytes
+
+# Prepare a variable to receive the length of the predicted values
+length = 82
+
+# Call the Swift function
+result = swift_lib.generatePrediction(json_bytes)
+
+# Read the generated predictions
+array = [result[i] for i in range(length)]
+print(array[0])
+print(f"The result from generatePrediction is: {array}")
+
+# Specify the argument types and return type of the prediction dates
+swift_lib.getPredictionDates.argtypes = [ctypes.c_char_p]
+swift_lib.getPredictionDates.restype = ctypes.c_char_p
+
+# Call the Swift function
+result = swift_lib.getPredictionDates(json_bytes).decode('utf-8')
+date_list = result.split(',')[:-1]
+print(f"The result from getPredictionDates is: {date_list}")
+```
+
+Adjust the paths, function names, and details as per your specific project setup and requirements.
+
+
+
+
+
+
+
+
+

README.md

@@ -0,0 +1,101 @@
+//
+//  LoopAlgorithmToPython.swift
+//  LoopAlgorithm
+//
+//  Created by Miriam K. Wolff on 24/06/2024.
+//
+
+import Foundation
+import LoopAlgorithm
+import HealthKit
+
+@_cdecl("generatePrediction") // Use @_cdecl to expose the function with a C-compatible name
+public func generatePrediction(jsonData: UnsafePointer<Int8>?) -> UnsafeMutablePointer<Double> {
+    /// To generate a lib file, run:
+    /// swiftc -emit-library -o libMySwiftModule.dylib Sources/LoopAlgorithmToPython/LoopAlgorithmToPython.swift
+    
+    // TODO: Add opportunity to get prediction effects from only one factor at a time
+    let decoder = JSONDecoder()
+    decoder.dateDecodingStrategy = .iso8601
+    
+    guard let jsonData = jsonData else {
+        fatalError("No JSON data provided")
+    }
+    
+    // Convert JSON data to Data
+    let data = Data(bytes: jsonData, count: strlen(jsonData))
+
+    do {
+        // Decode JSON data
+        let input = try decoder.decode(LoopPredictionInput.self, from: data)
+
+        let prediction = LoopAlgorithm.generatePrediction(
+            start: input.glucoseHistory.last?.startDate ?? Date(),
+            glucoseHistory: input.glucoseHistory,
+            doses: input.doses,
+            carbEntries: input.carbEntries,
+            basal: input.basal,
+            sensitivity: input.sensitivity,
+            carbRatio: input.carbRatio,
+            algorithmEffectsOptions: .all, // Here we can adjust which predictive factor to output
+            useIntegralRetrospectiveCorrection: input.useIntegralRetrospectiveCorrection
+        )
+        
+        var predictedValues: [Double] = []
+                
+        for val in prediction.glucose {
+            predictedValues.append(val.quantity.doubleValue(for: HKUnit(from: "mg/dL")))
+        }
+        let pointer = UnsafeMutablePointer<Double>.allocate(capacity: predictedValues.count)
+        pointer.initialize(from: predictedValues, count: predictedValues.count)
+                
+        return pointer
+    } catch {
+        fatalError("Error reading or decoding JSON file: \(error)")
+    }
+}
+
+@_cdecl("getPredictionDates") // Use @_cdecl to expose the function with a C-compatible name
+public func getPredictionDates(jsonData: UnsafePointer<Int8>?) -> UnsafePointer<CChar> {
+    /// To generate a lib file, run:
+    /// swiftc -emit-library -o libMySwiftModule.dylib Sources/LoopAlgorithmToPython/LoopAlgorithmToPython.swift
+    
+    let decoder = JSONDecoder()
+    decoder.dateDecodingStrategy = .iso8601
+    
+    guard let jsonData = jsonData else {
+        fatalError("No JSON data provided")
+    }
+    
+    // Convert JSON data to Data
+    let data = Data(bytes: jsonData, count: strlen(jsonData))
+    
+    do {
+        // Decode JSON data
+        let input = try decoder.decode(LoopPredictionInput.self, from: data)
+
+        let prediction = LoopAlgorithm.generatePrediction(
+            start: input.glucoseHistory.last?.startDate ?? Date(),
+            glucoseHistory: input.glucoseHistory,
+            doses: input.doses,
+            carbEntries: input.carbEntries,
+            basal: input.basal,
+            sensitivity: input.sensitivity,
+            carbRatio: input.carbRatio,
+            algorithmEffectsOptions: .all,
+            useIntegralRetrospectiveCorrection: input.useIntegralRetrospectiveCorrection
+        )
+        // Prepare prediction dates as a comma-separated string
+        var predictionDates: String = ""
+        for val in prediction.glucose {
+            predictionDates += val.startDate.ISO8601Format() + ","
+        }
+        let cString = strdup(predictionDates)!
+                
+        return UnsafePointer<CChar>(cString)
+    } catch {
+        fatalError("Error reading or decoding JSON file: \(error)")
+    }
+}
+
+

Sources/LoopAlgorithmToPython/LoopAlgorithmToPython.swift

@@ -0,0 +1,12 @@
+import XCTest
+@testable import LoopAlgorithmToPython
+
+final class LoopAlgorithmToPythonTests: XCTestCase {
+    func testExample() throws {
+        // XCTest Documentation
+        // https://developer.apple.com/documentation/xctest
+
+        // Defining Test Cases and Test Methods
+        // https://developer.apple.com/documentation/xctest/defining_test_cases_and_test_methods
+    }
+}