Class instance a derived Python class or pure C#?

Hey everybody, I am trying to see if there is a way to determine if my instance of a class is a pure C# class or a derived from C# Python class.

Here is an example:

Lets say I have a C# class public class Parent, -> in Python I create a subclass of it class PyClass(Parent), -> in C# I create a subclass of it public class CSharpClass : Parent

In both of these cases when I create the new objects it will use the Parent class constructor, but in that constructor I would like the behaviour to change if the instance is from a derived python class.

Is there a way to verify in the Parent class constructor that its being used in a derived Python class?

Thank you!

[lostmsu]

@C-SELLERS I was debugging some unrelated issue today, and came across ClassDerivedObject, that handles certain Python classes derived from C#.

First, is there a reason you don’t want to define your class as a CLR-like class? To do that you’d need to set __namespace__ like this:

class MyClass(Prototype.IProcessControl):
    __namespace__ = "Axa.Core.Prototype"

I believe in this case the derived class will implement dummy IPythonDerivedType.

[C-SELLERS]

Just a heads up, if anybody tries using the above, instances will also contain a copy of the object your originally passed in. I realize this probably isn’t desired so I added one extra step that will go get the type first, then dispose of our converted Python obj.

        /// <summary>
        /// Method for getting Python instances of a given obj type.
        /// This includes all subclass instances of the obj type.
        /// </summary>
        /// <param name="obj">instance of the object type you want to collect</param>
        /// <returns>Python List of PyObjects</returns>
        private static PyObject GetPythonInstances(object obj)
        {
            using (Py.GIL())
            {
                // Passing Python a type, even when converted using ToPython(), does not actually convert to Python type
                // so we must go fetch the type from Python, then dispose of this object so we don't get it in our list of
                // instances.
                var PythonObject = PyObject.FromManagedObject(obj);
                var type = PythonEngine.ModuleFromString(
                    "getPyType",
                    "def get_type(obj):\n" +
                    "   return type(obj)"
                ).InvokeMethod("get_type", PythonObject);
                PythonObject.Dispose();

                // Get all PyObjects that are instances of the type determined
                var instances = PythonEngine.ModuleFromString(
                    "getObject",
                    "import gc\n" +
                    "def get_instances(objType):\n" +
                    "   return [x for x in gc.get_objects() if isinstance(x, objType)]"
                ).InvokeMethod("get_instances", type);

                return instances;
            }
        }