pythonnet 3.0.3__tar.gz → 3.0.4__tar.gz

{pythonnet-3.0.3 → pythonnet-3.0.4}/AUTHORS.md

@@ -38,6 +38,7 @@
 -   Dmitriy Se ([@dmitriyse](https://github.com/dmitriyse))
 -   Félix Bourbonnais ([@BadSingleton](https://github.com/BadSingleton))
 -   Florian Treurniet ([@ftreurni](https://github.com/ftreurni))
+-   Frank Witscher ([@Frawak](https://github.com/Frawak))
 -   He-chien Tsai ([@t3476](https://github.com/t3476))
 -   Inna Wiesel ([@inna-w](https://github.com/inna-w))
 -   Ivan Cronyn ([@cronan](https://github.com/cronan))
@@ -86,3 +87,4 @@
 -   ([@gpetrou](https://github.com/gpetrou))
 -   Ehsan Iran-Nejad ([@eirannejad](https://github.com/eirannejad))
 -   ([@legomanww](https://github.com/legomanww))
+-   ([@gertdreyer](https://github.com/gertdreyer))

{pythonnet-3.0.3/pythonnet.egg-info → pythonnet-3.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pythonnet
-Version: 3.0.3
+Version: 3.0.4
 Summary: .NET and Mono integration for Python
 Author-email: "The Contributors of the Python.NET Project" <pythonnet@python.org>
 License: MIT

{pythonnet-3.0.3 → pythonnet-3.0.4/pythonnet.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pythonnet
-Version: 3.0.3
+Version: 3.0.4
 Summary: .NET and Mono integration for Python
 Author-email: "The Contributors of the Python.NET Project" <pythonnet@python.org>
 License: MIT

pythonnet-3.0.4/pythonnet.egg-info/SOURCES.txt

@@ -0,0 +1,200 @@
+AUTHORS.md
+Directory.Build.props
+LICENSE
+MANIFEST.in
+README.rst
+clr.py
+pyproject.toml
+pythonnet.sln
+setup.py
+version.txt
+pythonnet/__init__.py
+pythonnet.egg-info/PKG-INFO
+pythonnet.egg-info/SOURCES.txt
+pythonnet.egg-info/dependency_links.txt
+pythonnet.egg-info/not-zip-safe
+pythonnet.egg-info/requires.txt
+pythonnet.egg-info/top_level.txt
+src/pythonnet.snk
+src/runtime/AssemblyManager.cs
+src/runtime/ClassManager.cs
+src/runtime/Converter.cs
+src/runtime/DefaultBaseTypeProvider.cs
+src/runtime/DelegateManager.cs
+src/runtime/Exceptions.cs
+src/runtime/Finalizer.cs
+src/runtime/IPythonBaseTypeProvider.cs
+src/runtime/ImportHook.cs
+src/runtime/Interfaces.cs
+src/runtime/InternString.cs
+src/runtime/InternalPythonnetException.cs
+src/runtime/Interop.cs
+src/runtime/InteropConfiguration.cs
+src/runtime/Loader.cs
+src/runtime/MethodBinder.cs
+src/runtime/Py.cs
+src/runtime/PyExportAttribute.cs
+src/runtime/Python.Runtime.csproj
+src/runtime/PythonBaseTypeProviderGroup.cs
+src/runtime/PythonEngine.cs
+src/runtime/PythonException.cs
+src/runtime/README.md
+src/runtime/Runtime.Delegates.cs
+src/runtime/Runtime.cs
+src/runtime/RuntimeState.cs
+src/runtime/TypeManager.cs
+src/runtime/Codecs/DecoderGroup.cs
+src/runtime/Codecs/EncoderGroup.cs
+src/runtime/Codecs/EnumPyIntCodec.cs
+src/runtime/Codecs/IPyObjectDecoder.cs
+src/runtime/Codecs/IPyObjectEncoder.cs
+src/runtime/Codecs/IterableDecoder.cs
+src/runtime/Codecs/ListDecoder.cs
+src/runtime/Codecs/PyObjectConversions.cs
+src/runtime/Codecs/RawProxyEncoder.cs
+src/runtime/Codecs/SequenceDecoder.cs
+src/runtime/Codecs/TupleCodecs.cs
+src/runtime/CollectionWrappers/IterableWrapper.cs
+src/runtime/CollectionWrappers/ListWrapper.cs
+src/runtime/CollectionWrappers/SequenceWrapper.cs
+src/runtime/Mixins/CollectionMixinsProvider.cs
+src/runtime/Mixins/collections.py
+src/runtime/Native/ABI.cs
+src/runtime/Native/BorrowedReference.cs
+src/runtime/Native/CustomMarshaler.cs
+src/runtime/Native/GeneratedTypeOffsets.cs
+src/runtime/Native/ITypeOffsets.cs
+src/runtime/Native/LibDL.cs
+src/runtime/Native/LibraryLoader.cs
+src/runtime/Native/NativeCall.cs
+src/runtime/Native/NativeFunc.cs
+src/runtime/Native/NativeTypeSpec.cs
+src/runtime/Native/NewReference.cs
+src/runtime/Native/PyBufferInterface.cs
+src/runtime/Native/PyCompilerFlags.cs
+src/runtime/Native/PyGILState.cs
+src/runtime/Native/PyIdentifier_.cs
+src/runtime/Native/PyIdentifier_.tt
+src/runtime/Native/PyInterpreterState.cs
+src/runtime/Native/PyMemberFlags.cs
+src/runtime/Native/PyMemberType.cs
+src/runtime/Native/PyMethodFlags.cs
+src/runtime/Native/PyThreadState.cs
+src/runtime/Native/ReferenceExtensions.cs
+src/runtime/Native/StolenReference.cs
+src/runtime/Native/StrPtr.cs
+src/runtime/Native/TypeOffset.cs
+src/runtime/Native/TypeOffset310.cs
+src/runtime/Native/TypeOffset311.cs
+src/runtime/Native/TypeOffset312.cs
+src/runtime/Native/TypeOffset37.cs
+src/runtime/Native/TypeOffset38.cs
+src/runtime/Native/TypeOffset39.cs
+src/runtime/Properties/AssemblyInfo.cs
+src/runtime/PythonTypes/PyBuffer.cs
+src/runtime/PythonTypes/PyDict.cs
+src/runtime/PythonTypes/PyFloat.IComparable.cs
+src/runtime/PythonTypes/PyFloat.cs
+src/runtime/PythonTypes/PyInt.IComparable.cs
+src/runtime/PythonTypes/PyInt.cs
+src/runtime/PythonTypes/PyIter.cs
+src/runtime/PythonTypes/PyIterable.cs
+src/runtime/PythonTypes/PyList.cs
+src/runtime/PythonTypes/PyModule.cs
+src/runtime/PythonTypes/PyNumber.cs
+src/runtime/PythonTypes/PyObject.IConvertible.cs
+src/runtime/PythonTypes/PyObject.cs
+src/runtime/PythonTypes/PySequence.cs
+src/runtime/PythonTypes/PyString.cs
+src/runtime/PythonTypes/PyTuple.cs
+src/runtime/PythonTypes/PyType.cs
+src/runtime/PythonTypes/TypeSpec.cs
+src/runtime/Resources/clr.py
+src/runtime/Resources/interop.py
+src/runtime/StateSerialization/CLRMappedItem.cs
+src/runtime/StateSerialization/CLRWrapperCollection.cs
+src/runtime/StateSerialization/ClassManagerState.cs
+src/runtime/StateSerialization/ICLRObjectStorer.cs
+src/runtime/StateSerialization/ImportHookState.cs
+src/runtime/StateSerialization/MaybeMemberInfo.cs
+src/runtime/StateSerialization/MaybeMethodBase.cs
+src/runtime/StateSerialization/MaybeType.cs
+src/runtime/StateSerialization/MetatypeState.cs
+src/runtime/StateSerialization/NoopFormatter.cs
+src/runtime/StateSerialization/PythonNetState.cs
+src/runtime/StateSerialization/RuntimeData.cs
+src/runtime/StateSerialization/SharedObjectsState.cs
+src/runtime/StateSerialization/TypeManagerState.cs
+src/runtime/StateSerialization/UnloadedClass.cs
+src/runtime/Types/ArrayObject.cs
+src/runtime/Types/ClassBase.cs
+src/runtime/Types/ClassDerived.cs
+src/runtime/Types/ClassObject.cs
+src/runtime/Types/ClrModule.cs
+src/runtime/Types/ClrObject.cs
+src/runtime/Types/DelegateObject.cs
+src/runtime/Types/EventBinding.cs
+src/runtime/Types/EventObject.cs
+src/runtime/Types/ExceptionClassObject.cs
+src/runtime/Types/ExtensionType.cs
+src/runtime/Types/FieldObject.cs
+src/runtime/Types/GenericType.cs
+src/runtime/Types/Indexer.cs
+src/runtime/Types/InterfaceObject.cs
+src/runtime/Types/Iterator.cs
+src/runtime/Types/ManagedType.cs
+src/runtime/Types/ManagedTypes.cd
+src/runtime/Types/MetaType.cs
+src/runtime/Types/MethodBinding.cs
+src/runtime/Types/MethodObject.cs
+src/runtime/Types/ModuleFunctionObject.cs
+src/runtime/Types/ModuleObject.cs
+src/runtime/Types/ModulePropertyObject.cs
+src/runtime/Types/MpLengthSlot.cs
+src/runtime/Types/OperatorMethod.cs
+src/runtime/Types/OverloadMapper.cs
+src/runtime/Types/PropertyObject.cs
+src/runtime/Types/ReflectedClrType.cs
+src/runtime/Types/UnsafeReferenceWithRun.cs
+src/runtime/Util/CodeGenerator.cs
+src/runtime/Util/DebugUtil.cs
+src/runtime/Util/Encodings.cs
+src/runtime/Util/EventHandlerCollection.cs
+src/runtime/Util/GenericUtil.cs
+src/runtime/Util/InitOnly.cs
+src/runtime/Util/NonCopyableAttribute.cs
+src/runtime/Util/NullOnly.cs
+src/runtime/Util/OpsHelper.cs
+src/runtime/Util/ParameterHelper.cs
+src/runtime/Util/PythonReferenceComparer.cs
+src/runtime/Util/ReflectionPolyfills.cs
+src/runtime/Util/ReflectionUtil.cs
+src/runtime/Util/Util.cs
+tests/test_array.py
+tests/test_callback.py
+tests/test_class.py
+tests/test_clrmethod.py
+tests/test_codec.py
+tests/test_collection_mixins.py
+tests/test_constructors.py
+tests/test_conversion.py
+tests/test_delegate.py
+tests/test_docstring.py
+tests/test_engine.py
+tests/test_enum.py
+tests/test_event.py
+tests/test_exceptions.py
+tests/test_field.py
+tests/test_generic.py
+tests/test_import.py
+tests/test_indexer.py
+tests/test_interface.py
+tests/test_method.py
+tests/test_module.py
+tests/test_mp_length.py
+tests/test_property.py
+tests/test_recursive_types.py
+tests/test_repr.py
+tests/test_subclass.py
+tests/test_sysargv.py
+tests/test_thread.py

{pythonnet-3.0.3 → pythonnet-3.0.4}/src/runtime/AssemblyManager.cs

@@ -200,6 +200,13 @@ namespace Python.Runtime
                 }
                 else
                 {
+                    int invalidCharIndex = head.IndexOfAny(Path.GetInvalidPathChars());
+                    if (invalidCharIndex >= 0)
+                    {
+                        using var importWarning = Runtime.PyObject_GetAttrString(Exceptions.exceptions_module, "ImportWarning");
+                        Exceptions.warn($"Path entry '{head}' has invalid char at position {invalidCharIndex}", importWarning.BorrowOrThrow());
+                        continue;
+                    }
                     path = Path.Combine(head, name);
                 }
 

{pythonnet-3.0.3 → pythonnet-3.0.4}/src/runtime/ClassManager.cs

@@ -290,11 +290,13 @@ namespace Python.Runtime
 
         internal static bool ShouldBindMethod(MethodBase mb)
         {
+            if (mb is null) throw new ArgumentNullException(nameof(mb));
             return (mb.IsPublic || mb.IsFamily || mb.IsFamilyOrAssembly);
         }
 
         internal static bool ShouldBindField(FieldInfo fi)
         {
+            if (fi is null) throw new ArgumentNullException(nameof(fi));
             return (fi.IsPublic || fi.IsFamily || fi.IsFamilyOrAssembly);
         }
 
@@ -326,7 +328,7 @@ namespace Python.Runtime
 
         internal static bool ShouldBindEvent(EventInfo ei)
         {
-            return ShouldBindMethod(ei.GetAddMethod(true));
+            return ei.GetAddMethod(true) is { } add && ShouldBindMethod(add);
         }
 
         private static ClassInfo GetClassInfo(Type type, ClassBase impl)
@@ -546,7 +548,7 @@ namespace Python.Runtime
                         ci.members[pyName] = new MethodObject(type, name, forwardMethods).AllocObject();
                     // Only methods where only the right operand is the declaring type.
                     if (reverseMethods.Length > 0)
-                        ci.members[pyNameReverse] = new MethodObject(type, name, reverseMethods).AllocObject();
+                        ci.members[pyNameReverse] = new MethodObject(type, name, reverseMethods, argsReversed: true).AllocObject();
                 }
             }
 

{pythonnet-3.0.3 → pythonnet-3.0.4}/src/runtime/CollectionWrappers/IterableWrapper.cs

@@ -24,18 +24,22 @@ namespace Python.Runtime.CollectionWrappers
             {
                 iterObject = PyIter.GetIter(pyObject);
             }
-
-            using var _ = iterObject;
-            while (true)
+            try
             {
-                using var GIL = Py.GIL();
-
-                if (!iterObject.MoveNext())
+                while (true)
                 {
-                    iterObject.Dispose();
-                    break;
+                    using var _ = Py.GIL();
+                    if (!iterObject.MoveNext())
+                    {
+                        break;
+                    }
+                    yield return iterObject.Current.As<T>()!;
                 }
-                yield return iterObject.Current.As<T>()!;
+            }
+            finally
+            {
+                using var _ = Py.GIL();
+                iterObject.Dispose();
             }
         }
     }

{pythonnet-3.0.3 → pythonnet-3.0.4}/src/runtime/Converter.cs

@@ -133,7 +133,8 @@ namespace Python.Runtime
             if (EncodableByUser(type, value))
             {
                 var encoded = PyObjectConversions.TryEncode(value, type);
-                if (encoded != null) {
+                if (encoded != null)
+                {
                     return new NewReference(encoded);
                 }
             }
@@ -334,7 +335,7 @@ namespace Python.Runtime
 
             if (obType.IsGenericType && obType.GetGenericTypeDefinition() == typeof(Nullable<>))
             {
-                if( value == Runtime.PyNone )
+                if (value == Runtime.PyNone)
                 {
                     result = null;
                     return true;
@@ -980,5 +981,11 @@ namespace Python.Runtime
             if (o is null) return Runtime.None;
             return Converter.ToPython(o, o.GetType()).MoveToPyObject();
         }
+
+        public static PyObject ToPythonAs<T>(this T? o)
+        {
+            if (o is null) return Runtime.None;
+            return Converter.ToPython(o, typeof(T)).MoveToPyObject();
+        }
     }
 }

{pythonnet-3.0.3 → pythonnet-3.0.4}/src/runtime/Exceptions.cs

@@ -270,7 +270,7 @@ namespace Python.Runtime
             }
 
             using var warn = Runtime.PyObject_GetAttrString(warnings_module.obj, "warn");
-            Exceptions.ErrorCheck(warn.Borrow());
+            warn.BorrowOrThrow();
 
             using var argsTemp = Runtime.PyTuple_New(3);
             BorrowedReference args = argsTemp.BorrowOrThrow();
@@ -283,7 +283,7 @@ namespace Python.Runtime
             Runtime.PyTuple_SetItem(args, 2, level.StealOrThrow());
 
             using var result = Runtime.PyObject_CallObject(warn.Borrow(), args);
-            Exceptions.ErrorCheck(result.Borrow());
+            result.BorrowOrThrow();
         }
 
         public static void warn(string message, BorrowedReference exception)

{pythonnet-3.0.3 → pythonnet-3.0.4}/src/runtime/Finalizer.cs

@@ -191,7 +191,7 @@ namespace Python.Runtime
             Instance.started = false;
         }
 
-        internal nint DisposeAll()
+        internal nint DisposeAll(bool disposeObj = true, bool disposeDerived = true, bool disposeBuffer = true)
         {
             if (_objQueue.IsEmpty && _derivedQueue.IsEmpty && _bufferQueue.IsEmpty)
                 return 0;
@@ -216,7 +216,7 @@ namespace Python.Runtime
 
                 try
                 {
-                    while (!_objQueue.IsEmpty)
+                    if (disposeObj) while (!_objQueue.IsEmpty)
                     {
                         if (!_objQueue.TryDequeue(out var obj))
                             continue;
@@ -240,7 +240,7 @@ namespace Python.Runtime
                         }
                     }
 
-                    while (!_derivedQueue.IsEmpty)
+                    if (disposeDerived) while (!_derivedQueue.IsEmpty)
                     {
                         if (!_derivedQueue.TryDequeue(out var derived))
                             continue;
@@ -258,7 +258,7 @@ namespace Python.Runtime
                         collected++;
                     }
 
-                    while (!_bufferQueue.IsEmpty)
+                    if (disposeBuffer) while (!_bufferQueue.IsEmpty)
                     {
                         if (!_bufferQueue.TryDequeue(out var buffer))
                             continue;

pythonnet-3.0.4/src/runtime/InternalPythonnetException.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Python.Runtime;
+
+public class InternalPythonnetException : Exception
+{
+    public InternalPythonnetException(string message, Exception innerException)
+        : base(message, innerException) { }
+}

{pythonnet-3.0.3 → pythonnet-3.0.4}/src/runtime/Loader.cs

@@ -12,7 +12,7 @@ namespace Python.Runtime
         {
             try
             {
-                var dllPath = Encoding.UTF8.GetString((byte*)data.ToPointer(), size);
+                var dllPath = Encodings.UTF8.GetString((byte*)data.ToPointer(), size);
 
                 if (!string.IsNullOrEmpty(dllPath))
                 {
@@ -33,7 +33,7 @@ namespace Python.Runtime
                 );
                 return 1;
             }
-            
+
             return 0;
         }
 
@@ -41,7 +41,7 @@ namespace Python.Runtime
         {
             try
             {
-                var command = Encoding.UTF8.GetString((byte*)data.ToPointer(), size);
+                var command = Encodings.UTF8.GetString((byte*)data.ToPointer(), size);
 
                 if (command == "full_shutdown")
                 {

{pythonnet-3.0.3 → pythonnet-3.0.4}/src/runtime/MethodBinder.cs

@@ -28,9 +28,12 @@ namespace Python.Runtime
 
         [NonSerialized]
         public bool init = false;
+
         public const bool DefaultAllowThreads = true;
         public bool allow_threads = DefaultAllowThreads;
 
+        public bool argsReversed = false;
+
         internal MethodBinder()
         {
             list = new List<MaybeMethodBase>();
@@ -363,10 +366,10 @@ namespace Python.Runtime
                 _methods = GetMethods();
             }
 
-            return Bind(inst, args, kwargDict, _methods, matchGenerics: true);
+            return Bind(inst, args, kwargDict, _methods, matchGenerics: true, argsReversed);
         }
 
-        static Binding? Bind(BorrowedReference inst, BorrowedReference args, Dictionary<string, PyObject> kwargDict, MethodBase[] methods, bool matchGenerics)
+        private static Binding? Bind(BorrowedReference inst, BorrowedReference args, Dictionary<string, PyObject> kwargDict, MethodBase[] methods, bool matchGenerics, bool argsReversed = false)
         {
             var pynargs = (int)Runtime.PyTuple_Size(args);
             var isGeneric = false;
@@ -386,7 +389,7 @@ namespace Python.Runtime
                 // Binary operator methods will have 2 CLR args but only one Python arg
                 // (unary operators will have 1 less each), since Python operator methods are bound.
                 isOperator = isOperator && pynargs == pi.Length - 1;
-                bool isReverse = isOperator && OperatorMethod.IsReverse((MethodInfo)mi);  // Only cast if isOperator.
+                bool isReverse = isOperator && argsReversed;  // Only cast if isOperator.
                 if (isReverse && OperatorMethod.IsComparisonOp((MethodInfo)mi))
                     continue;  // Comparison operators in Python have no reverse mode.
                 if (!MatchesArgumentCount(pynargs, pi, kwargDict, out bool paramsArray, out ArrayList? defaultArgList, out int kwargsMatched, out int defaultsNeeded) && !isOperator)
@@ -394,12 +397,14 @@ namespace Python.Runtime
                     continue;
                 }
                 // Preprocessing pi to remove either the first or second argument.
-                if (isOperator && !isReverse) {
+                if (isOperator && !isReverse)
+                {
                     // The first Python arg is the right operand, while the bound instance is the left.
                     // We need to skip the first (left operand) CLR argument.
                     pi = pi.Skip(1).ToArray();
                 }
-                else if (isOperator && isReverse) {
+                else if (isOperator && isReverse)
+                {
                     // The first Python arg is the left operand.
                     // We need to take the first CLR argument.
                     pi = pi.Take(1).ToArray();

{pythonnet-3.0.3 → pythonnet-3.0.4}/src/runtime/Native/CustomMarshaler.cs

@@ -42,7 +42,7 @@ namespace Python.Runtime
     internal class UcsMarshaler : MarshalerBase
     {
         internal static readonly int _UCS = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? 2 : 4;
-        internal static readonly Encoding PyEncoding = _UCS == 2 ? Encoding.Unicode : Encoding.UTF32;
+        internal static readonly Encoding PyEncoding = _UCS == 2 ? Encodings.UTF16 : Encodings.UTF32;
         private static readonly MarshalerBase Instance = new UcsMarshaler();
 
         public override IntPtr MarshalManagedToNative(object managedObj)

{pythonnet-3.0.3 → pythonnet-3.0.4}/src/runtime/Native/NativeTypeSpec.cs

@@ -17,7 +17,7 @@ namespace Python.Runtime.Native
         {
             if (spec is null) throw new ArgumentNullException(nameof(spec));
 
-            this.Name = new StrPtr(spec.Name, Encoding.UTF8);
+            this.Name = new StrPtr(spec.Name);
             this.BasicSize = spec.BasicSize;
             this.ItemSize = spec.ItemSize;
             this.Flags = (int)spec.Flags;

{pythonnet-3.0.3 → pythonnet-3.0.4}/src/runtime/Native/StrPtr.cs

@@ -10,6 +10,8 @@ namespace Python.Runtime.Native
         public IntPtr RawPointer { get; set; }
         unsafe byte* Bytes => (byte*)this.RawPointer;
 
+        public unsafe StrPtr(string value) : this(value, Encodings.UTF8) {}
+
         public unsafe StrPtr(string value, Encoding encoding)
         {
             if (value is null) throw new ArgumentNullException(nameof(value));

pythonnet-3.0.4/src/runtime/PythonTypes/PyFloat.IComparable.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace Python.Runtime;
+
+partial class PyFloat : IComparable<double>, IComparable<float>
+    , IEquatable<double>, IEquatable<float>
+    , IComparable<PyFloat?>, IEquatable<PyFloat?>
+{
+    public override bool Equals(object o)
+    {
+        using var _ = Py.GIL();
+        return o switch
+        {
+            double f64 => this.Equals(f64),
+            float f32 => this.Equals(f32),
+            _ => base.Equals(o),
+        };
+    }
+
+    public int CompareTo(double other) => this.ToDouble().CompareTo(other);
+
+    public int CompareTo(float other) => this.ToDouble().CompareTo(other);
+
+    public bool Equals(double other) => this.ToDouble().Equals(other);
+
+    public bool Equals(float other) => this.ToDouble().Equals(other);
+
+    public int CompareTo(PyFloat? other)
+    {
+        return other is null ? 1 : this.CompareTo(other.BorrowNullable());
+    }
+
+    public bool Equals(PyFloat? other) => base.Equals(other);
+}

{pythonnet-3.0.3 → pythonnet-3.0.4}/src/runtime/PythonTypes/PyFloat.cs

@@ -8,7 +8,7 @@ namespace Python.Runtime
     /// PY3: https://docs.python.org/3/c-api/float.html
     /// for details.
     /// </summary>
-    public class PyFloat : PyNumber
+    public partial class PyFloat : PyNumber
     {
         internal PyFloat(in StolenReference ptr) : base(ptr)
         {
@@ -100,6 +100,8 @@ namespace Python.Runtime
             return new PyFloat(op.Steal());
         }
 
+        public double ToDouble() => Runtime.PyFloat_AsDouble(obj);
+
         public override TypeCode GetTypeCode() => TypeCode.Double;
     }
 }