{

[TearDown]

public void TearDown()

{

PyObjectConversions.Reset();

}

[Test]

public void TupleConversionsGeneric()

{

TupleConversionsGeneric<ValueTuple<int, string, object>, ValueTuple>();

}

static void TupleConversionsGeneric<T, TTuple>()

{

TupleCodec<TTuple>.Register();

var tuple = Activator.CreateInstance(typeof(T), 42, "42", new object());

T restored = default;

using (var scope = Py.CreateScope())

{

void Accept(T value) => restored = value;

using var accept = new Action<T>(Accept).ToPython();

scope.Set(nameof(tuple), tuple);

scope.Set(nameof(accept), accept);

scope.Exec($"{nameof(accept)}({nameof(tuple)})");

Assert.AreEqual(expected: tuple, actual: restored);

}

}

[Test]

public void TupleConversionsObject()

{

TupleConversionsObject<ValueTuple<double, string, object>, ValueTuple>();

}

static void TupleConversionsObject<T, TTuple>()

{

TupleCodec<TTuple>.Register();

var tuple = Activator.CreateInstance(typeof(T), 42.0, "42", new object());

T restored = default;

using (var scope = Py.CreateScope())

{

void Accept(object value) => restored = (T)value;

using var accept = new Action<object>(Accept).ToPython();

scope.Set(nameof(tuple), tuple);

scope.Set(nameof(accept), accept);

scope.Exec($"{nameof(accept)}({nameof(tuple)})");

Assert.AreEqual(expected: tuple, actual: restored);

}

}

[Test]

public void TupleRoundtripObject()

{

TupleRoundtripObject<ValueTuple<double, string, object>, ValueTuple>();

}

static void TupleRoundtripObject<T, TTuple>()

{

var tuple = Activator.CreateInstance(typeof(T), 42.0, "42", new object());

using var pyTuple = TupleCodec<TTuple>.Instance.TryEncode(tuple);

Assert.IsTrue(TupleCodec<TTuple>.Instance.TryDecode(pyTuple, out object restored));

Assert.AreEqual(expected: tuple, actual: restored);

}

[Test]

public void TupleRoundtripGeneric()

{

TupleRoundtripGeneric<ValueTuple<int, string, object>, ValueTuple>();

}

static void TupleRoundtripGeneric<T, TTuple>()

{

var tuple = Activator.CreateInstance(typeof(T), 42, "42", new object());

using var pyTuple = TupleCodec<TTuple>.Instance.TryEncode(tuple);

Assert.IsTrue(TupleCodec<TTuple>.Instance.TryDecode(pyTuple, out T restored));

Assert.AreEqual(expected: tuple, actual: restored);

}

static PyObject GetPythonIterable() => PythonEngine.Eval("map(lambda x: x, [1,2,3])");

[Test]

public void ListDecoderTest()

{

var codec = ListDecoder.Instance;

var items = new List<PyObject>() { new PyInt(1), new PyInt(2), new PyInt(3) };

using var pyList = new PyList(items.ToArray());

using var pyListType = pyList.GetPythonType();

Assert.IsTrue(codec.CanDecode(pyListType, typeof(IList<bool>)));

Assert.IsTrue(codec.CanDecode(pyListType, typeof(IList<int>)));

Assert.IsFalse(codec.CanDecode(pyListType, typeof(System.Collections.IEnumerable)));

Assert.IsFalse(codec.CanDecode(pyListType, typeof(IEnumerable<int>)));

Assert.IsFalse(codec.CanDecode(pyListType, typeof(ICollection<float>)));

Assert.IsFalse(codec.CanDecode(pyListType, typeof(bool)));

//we'd have to copy into a list instance to do this, it would not be lossless.

//lossy converters can be implemented outside of the python.net core library

Assert.IsFalse(codec.CanDecode(pyListType, typeof(List<int>)));

//convert to list of int

IList<int> intList = null;

Assert.DoesNotThrow(() => { codec.TryDecode(pyList, out intList); });

CollectionAssert.AreEqual(intList, new List<object> { 1, 2, 3 });

//convert to list of string. This will not work.

//The ListWrapper class will throw a python exception when it tries to access any element.

//TryDecode is a lossless conversion so there will be no exception at that point

//interestingly, since the size of the python list can be queried without any conversion,

//the IList will report a Count of 3.

IList<string> stringList = null;

Assert.DoesNotThrow(() => { codec.TryDecode(pyList, out stringList); });

Assert.AreEqual(stringList.Count, 3);

Assert.Throws(typeof(InvalidCastException), () => { var x = stringList[0]; });

//can't convert python iterable to list (this will require a copy which isn't lossless)

using var foo = GetPythonIterable();

using var fooType = foo.GetPythonType();

Assert.IsFalse(codec.CanDecode(fooType, typeof(IList<int>)));

}

[Test]

public void SequenceDecoderTest()

{

var codec = SequenceDecoder.Instance;

var items = new List<PyObject>() { new PyInt(1), new PyInt(2), new PyInt(3) };

//SequenceConverter can only convert to any ICollection

using var pyList = new PyList(items.ToArray());

using var listType = pyList.GetPythonType();

//it can convert a PyList, since PyList satisfies the python sequence protocol

Assert.IsFalse(codec.CanDecode(listType, typeof(bool)));

Assert.IsFalse(codec.CanDecode(listType, typeof(IList<int>)));

Assert.IsFalse(codec.CanDecode(listType, typeof(System.Collections.IEnumerable)));

Assert.IsFalse(codec.CanDecode(listType, typeof(IEnumerable<int>)));

Assert.IsTrue(codec.CanDecode(listType, typeof(ICollection<float>)));

Assert.IsTrue(codec.CanDecode(listType, typeof(ICollection<string>)));

Assert.IsTrue(codec.CanDecode(listType, typeof(ICollection<int>)));

//convert to collection of int

ICollection<int> intCollection = null;

Assert.DoesNotThrow(() => { codec.TryDecode(pyList, out intCollection); });

CollectionAssert.AreEqual(intCollection, new List<object> { 1, 2, 3 });

//no python exception should have occurred during the above conversion and check

Runtime.CheckExceptionOccurred();

//convert to collection of string. This will not work.

//The SequenceWrapper class will throw a python exception when it tries to access any element.

//TryDecode is a lossless conversion so there will be no exception at that point

//interestingly, since the size of the python sequence can be queried without any conversion,

//the IList will report a Count of 3.

ICollection<string> stringCollection = null;

Assert.DoesNotThrow(() => { codec.TryDecode(pyList, out stringCollection); });

Assert.AreEqual(3, stringCollection.Count());

Assert.Throws(typeof(InvalidCastException), () => {

string[] array = new string[3];

stringCollection.CopyTo(array, 0);

});

Runtime.CheckExceptionOccurred();

//can't convert python iterable to collection (this will require a copy which isn't lossless)

//python iterables do not satisfy the python sequence protocol

var foo = GetPythonIterable();

var fooType = foo.GetPythonType();

Assert.IsFalse(codec.CanDecode(fooType, typeof(ICollection<int>)));

//python tuples do satisfy the python sequence protocol

var pyTuple = new PyTuple(items.ToArray());

var pyTupleType = pyTuple.GetPythonType();

Assert.IsTrue(codec.CanDecode(pyTupleType, typeof(ICollection<float>)));

Assert.IsTrue(codec.CanDecode(pyTupleType, typeof(ICollection<int>)));

Assert.IsTrue(codec.CanDecode(pyTupleType, typeof(ICollection<string>)));

//convert to collection of int

ICollection<int> intCollection2 = null;

Assert.DoesNotThrow(() => { codec.TryDecode(pyTuple, out intCollection2); });

CollectionAssert.AreEqual(intCollection2, new List<object> { 1, 2, 3 });

//no python exception should have occurred during the above conversion and check

Runtime.CheckExceptionOccurred();

//convert to collection of string. This will not work.

//The SequenceWrapper class will throw a python exception when it tries to access any element.

//TryDecode is a lossless conversion so there will be no exception at that point

//interestingly, since the size of the python sequence can be queried without any conversion,

//the IList will report a Count of 3.

ICollection<string> stringCollection2 = null;

Assert.DoesNotThrow(() => { codec.TryDecode(pyTuple, out stringCollection2); });

Assert.AreEqual(3, stringCollection2.Count());

Assert.Throws(typeof(InvalidCastException), () => {

string[] array = new string[3];

stringCollection2.CopyTo(array, 0);

});

Runtime.CheckExceptionOccurred();

}

[Test]

public void IterableDecoderTest()

{

var codec = IterableDecoder.Instance;

var items = new List<PyObject>() { new PyInt(1), new PyInt(2), new PyInt(3) };

var pyList = new PyList(items.ToArray());

var pyListType = pyList.GetPythonType();

Assert.IsFalse(codec.CanDecode(pyListType, typeof(IList<bool>)));

Assert.IsTrue(codec.CanDecode(pyListType, typeof(System.Collections.IEnumerable)));

Assert.IsTrue(codec.CanDecode(pyListType, typeof(IEnumerable<int>)));

Assert.IsFalse(codec.CanDecode(pyListType, typeof(ICollection<float>)));

Assert.IsFalse(codec.CanDecode(pyListType, typeof(bool)));

//ensure a PyList can be converted to a plain IEnumerable

System.Collections.IEnumerable plainEnumerable1 = null;

Assert.DoesNotThrow(() => { codec.TryDecode(pyList, out plainEnumerable1); });

CollectionAssert.AreEqual(plainEnumerable1.Cast<PyInt>().Select(i => i.ToInt32()), new List<object> { 1, 2, 3 });

//can convert to any generic ienumerable. If the type is not assignable from the python element

//it will lead to an empty iterable when decoding. TODO - should it throw?

Assert.IsTrue(codec.CanDecode(pyListType, typeof(IEnumerable<int>)));

Assert.IsTrue(codec.CanDecode(pyListType, typeof(IEnumerable<double>)));

Assert.IsTrue(codec.CanDecode(pyListType, typeof(IEnumerable<string>)));

IEnumerable<int> intEnumerable = null;

Assert.DoesNotThrow(() => { codec.TryDecode(pyList, out intEnumerable); });

CollectionAssert.AreEqual(intEnumerable, new List<object> { 1, 2, 3 });

Runtime.CheckExceptionOccurred();

IEnumerable<double> doubleEnumerable = null;

Assert.DoesNotThrow(() => { codec.TryDecode(pyList, out doubleEnumerable); });

CollectionAssert.AreEqual(doubleEnumerable, new List<object> { 1, 2, 3 });

Runtime.CheckExceptionOccurred();

IEnumerable<string> stringEnumerable = null;

Assert.DoesNotThrow(() => { codec.TryDecode(pyList, out stringEnumerable); });

Assert.Throws(typeof(InvalidCastException), () => {

foreach (string item in stringEnumerable)

{

var x = item;

}

});

Assert.Throws(typeof(InvalidCastException), () => {

stringEnumerable.Count();

});

Runtime.CheckExceptionOccurred();

//ensure a python class which implements the iterator protocol can be converter to a plain IEnumerable

var foo = GetPythonIterable();

var fooType = foo.GetPythonType();

System.Collections.IEnumerable plainEnumerable2 = null;

Assert.DoesNotThrow(() => { codec.TryDecode(pyList, out plainEnumerable2); });

CollectionAssert.AreEqual(plainEnumerable2.Cast<PyInt>().Select(i => i.ToInt32()), new List<object> { 1, 2, 3 });

//can convert to any generic ienumerable. If the type is not assignable from the python element

//it will be an exception during TryDecode

Assert.IsTrue(codec.CanDecode(fooType, typeof(IEnumerable<int>)));

Assert.IsTrue(codec.CanDecode(fooType, typeof(IEnumerable<double>)));

Assert.IsTrue(codec.CanDecode(fooType, typeof(IEnumerable<string>)));

Assert.DoesNotThrow(() => { codec.TryDecode(pyList, out intEnumerable); });

CollectionAssert.AreEqual(intEnumerable, new List<object> { 1, 2, 3 });

}

// regression for https://github.com/pythonnet/pythonnet/issues/1427

[Test]

public void PythonRegisteredDecoder_NoStackOverflowOnSystemType()

{

const string PyCode = @"

PythonEngine.Exec(PyCode);

}

const string TestExceptionMessage = "Hello World!";

[Test]

public void ExceptionEncoded()

{

PyObjectConversions.RegisterEncoder(new ValueErrorCodec());

void CallMe() => throw new ValueErrorWrapper(TestExceptionMessage);

var callMeAction = new Action(CallMe);

using var scope = Py.CreateScope();

scope.Exec(@"

var callFunc = scope.Get("call");

string message = callFunc.Invoke(callMeAction.ToPython()).As<string>();

Assert.AreEqual(TestExceptionMessage, message);

}

[Test]

public void ExceptionDecoded()

{

PyObjectConversions.RegisterDecoder(new ValueErrorCodec());

using var scope = Py.CreateScope();

var error = Assert.Throws<ValueErrorWrapper>(()

=> PythonEngine.Exec($"raise ValueError('{TestExceptionMessage}')"));

Assert.AreEqual(TestExceptionMessage, error.Message);

}

[Test]

public void DateTimeDecoded()

{

using var scope = Py.CreateScope();

scope.Exec(@"

scope.Exec("Codecs.AcceptsDateTime(datetime(2021, 1, 22))");

}

[Test]

public void FloatDerivedDecoded()

{

using var scope = Py.CreateScope();

scope.Exec(@"class FloatDerived(float): pass");

using var floatDerived = scope.Eval("FloatDerived");

var decoder = new DecoderReturningPredefinedValue<object>(floatDerived, 42);

PyObjectConversions.RegisterDecoder(decoder);

using var result = scope.Eval("FloatDerived()");

object decoded = result.As<object>();

Assert.AreEqual(42, decoded);

}

[Test]

public void ExceptionDecodedNoInstance()

{

if (Runtime.PyVersion < new Version(3, 12))

{

PyObjectConversions.RegisterDecoder(new InstancelessExceptionDecoder());

using var scope = Py.CreateScope();

var error = Assert.Throws<ValueErrorWrapper>(() =>

PythonEngine.Exec($"[].__iter__().__next__()")

);

Assert.AreEqual(TestExceptionMessage, error.Message);

}

else

{

Assert.Ignore(

"This test does not work for Python 3.12, see " +

"https://github.com/python/cpython/issues/101578"

);

}

}

public static void AcceptsDateTime(DateTime v) {}

[Test]

public void As_Object_AffectedByDecoders()

{

var everythingElseToSelf = new EverythingElseToSelfDecoder();

PyObjectConversions.RegisterDecoder(everythingElseToSelf);

var pyObj = PythonEngine.Eval("iter");

var decoded = pyObj.As<object>();

Assert.AreSame(everythingElseToSelf, decoded);

}

public class EverythingElseToSelfDecoder : IPyObjectDecoder

{

public bool CanDecode(PyType objectType, Type targetType)

{

return targetType.IsAssignableFrom(typeof(EverythingElseToSelfDecoder));

}

public bool TryDecode<T>(PyObject pyObj, out T value)

{

value = (T)(object)this;

return true;

}

}

class ValueErrorWrapper : Exception

{

public ValueErrorWrapper(string message) : base(message) { }

}

class ValueErrorCodec : IPyObjectEncoder, IPyObjectDecoder

{

public bool CanDecode(PyType objectType, Type targetType)

=> this.CanEncode(targetType)

&& PythonReferenceComparer.Instance.Equals(objectType, PythonEngine.Eval("ValueError"));

public bool CanEncode(Type type) => type == typeof(ValueErrorWrapper)

|| typeof(ValueErrorWrapper).IsSubclassOf(type);

public bool TryDecode<T>(PyObject pyObj, out T value)

{

var message = pyObj.GetAttr("args")[0].As<string>();

value = (T)(object)new ValueErrorWrapper(message);

return true;

}

public PyObject TryEncode(object value)

{

var error = (ValueErrorWrapper)value;

return PythonEngine.Eval("ValueError").Invoke(error.Message.ToPython());

}

}

class InstancelessExceptionDecoder : IPyObjectDecoder, IDisposable

{

readonly PyObject PyErr = Py.Import("clr.interop").GetAttr("PyErr");

public bool CanDecode(PyType objectType, Type targetType)

=> PythonReferenceComparer.Instance.Equals(PyErr, objectType);

public void Dispose()

{

PyErr.Dispose();

}

public bool TryDecode<T>(PyObject pyObj, out T value)

{

if (pyObj.HasAttr("value"))

{

value = default;

return false;

}

value = (T)(object)new ValueErrorWrapper(TestExceptionMessage);

return true;

}

}

{

public bool CanEncode(Type type) => type == typeof(T);

public PyObject TryEncode(object value) => PyObject.FromManagedObject(this);

{

public PyObject TheOnlySupportedSourceType { get; }

public TTarget DecodeResult { get; }

public DecoderReturningPredefinedValue(PyObject objectType, TTarget decodeResult)

{

this.TheOnlySupportedSourceType = objectType;

this.DecodeResult = decodeResult;

}

public bool CanDecode(PyType objectType, Type targetType)

=> PythonReferenceComparer.Instance.Equals(objectType, TheOnlySupportedSourceType)

&& targetType == typeof(TTarget);

public bool TryDecode<T>(PyObject pyObj, out T value)

{

if (typeof(T) != typeof(TTarget))

throw new ArgumentException(nameof(T));

value = (T)(object)DecodeResult;

return true;

}

{

public static void Setup()

{

PyObjectConversions.RegisterDecoder(new DateTimeDecoder());

}

public bool CanDecode(PyType objectType, Type targetType)

{

return targetType == typeof(DateTime);

}

public bool TryDecode<T>(PyObject pyObj, out T value)

{

var dt = new DateTime(

pyObj.GetAttr("year").As<int>(),

pyObj.GetAttr("month").As<int>(),

pyObj.GetAttr("day").As<int>(),

pyObj.GetAttr("hour").As<int>(),

pyObj.GetAttr("minute").As<int>(),

pyObj.GetAttr("second").As<int>());

value = (T)(object)dt;

return true;

}