private var pointer: OwnedPyObjectPointer

// This `PyReference`, once deleted, will make no delta change to the

// python object's reference count. It will however, retain the reference for

// the lifespan of this object.

init(_ pointer: OwnedPyObjectPointer) {

self.pointer = pointer

Py_IncRef(pointer)

}

// This `PyReference` adopts the +1 reference and will decrement it in the

// future.

init(consuming pointer: PyObjectPointer) {

self.pointer = pointer

}

deinit {

Py_DecRef(pointer)

}

var borrowedPyObject: PyObjectPointer {

return pointer

}

var ownedPyObject: OwnedPyObjectPointer {

Py_IncRef(pointer)

return pointer

}

/// The underlying `PyReference`.

fileprivate var reference: PyReference

@usableFromInline

init(_ pointer: PyReference) {

reference = pointer

}

/// Creates a new instance and a new reference.

init(_ pointer: OwnedPyObjectPointer) {

reference = PyReference(pointer)

}

/// Creates a new instance consuming the specified `PyObject` pointer.

init(consuming pointer: PyObjectPointer) {

reference = PyReference(consuming: pointer)

}

fileprivate var borrowedPyObject: PyObjectPointer {

return reference.borrowedPyObject

}

fileprivate var ownedPyObject: OwnedPyObjectPointer {

return reference.ownedPyObject

}

// The `str` function is used here because it is designed to return

// human-readable descriptions of Python objects. The Python REPL also uses

// it for printing descriptions.

// `repr` is not used because it is not designed to be readable and takes

// too long for large objects.

return String(Python.str(self))!

/// Creates a new instance from the given `PythonObject`, if possible.

/// - Note: Conversion may fail if the given `PythonObject` instance is

/// incompatible (e.g. a Python `string` object cannot be converted into an

/// `Int`).

init?(_ object: PythonObject)

/// A Python runtime exception, produced by calling a Python function.

case exception(PythonObject, traceback: PythonObject?)

/// A failed call on a `PythonObject`.

/// Reasons for failure include:

/// - A non-callable Python object was called.

/// - An incorrect number of arguments were provided to the callable Python

/// object.

/// - An invalid keyword argument was specified.

case invalidCall(PythonObject)

/// A module import error.

case invalidModule(String)

