{

internal static PythonEnvironment PythonEnvironment = PythonEnvironment.FromEnv();

public static string? PythonDLL

{

get => _PythonDll;

set

{

if (_isInitialized)

throw new InvalidOperationException("This property must be set before runtime is initialized");

PythonEnvironment.LibPython = value;

}

}

static string? _PythonDll => PythonEnvironment.LibPython;

private static bool _isInitialized = false;

internal static bool IsInitialized => _isInitialized;

private static bool _typesInitialized = false;

internal static bool TypeManagerInitialized => _typesInitialized;

internal static readonly bool Is32Bit = IntPtr.Size == 4;

// Available in newer .NET Core versions (>= 5) as IntPtr.MaxValue etc.

internal static readonly long IntPtrMaxValue = Is32Bit ? Int32.MaxValue : Int64.MaxValue;

internal static readonly long IntPtrMinValue = Is32Bit ? Int32.MinValue : Int64.MinValue;

internal static readonly ulong UIntPtrMaxValue = Is32Bit ? UInt32.MaxValue : UInt64.MaxValue;

// .NET core: System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(OSPlatform.Windows)

internal static bool IsWindows = Environment.OSVersion.Platform == PlatformID.Win32NT;

internal static Version InteropVersion { get; }

= System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;

public static int MainManagedThreadId { get; private set; }

private static readonly List<PyObject> _pyRefs = new ();

internal static Version PyVersion

{

get

{

var versionTuple = PySys_GetObject("version_info");

var major = Converter.ToInt32(PyTuple_GetItem(versionTuple, 0));

var minor = Converter.ToInt32(PyTuple_GetItem(versionTuple, 1));

var micro = Converter.ToInt32(PyTuple_GetItem(versionTuple, 2));

return new Version(major, minor, micro);

}

}

const string RunSysPropName = "__pythonnet_run__";

static int run = 0;

internal static int GetRun()

{

int runNumber = run;

Debug.Assert(runNumber > 0, "This must only be called after Runtime is initialized at least once");

return runNumber;

}

static void EnsureProgramName()

{

if (!string.IsNullOrEmpty(PythonEngine.ProgramName))

return;

if (PythonEnvironment.IsValid)

{

PythonEngine.ProgramName = PythonEnvironment.ProgramName!;

return;

}

}

internal static bool HostedInPython;

internal static bool ProcessIsTerminating;

/// <summary>

/// Initialize the runtime...

/// </summary>

/// <remarks>Always call this method from the Main thread. After the

/// first call to this method, the main thread has acquired the GIL.</remarks>

internal static void Initialize(bool initSigs = false)

{

if (_isInitialized)

{

return;

}

_isInitialized = true;

bool interpreterAlreadyInitialized = TryUsingDll(

() => Py_IsInitialized() != 0

);

if (!interpreterAlreadyInitialized)

{

EnsureProgramName();

Py_InitializeEx(initSigs ? 1 : 0);

NewRun();

if (PyEval_ThreadsInitialized() == 0)

{

PyEval_InitThreads();

}

RuntimeState.Save();

}

else

{

if (!HostedInPython)

{

PyGILState_Ensure();

}

BorrowedReference pyRun = PySys_GetObject(RunSysPropName);

if (pyRun != null)

{

run = checked((int)PyLong_AsSignedSize_t(pyRun));

}

else

{

NewRun();

}

}

MainManagedThreadId = Thread.CurrentThread.ManagedThreadId;

Finalizer.Initialize();

InitPyMembers();

ABI.Initialize(PyVersion);

InternString.Initialize();

GenericUtil.Reset();

ClassManager.Reset();

ClassDerivedObject.Reset();

TypeManager.Initialize();

CLRObject.creationBlocked = false;

_typesInitialized = true;

// Initialize modules that depend on the runtime class.

AssemblyManager.Initialize();

OperatorMethod.Initialize();

if (RuntimeData.HasStashData())

{

RuntimeData.RestoreRuntimeData();

}

else

{

PyCLRMetaType = MetaType.Initialize();

ImportHook.Initialize();

}

Exceptions.Initialize();

// Need to add the runtime directory to sys.path so that we

// can find built-in assemblies like System.Data, et. al.

string rtdir = RuntimeEnvironment.GetRuntimeDirectory();

BorrowedReference path = PySys_GetObject("path");

using var item = PyString_FromString(rtdir);

if (PySequence_Contains(path, item.Borrow()) == 0)

{

PyList_Append(path, item.Borrow());

}

AssemblyManager.UpdatePath();

clrInterop = GetModuleLazy("clr.interop");

inspect = GetModuleLazy("inspect");

hexCallable = new(() => new PyString("%x").GetAttr("__mod__"));

}

static void NewRun()

{

run++;

using var pyRun = PyLong_FromLongLong(run);

PySys_SetObject(RunSysPropName, pyRun.BorrowOrThrow());

}

private static void InitPyMembers()

{

using (var builtinsOwned = PyImport_ImportModule("builtins"))

{

var builtins = builtinsOwned.Borrow();

SetPyMember(out PyNotImplemented, PyObject_GetAttrString(builtins, "NotImplemented").StealNullable());

SetPyMember(out PyBaseObjectType, PyObject_GetAttrString(builtins, "object").StealNullable());

SetPyMember(out _PyNone, PyObject_GetAttrString(builtins, "None").StealNullable());

SetPyMember(out _PyTrue, PyObject_GetAttrString(builtins, "True").StealNullable());

SetPyMember(out _PyFalse, PyObject_GetAttrString(builtins, "False").StealNullable());

SetPyMemberTypeOf(out PyBoolType, _PyTrue!);

SetPyMemberTypeOf(out PyNoneType, _PyNone!);

SetPyMemberTypeOf(out PyMethodType, PyObject_GetAttrString(builtins, "len").StealNullable());

// For some arcane reason, builtins.__dict__.__setitem__ is *not*

// a wrapper_descriptor, even though dict.__setitem__ is.

//

// object.__init__ seems safe, though.

SetPyMemberTypeOf(out PyWrapperDescriptorType, PyObject_GetAttrString(PyBaseObjectType, "__init__").StealNullable());

SetPyMember(out PySuper_Type, PyObject_GetAttrString(builtins, "super").StealNullable());

}

SetPyMemberTypeOf(out PyStringType, PyString_FromString("string").StealNullable());

SetPyMemberTypeOf(out PyUnicodeType, PyString_FromString("unicode").StealNullable());

SetPyMemberTypeOf(out PyBytesType, EmptyPyBytes().StealNullable());

SetPyMemberTypeOf(out PyTupleType, PyTuple_New(0).StealNullable());

SetPyMemberTypeOf(out PyListType, PyList_New(0).StealNullable());

SetPyMemberTypeOf(out PyDictType, PyDict_New().StealNullable());

SetPyMemberTypeOf(out PyLongType, PyInt_FromInt32(0).StealNullable());

SetPyMemberTypeOf(out PyFloatType, PyFloat_FromDouble(0).StealNullable());

_PyObject_NextNotImplemented = Get_PyObject_NextNotImplemented();

{

using var sys = PyImport_ImportModule("sys");

SetPyMemberTypeOf(out PyModuleType, sys.StealNullable());

}

}

private static NativeFunc* Get_PyObject_NextNotImplemented()

{

using var pyType = SlotHelper.CreateObjectType();

return Util.ReadPtr<NativeFunc>(pyType.Borrow(), TypeOffset.tp_iternext);

}

internal static void Shutdown()

{

if (Py_IsInitialized() == 0 || !_isInitialized)

{

return;

}

_isInitialized = false;

var state = PyGILState_Ensure();

if (!HostedInPython && !ProcessIsTerminating)

{

// avoid saving dead objects

TryCollectingGarbage(runs: 3);

RuntimeData.Stash();

}

AssemblyManager.Shutdown();

OperatorMethod.Shutdown();

ImportHook.Shutdown();

ClearClrModules();

RemoveClrRootModule();

TryCollectingGarbage(MaxCollectRetriesOnShutdown, forceBreakLoops: true,

obj: true, derived: false, buffer: false);

CLRObject.creationBlocked = true;

NullGCHandles(ExtensionType.loadedExtensions);

ClassManager.RemoveClasses();

TypeManager.RemoveTypes();

_typesInitialized = false;

MetaType.Release();

PyCLRMetaType.Dispose();

PyCLRMetaType = null!;

Exceptions.Shutdown();

PythonEngine.InteropConfiguration.Dispose();

DisposeLazyObject(clrInterop);

DisposeLazyObject(inspect);

DisposeLazyObject(hexCallable);

PyObjectConversions.Reset();

PyGC_Collect();

bool everythingSeemsCollected = TryCollectingGarbage(MaxCollectRetriesOnShutdown);

Debug.Assert(everythingSeemsCollected);

Finalizer.Shutdown();

InternString.Shutdown();

ResetPyMembers();

if (!HostedInPython)

{

GC.Collect();

GC.WaitForPendingFinalizers();

PyGILState_Release(state);

// Then release the GIL for good, if there is somehting to release

// Use the unchecked version as the checked version calls `abort()`

// if the current state is NULL.

if (PyThreadState_GetUnchecked() != (PyThreadState*)0)

{

PyEval_SaveThread();

}

ExtensionType.loadedExtensions.Clear();

CLRObject.reflectedObjects.Clear();

}

else

{

PyGILState_Release(state);

}

}

const int MaxCollectRetriesOnShutdown = 20;

internal static int _collected;

static bool TryCollectingGarbage(int runs, bool forceBreakLoops,

bool obj = true, bool derived = true, bool buffer = true)

{

if (runs <= 0) throw new ArgumentOutOfRangeException(nameof(runs));

for (int attempt = 0; attempt < runs; attempt++)

{

Interlocked.Exchange(ref _collected, 0);

nint pyCollected = 0;

for (int i = 0; i < 2; i++)

{

GC.Collect();

GC.WaitForPendingFinalizers();

pyCollected += PyGC_Collect();

pyCollected += Finalizer.Instance.DisposeAll(disposeObj: obj,

disposeDerived: derived,

disposeBuffer: buffer);

}

if (Volatile.Read(ref _collected) == 0 && pyCollected == 0)

{

if (attempt + 1 == runs) return true;

}

else if (forceBreakLoops)

{

NullGCHandles(CLRObject.reflectedObjects);

CLRObject.reflectedObjects.Clear();

}

}

return false;

}

/// <summary>

/// Alternates .NET and Python GC runs in an attempt to collect all garbage

/// </summary>

/// <param name="runs">Total number of GC loops to run</param>

/// <returns><c>true</c> if a steady state was reached upon the requested number of tries (e.g. on the last try no objects were collected).</returns>

[ForbidPythonThreads]

public static bool TryCollectingGarbage(int runs)

=> TryCollectingGarbage(runs, forceBreakLoops: false);

static void DisposeLazyObject(Lazy<PyObject> pyObject)

{

if (pyObject.IsValueCreated)

{

pyObject.Value.Dispose();

}

}

private static Lazy<PyObject> GetModuleLazy(string moduleName)

=> moduleName is null

? throw new ArgumentNullException(nameof(moduleName))

: new Lazy<PyObject>(() => PyModule.Import(moduleName), isThreadSafe: false);

private static void SetPyMember(out PyObject obj, StolenReference value)

{

// XXX: For current usages, value should not be null.

if (value == null)

{

throw PythonException.ThrowLastAsClrException();

}

obj = new PyObject(value);

_pyRefs.Add(obj);

}

private static void SetPyMemberTypeOf(out PyType obj, PyObject value)

{

var type = PyObject_Type(value);

obj = new PyType(type.StealOrThrow(), prevalidated: true);

_pyRefs.Add(obj);

}

private static void SetPyMemberTypeOf(out PyObject obj, StolenReference value)

{

if (value == null)

{

throw PythonException.ThrowLastAsClrException();

}

var @ref = new BorrowedReference(value.Pointer);

var type = PyObject_Type(@ref);

XDecref(value.AnalyzerWorkaround());

SetPyMember(out obj, type.StealNullable());

}

private static void ResetPyMembers()

{

foreach (var pyObj in _pyRefs)

pyObj.Dispose();

_pyRefs.Clear();

}

private static void ClearClrModules()

{

var modules = PyImport_GetModuleDict();

using var items = PyDict_Items(modules);

nint length = PyList_Size(items.BorrowOrThrow());

if (length < 0) throw PythonException.ThrowLastAsClrException();

for (nint i = 0; i < length; i++)

{

var item = PyList_GetItem(items.Borrow(), i);

var name = PyTuple_GetItem(item, 0);

var module = PyTuple_GetItem(item, 1);

if (ManagedType.IsInstanceOfManagedType(module))

{

PyDict_DelItem(modules, name);

}

}

}

private static void RemoveClrRootModule()

{

var modules = PyImport_GetModuleDict();

PyDictTryDelItem(modules, "clr");

PyDictTryDelItem(modules, "clr._extra");

}

private static void PyDictTryDelItem(BorrowedReference dict, string key)

{

if (PyDict_DelItemString(dict, key) == 0)

{

return;

}

if (!PythonException.CurrentMatches(Exceptions.KeyError))

{

throw PythonException.ThrowLastAsClrException();

}

PyErr_Clear();

}

private static void NullGCHandles(IEnumerable<IntPtr> objects)

{

foreach (IntPtr objWithGcHandle in objects.ToArray())

{

var @ref = new BorrowedReference(objWithGcHandle);

ManagedType.TryFreeGCHandle(@ref);

}

}

#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.

// these objects are initialized in Initialize rather than in constructor

internal static PyObject PyBaseObjectType;

internal static PyObject PyModuleType;

internal static PyObject PySuper_Type;

internal static PyType PyCLRMetaType;

internal static PyObject PyMethodType;

internal static PyObject PyWrapperDescriptorType;

internal static PyObject PyUnicodeType;

internal static PyObject PyStringType;

internal static PyObject PyTupleType;

internal static PyObject PyListType;

internal static PyObject PyDictType;

internal static PyObject PyLongType;

internal static PyObject PyFloatType;

internal static PyType PyBoolType;

internal static PyType PyNoneType;

internal static BorrowedReference PyTypeType => new(Delegates.PyType_Type);

internal static PyObject PyBytesType;

internal static NativeFunc* _PyObject_NextNotImplemented;

internal static PyObject PyNotImplemented;

internal const int Py_LT = 0;

internal const int Py_LE = 1;

internal const int Py_EQ = 2;

internal const int Py_NE = 3;

internal const int Py_GT = 4;

internal const int Py_GE = 5;

internal static BorrowedReference PyTrue => _PyTrue;

static PyObject _PyTrue;

internal static BorrowedReference PyFalse => _PyFalse;

static PyObject _PyFalse;

internal static BorrowedReference PyNone => _PyNone;

private static PyObject _PyNone;

private static Lazy<PyObject> inspect;

internal static PyObject InspectModule => inspect.Value;

private static Lazy<PyObject> clrInterop;

internal static PyObject InteropModule => clrInterop.Value;

private static Lazy<PyObject> hexCallable;

internal static PyObject HexCallable => hexCallable.Value;

#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.

internal static BorrowedReference CLRMetaType => PyCLRMetaType;

public static PyObject None => new(_PyNone);

/// <summary>

/// Check if any Python Exceptions occurred.

/// If any exist throw new PythonException.

/// </summary>

/// <remarks>

/// Can be used instead of `obj == IntPtr.Zero` for example.

/// </remarks>

internal static void CheckExceptionOccurred()

{

if (PyErr_Occurred() != null)

{

throw PythonException.ThrowLastAsClrException();

}

}

internal static Type[]? PythonArgsToTypeArray(BorrowedReference arg)

{

return PythonArgsToTypeArray(arg, false);

}

internal static Type[]? PythonArgsToTypeArray(BorrowedReference arg, bool mangleObjects)

{

// Given a PyObject * that is either a single type object or a

// tuple of (managed or unmanaged) type objects, return a Type[]

// containing the CLR Type objects that map to those types.

BorrowedReference args = arg;

NewReference newArgs = default;

if (!PyTuple_Check(arg))

{

newArgs = PyTuple_New(1);

args = newArgs.Borrow();

PyTuple_SetItem(args, 0, arg);

}

var n = PyTuple_Size(args);

var types = new Type[n];

Type? t = null;

for (var i = 0; i < n; i++)

{

BorrowedReference op = PyTuple_GetItem(args, i);

if (mangleObjects && (!PyType_Check(op)))

{

op = PyObject_TYPE(op);

}

ManagedType? mt = ManagedType.GetManagedObject(op);

if (mt is ClassBase b)

{

var _type = b.type;

t = _type.Valid ? _type.Value : null;

}

else if (mt is CLRObject ob)

{

var inst = ob.inst;

if (inst is Type ty)

{

t = ty;

}

}

else

{

t = Converter.GetTypeByAlias(op);

}

if (t == null)

{

types = null;

break;

}

types[i] = t;

}

newArgs.Dispose();

return types;

}

/// <summary>

/// Managed exports of the Python C API. Where appropriate, we do

/// some optimization to avoid managed &lt;--&gt; unmanaged transitions

/// (mostly for heavily used methods).

/// </summary>

[Obsolete("Use NewReference or PyObject constructor instead")]

internal static unsafe void XIncref(BorrowedReference op)

{

Py_IncRef(op);

return;

}

internal static unsafe void XDecref(StolenReference op)

{

#if DEBUG

Debug.Assert(op == null || Refcount(new BorrowedReference(op.Pointer)) > 0);

Debug.Assert(_isInitialized || Py_IsInitialized() != 0 || _Py_IsFinalizing() != false);

#endif

if (op == null) return;

Py_DecRef(op.AnalyzerWorkaround());

return;

}

[Pure]

internal static unsafe nint Refcount(BorrowedReference op)

{

if (op == null)

{

return 0;

}

var p = (nint*)(op.DangerousGetAddress() + ABI.RefCountOffset);

return *p;

}

[Pure]

internal static int Refcount32(BorrowedReference op) => checked((int)Refcount(op));

internal static void TryUsingDll(Action op) =>

TryUsingDll(() => { op(); return 0; });

/// <summary>

/// Call specified function, and handle PythonDLL-related failures.

/// </summary>

internal static T TryUsingDll<T>(Func<T> op)

{

try

{

return op();

}

catch (TypeInitializationException loadFailure)

{

var delegatesLoadFailure = loadFailure;

// failure to load Delegates type might have been the cause

// of failure to load some higher-level type

while (delegatesLoadFailure.InnerException is TypeInitializationException nested)

{

delegatesLoadFailure = nested;

}

if (delegatesLoadFailure.InnerException is BadPythonDllException badDll)

{

throw badDll;

}

throw;

}

}

/// <summary>

/// Export of Macro Py_XIncRef. Use XIncref instead.

/// Limit this function usage for Testing and Py_Debug builds

/// </summary>

/// <param name="ob">PyObject Ptr</param>

internal static void Py_IncRef(BorrowedReference ob) => Delegates.Py_IncRef(ob);

/// <summary>

/// Export of Macro Py_XDecRef. Use XDecref instead.

/// Limit this function usage for Testing and Py_Debug builds

/// </summary>

/// <param name="ob">PyObject Ptr</param>

internal static void Py_DecRef(StolenReference ob) => Delegates.Py_DecRef(ob);

internal static void Py_Initialize() => Delegates.Py_Initialize();

internal static void Py_InitializeEx(int initsigs) => Delegates.Py_InitializeEx(initsigs);

internal static int Py_IsInitialized() => Delegates.Py_IsInitialized();

internal static void Py_Finalize() => Delegates.Py_Finalize();

internal static PyThreadState* Py_NewInterpreter() => Delegates.Py_NewInterpreter();

internal static void Py_EndInterpreter(PyThreadState* threadState) => Delegates.Py_EndInterpreter(threadState);

internal static PyThreadState* PyThreadState_New(PyInterpreterState* istate) => Delegates.PyThreadState_New(istate);

internal static PyThreadState* PyThreadState_Get() => Delegates.PyThreadState_Get();

internal static PyThreadState* PyThreadState_GetUnchecked() => Delegates.PyThreadState_GetUnchecked();

internal static int PyGILState_Check() => Delegates.PyGILState_Check();

internal static PyGILState PyGILState_Ensure() => Delegates.PyGILState_Ensure();

internal static void PyGILState_Release(PyGILState gs) => Delegates.PyGILState_Release(gs);

internal static PyThreadState* PyGILState_GetThisThreadState() => Delegates.PyGILState_GetThisThreadState();

internal static void PyEval_InitThreads() => Delegates.PyEval_InitThreads();

internal static int PyEval_ThreadsInitialized() => Delegates.PyEval_ThreadsInitialized();

internal static void PyEval_AcquireLock() => Delegates.PyEval_AcquireLock();

internal static void PyEval_ReleaseLock() => Delegates.PyEval_ReleaseLock();

internal static void PyEval_AcquireThread(PyThreadState* tstate) => Delegates.PyEval_AcquireThread(tstate);

internal static void PyEval_ReleaseThread(PyThreadState* tstate) => Delegates.PyEval_ReleaseThread(tstate);

internal static PyThreadState* PyEval_SaveThread() => Delegates.PyEval_SaveThread();

internal static void PyEval_RestoreThread(PyThreadState* tstate) => Delegates.PyEval_RestoreThread(tstate);

internal static BorrowedReference PyEval_GetBuiltins() => Delegates.PyEval_GetBuiltins();

internal static BorrowedReference PyEval_GetGlobals() => Delegates.PyEval_GetGlobals();

internal static BorrowedReference PyEval_GetLocals() => Delegates.PyEval_GetLocals();

internal static IntPtr Py_GetProgramName() => Delegates.Py_GetProgramName();

internal static void Py_SetProgramName(IntPtr name) => Delegates.Py_SetProgramName(name);

internal static IntPtr Py_GetPythonHome() => Delegates.Py_GetPythonHome();

internal static void Py_SetPythonHome(IntPtr home) => Delegates.Py_SetPythonHome(home);

internal static IntPtr Py_GetPath() => Delegates.Py_GetPath();

internal static void Py_SetPath(IntPtr home) => Delegates.Py_SetPath(home);

internal static IntPtr Py_GetVersion() => Delegates.Py_GetVersion();

internal static IntPtr Py_GetPlatform() => Delegates.Py_GetPlatform();

internal static IntPtr Py_GetCopyright() => Delegates.Py_GetCopyright();

internal static IntPtr Py_GetCompiler() => Delegates.Py_GetCompiler();

internal static IntPtr Py_GetBuildInfo() => Delegates.Py_GetBuildInfo();

const PyCompilerFlags Utf8String = PyCompilerFlags.IGNORE_COOKIE | PyCompilerFlags.SOURCE_IS_UTF8;

internal static int PyRun_SimpleString(string code)

{

using var codePtr = new StrPtr(code);

return Delegates.PyRun_SimpleStringFlags(codePtr, Utf8String);

}

internal static NewReference PyRun_String(string code, RunFlagType st, BorrowedReference globals, BorrowedReference locals)

{

using var codePtr = new StrPtr(code);

return Delegates.PyRun_StringFlags(codePtr, st, globals, locals, Utf8String);

}

internal static NewReference PyEval_EvalCode(BorrowedReference co, BorrowedReference globals, BorrowedReference locals) => Delegates.PyEval_EvalCode(co, globals, locals);

/// <summary>

/// Return value: New reference.

/// This is a simplified interface to Py_CompileStringFlags() below, leaving flags set to NULL.

/// </summary>

internal static NewReference Py_CompileString(string str, string file, int start)

{

using var strPtr = new StrPtr(str);

using var fileObj = new PyString(file);

return Delegates.Py_CompileStringObject(strPtr, fileObj, start, Utf8String, -1);

}

internal static NewReference PyImport_ExecCodeModule(string name, BorrowedReference code)

{

using var namePtr = new StrPtr(name);

return Delegates.PyImport_ExecCodeModule(namePtr, code);

}

//====================================================================

// Python abstract object API

//====================================================================

/// <summary>

/// A macro-like method to get the type of a Python object. This is

/// designed to be lean and mean in IL &amp; avoid managed &lt;-&gt; unmanaged

/// transitions. Note that this does not incref the type object.

/// </summary>

internal static unsafe BorrowedReference PyObject_TYPE(BorrowedReference op)

{

IntPtr address = op.DangerousGetAddressOrNull();

if (address == IntPtr.Zero)

{

return BorrowedReference.Null;

}

Debug.Assert(TypeOffset.ob_type > 0);

BorrowedReference* typePtr = (BorrowedReference*)(address + TypeOffset.ob_type);

return *typePtr;

}

internal static NewReference PyObject_Type(BorrowedReference o)

=> Delegates.PyObject_Type(o);

internal static string PyObject_GetTypeName(BorrowedReference op)

{

Debug.Assert(TypeOffset.tp_name > 0);

Debug.Assert(op != null);

BorrowedReference pyType = PyObject_TYPE(op);

IntPtr ppName = Util.ReadIntPtr(pyType, TypeOffset.tp_name);