switch self {

case .exception(let e, let t):

var exceptionDescription = "Python exception: \(e)"

if let t = t {

let traceback = Python.import("traceback")

exceptionDescription += """

\(PythonObject("").join(traceback.format_tb(t)))

}

return exceptionDescription

case .invalidCall(let e):

return "Invalid Python call: \(e)"

case .invalidModule(let m):

return "Invalid Python module: \(m)"

}

if PyErr_Occurred() == nil { return }

var type: PyObjectPointer?

var value: PyObjectPointer?

var traceback: PyObjectPointer?

// Fetch the exception and clear the exception state.

PyErr_Fetch(&type, &value, &traceback)

// The value for the exception may not be set but the type always should be.

let resultObject = PythonObject(consuming: value ?? type!)

let tracebackObject = traceback.flatMap { PythonObject(consuming: $0) }

throw PythonError.exception(resultObject, traceback: tracebackObject)

private var base: PythonObject

fileprivate init(_ base: PythonObject) {

self.base = base

}

/// Call `self` with the specified positional arguments.

/// If the call fails for some reason, `PythonError.invalidCall` is thrown.

/// - Precondition: `self` must be a Python callable.

/// - Parameter args: Positional arguments for the Python callable.

@discardableResult

public func dynamicallyCall(

withArguments args: PythonConvertible...) throws -> PythonObject {

return try dynamicallyCall(withArguments: args)

}

/// Call `self` with the specified positional arguments.

/// If the call fails for some reason, `PythonError.invalidCall` is thrown.

/// - Precondition: `self` must be a Python callable.

/// - Parameter args: Positional arguments for the Python callable.

@discardableResult

public func dynamicallyCall(

withArguments args: [PythonConvertible] = []) throws -> PythonObject {

try throwPythonErrorIfPresent()

// Positional arguments are passed as a tuple of objects.

let argTuple = pyTuple(args.map { $0.pythonObject })

defer { Py_DecRef(argTuple) }

// Python calls always return a non-null object when successful. If the

// Python function produces the equivalent of C `void`, it returns the

// `None` object. A `null` result of `PyObjectCall` happens when there is an

// error, like `self` not being a Python callable.

let selfObject = base.ownedPyObject

defer { Py_DecRef(selfObject) }

guard let result = PyObject_CallObject(selfObject, argTuple) else {

// If a Python exception was thrown, throw a corresponding Swift error.

try throwPythonErrorIfPresent()

throw PythonError.invalidCall(base)

}

return PythonObject(consuming: result)

}

/// Call `self` with the specified arguments.

/// If the call fails for some reason, `PythonError.invalidCall` is thrown.

/// - Precondition: `self` must be a Python callable.

/// - Parameter args: Positional or keyword arguments for the Python callable.

@discardableResult

public func dynamicallyCall(

withKeywordArguments args:

KeyValuePairs<String, PythonConvertible> = [:]) throws -> PythonObject {

return try _dynamicallyCall(args)

}

/// Alias for the function above that lets the caller dynamically construct the argument list, without using a dictionary literal.

/// This function must be called explicitly on a `PythonObject` because `@dynamicCallable` does not recognize it.

@discardableResult

public func dynamicallyCall(

withKeywordArguments args:

[(key: String, value: PythonConvertible)] = []) throws -> PythonObject {

return try _dynamicallyCall(args)

}

/// Implementation of `dynamicallyCall(withKeywordArguments)`.

private func _dynamicallyCall<T : Collection>(_ args: T) throws -> PythonObject

where T.Element == (key: String, value: PythonConvertible) {

try throwPythonErrorIfPresent()

// An array containing positional arguments.

var positionalArgs: [PythonObject] = []

// A dictionary object for storing keyword arguments, if any exist.

var kwdictObject: OwnedPyObjectPointer? = nil

for (key, value) in args {

if key.isEmpty {

positionalArgs.append(value.pythonObject)

continue

}

// Initialize dictionary object if necessary.

if kwdictObject == nil { kwdictObject = PyDict_New()! }

// Add key-value pair to the dictionary object.

// TODO: Handle duplicate keys.

// In Python, `SyntaxError: keyword argument repeated` is thrown.

let k = PythonObject(key).ownedPyObject

let v = value.ownedPyObject

PyDict_SetItem(kwdictObject, k, v)

Py_DecRef(k)

Py_DecRef(v)

}

defer { Py_DecRef(kwdictObject) } // Py_DecRef is `nil` safe.

// Positional arguments are passed as a tuple of objects.

let argTuple = pyTuple(positionalArgs)

defer { Py_DecRef(argTuple) }

// Python calls always return a non-null object when successful. If the

// Python function produces the equivalent of C `void`, it returns the

// `None` object. A `null` result of `PyObjectCall` happens when there is an

// error, like `self` not being a Python callable.

let selfObject = base.ownedPyObject

defer { Py_DecRef(selfObject) }

guard let result = PyObject_Call(selfObject, argTuple, kwdictObject) else {

// If a Python exception was thrown, throw a corresponding Swift error.

try throwPythonErrorIfPresent()

throw PythonError.invalidCall(base)

}

return PythonObject(consuming: result)

}

/// Converts to a 2-tuple, if possible.

public var tuple2: (PythonObject, PythonObject)? {

let ct = base.checking

guard let elt0 = ct[0], let elt1 = ct[1] else {

return nil

}

return (elt0, elt1)

}

/// Converts to a 3-tuple, if possible.

public var tuple3: (PythonObject, PythonObject, PythonObject)? {

let ct = base.checking

guard let elt0 = ct[0], let elt1 = ct[1], let elt2 = ct[2] else {

return nil

}

return (elt0, elt1, elt2)

}

/// Converts to a 4-tuple, if possible.

public var tuple4: (PythonObject, PythonObject, PythonObject, PythonObject)? {

let ct = base.checking

guard let elt0 = ct[0], let elt1 = ct[1],

let elt2 = ct[2], let elt3 = ct[3] else {

return nil

}

return (elt0, elt1, elt2, elt3)

}

public var count: Int? {

base.checking.count

}

/// The underlying `PythonObject`.

private var base: PythonObject

fileprivate init(_ base: PythonObject) {

self.base = base

}

public subscript(dynamicMember name: String) -> PythonObject? {

get {

let selfObject = base.ownedPyObject

defer { Py_DecRef(selfObject) }

guard let result = PyObject_GetAttrString(selfObject, name) else {

PyErr_Clear()

return nil

}

// `PyObject_GetAttrString` returns +1 result.

return PythonObject(consuming: result)

}

}

/// Access the element corresponding to the specified `PythonConvertible`

/// values representing a key.

/// - Note: This is equivalent to `object[key]` in Python.

public subscript(key: [PythonConvertible]) -> PythonObject? {

get {

let keyObject = flattenedSubscriptIndices(key)

let selfObject = base.ownedPyObject

defer {

Py_DecRef(keyObject)

Py_DecRef(selfObject)

}

// `PyObject_GetItem` returns +1 reference.

if let result = PyObject_GetItem(selfObject, keyObject) {

return PythonObject(consuming: result)

}

PyErr_Clear()

return nil

}

nonmutating set {

let keyObject = flattenedSubscriptIndices(key)

let selfObject = base.ownedPyObject

defer {

Py_DecRef(keyObject)

Py_DecRef(selfObject)

}

if let newValue = newValue {

let newValueObject = newValue.ownedPyObject

PyObject_SetItem(selfObject, keyObject, newValueObject)

Py_DecRef(newValueObject)

} else {

// Assigning `nil` deletes the key, just like Swift dictionaries.

PyObject_DelItem(selfObject, keyObject)

}

}

}

/// Access the element corresponding to the specified `PythonConvertible`

/// values representing a key.

/// - Note: This is equivalent to `object[key]` in Python.

public subscript(key: PythonConvertible...) -> PythonObject? {

get {

return self[key]

}

nonmutating set {

self[key] = newValue

}

}

/// Converts to a 2-tuple, if possible.

public var tuple2: (PythonObject, PythonObject)? {

guard let elt0 = self[0], let elt1 = self[1] else {

return nil

}

return (elt0, elt1)

}

/// Converts to a 3-tuple, if possible.

public var tuple3: (PythonObject, PythonObject, PythonObject)? {

guard let elt0 = self[0], let elt1 = self[1], let elt2 = self[2] else {

return nil

}

return (elt0, elt1, elt2)

}

/// Converts to a 4-tuple, if possible.

public var tuple4: (PythonObject, PythonObject, PythonObject, PythonObject)? {

guard let elt0 = self[0], let elt1 = self[1],

let elt2 = self[2], let elt3 = self[3] else {

return nil

}

return (elt0, elt1, elt2, elt3)

}

public var count: Int? {

Int(Python.len(base))

}

_ indices: [PythonConvertible]) -> OwnedPyObjectPointer {

if indices.count == 1 {

return indices[0].ownedPyObject

}

return pyTuple(indices.map { $0.pythonObject })

get {

guard let member = checking[dynamicMember: memberName] else {

fatalError("Could not access PythonObject member '\(memberName)'")

}

return member

}

nonmutating set {

let selfObject = ownedPyObject

defer { Py_DecRef(selfObject) }

let valueObject = newValue.ownedPyObject

defer { Py_DecRef(valueObject) }

if PyObject_SetAttrString(selfObject, memberName, valueObject) == -1 {

try! throwPythonErrorIfPresent()

fatalError("""

Could not set PythonObject member '\(memberName)' to the specified \

}

}

get {

guard let item = checking[key] else {

fatalError("""

key values: \(key)

}

return item

}

nonmutating set {

checking[key] = newValue

}

guard let result = checking.tuple2 else {

fatalError("Could not convert PythonObject to a 2-element tuple")

}

return result

guard let result = checking.tuple3 else {

fatalError("Could not convert PythonObject to a 3-element tuple")

}

return result

guard let result = checking.tuple4 else {

fatalError("Could not convert PythonObject to a 4-element tuple")

}

return result

withKeywordArguments args:

KeyValuePairs<String, PythonConvertible> = [:]) -> PythonObject {

return try! throwing.dynamicallyCall(withKeywordArguments: args)

withKeywordArguments args:

[(key: String, value: PythonConvertible)] = []) -> PythonObject {

return try! throwing.dynamicallyCall(withKeywordArguments: args)

/// A dictionary of the Python builtins.

public let builtins: PythonObject

init() {

Py_Initialize() // Initialize Python

builtins = PythonObject(PyEval_GetBuiltins())

// Runtime Fixes:

PyRun_SimpleString("""

}

public func attemptImport(_ name: String) throws -> PythonObject {

guard let module = PyImport_ImportModule(name) else {

try throwPythonErrorIfPresent()

throw PythonError.invalidModule(name)

}

return PythonObject(consuming: module)

}

public func `import`(_ name: String) -> PythonObject {

return try! attemptImport(name)

}

public subscript(dynamicMember name: String) -> PythonObject {

return builtins[name]

}

// The Python runtime version.

// Equivalent to `sys.version` in Python.

public var version: PythonObject {

return self.import("sys").version

}

// The Python runtime version information.

// Equivalent to `sys.version_info` in Python.

public var versionInfo: PythonObject {

return self.import("sys").version_info

}

public func saveThread() -> PythonThreadState {

return PythonThreadState(ptr: PyEval_SaveThread())

}

public func restoreThread(_ t: PythonThreadState) {

PyEval_RestoreThread(t.ptr)

}

public func performWithGIL<T>(_ block: () -> T) -> T {

let state = PyGILState_Ensure()

defer {

PyGILState_Release(state)

}

return block()

}

/// Emulates a Python `with` statement.

/// - Parameter object: A context manager object.

/// - Parameter body: A closure to call on the result of `object.__enter__()`.

public func with(_ object: PythonObject, _ body: (PythonObject) throws -> Void) rethrows {

let yieldValue = object.__enter__()

try body(yieldValue)

yieldValue.__exit__()

}

where T.Element : PythonConvertible {

let tuple = PyTuple_New(vals.count)!

for (index, element) in vals.enumerated() {

// `PyTuple_SetItem` steals the reference of the object stored.

PyTuple_SetItem(tuple, index, element.ownedPyObject)

}

return tuple

type: PyObjectPointer) -> Bool {

let typePyRef = PythonObject(type)

let result = Python.isinstance(object, typePyRef)

// We cannot use the normal failable Bool initializer from `PythonObject`

// here because would cause an infinite loop.

let pyObject = result.ownedPyObject

defer { Py_DecRef(pyObject) }

// Anything not equal to `Py_ZeroStruct` is truthy.

return pyObject != _Py_ZeroStruct

_ = Python // Ensure Python is initialized.

let v = utf8CString.withUnsafeBufferPointer {

// 1 is subtracted from the C string length to trim the trailing null

// character (`\0`).

PyString_FromStringAndSize($0.baseAddress, $0.count - 1)!

}

return PythonObject(consuming: v)

withError errorValue: T, by converter: (OwnedPyObjectPointer) -> T

) -> T? {

let pyObject = ownedPyObject

defer { Py_DecRef(pyObject) }

assert(PyErr_Occurred() == nil,

"Python error occurred somewhere but wasn't handled")

let value = converter(pyObject)

guard value != errorValue || PyErr_Occurred() == nil else {

PyErr_Clear()

return nil

}

return value