Added support for marking properties with python types.

Added support for specifying attributes on property-methods (eg. get/set attributes).
pythonnet · rmadsen-ks · Apr 27, 2022 · Apr 28, 2022 · Apr 29, 2022 · May 3, 2022
commit 9eaf35ff4531a697f6513e50ebd4a44947b33f68
diff --git a/src/runtime/PythonTypes/PyObject.cs b/src/runtime/PythonTypes/PyObject.cs
@@ -25,7 +25,7 @@ public partial class PyObject : DynamicObject, IDisposable, ISerializable
         /// Trace stack for PyObject's construction
         /// </summary>
         public StackTrace Traceback { get; } = new StackTrace(1);
-#endif  
+#endif
 
         protected IntPtr rawPtr = IntPtr.Zero;
         internal readonly int run = Runtime.GetRun();
@@ -165,7 +165,7 @@ public static PyObject FromManagedObject(object ob)
         {
             if (!Converter.ToManaged(obj, t, out var result, true))
             {
-                throw new InvalidCastException("cannot convert object to target type",
+                throw new InvalidCastException($"Cannot convert object to target type '{t}'.",
                     PythonException.FetchCurrentOrNull(out _));
             }
             return result;
@@ -235,7 +235,7 @@ public void Dispose()
         {
             GC.SuppressFinalize(this);
             Dispose(true);
-            
+
         }
 
         internal StolenReference Steal()
@@ -1314,7 +1314,7 @@ private bool TryCompare(PyObject arg, int op, out object @out)
             }
             return true;
         }
-        
+
         public override bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object? result)
         {
             using var _ = Py.GIL();

diff --git a/src/runtime/PythonTypes/PythonTypeAttribute.cs b/src/runtime/PythonTypes/PythonTypeAttribute.cs
@@ -0,0 +1,27 @@
+using System;
+
+namespace Python.Runtime;
+
+/// <summary>
+/// Marks a property type with a specific python type. Normally, properties has .NET types, but if the property has a python type,
+/// that cannot be represented in the propert type info, so this attribute is used to mark the property with the corresponding python type.
+/// </summary>
+public class PythonTypeAttribute : Attribute
+{
+    /// <summary> Type name. </summary>
+    public string TypeName { get; }
+
+    /// <summary> Importable module name. </summary>
+    public string Module { get; }
+
+    /// <summary>
+    /// Creates a new instance of PythonTypeAttribute.
+    /// </summary>
+    /// <param name="pyTypeModule"></param>
+    /// <param name="pyTypeName"></param>
+    public PythonTypeAttribute(string pyTypeModule, string pyTypeName)
+    {
+        TypeName = pyTypeName;
+        Module = pyTypeModule;
+    }
+}
diff --git a/src/runtime/Resources/clr.py b/src/runtime/Resources/clr.py
@@ -61,7 +61,7 @@ def add_attribute(self, *args, **kwargs):
 
 class property(object):
 
-    def __init__(self, type, default):
+    def __init__(self, type, default = None):
         import weakref
         self._clr_property_type_ = type
         self.default = default
@@ -70,9 +70,14 @@ def __init__(self, type, default):
         self.fget = 1
         self.fset = 1
     def __get__(self, instance, owner):
+        if self.fget != 1:
+            return self.fget(instance)
         v = self.values.get(instance, self.default)
         return v
     def __set__(self, instance, value):
+        if self.fset != 1:
+            self.fset(instance,value)
+            return
         self.values[instance] = value
     def add_attribute(self, *args, **kwargs):
         lst = []
@@ -84,8 +89,9 @@ def add_attribute(self, *args, **kwargs):
         self._clr_attributes_.extend(lst)
         return self
 
-    def __call__(self, type, default):
-        self2 = self.__class__(self._clr_property_type_, type, default)
+    def __call__(self, func):
+        self2 = self.__class__(self._clr_property_type_, None)
+        self2.fget = func
         self2._clr_attributes_ = self._clr_attributes_
         return self2
 class clrmethod(object):

diff --git a/src/runtime/Types/ClassDerived.cs b/src/runtime/Types/ClassDerived.cs
@@ -145,6 +145,10 @@ static CustomAttributeBuilder AddAttribute(PyObject attr)
             // named arguments and named properties or fields the same way.
             var tp = new PyTuple(attr);
             Type attribute = (Type) tp[0].AsManagedObject(typeof(object));
+            if (typeof(Attribute).IsAssignableFrom(attribute) == false)
+            {
+                throw new Exception("This type is not an attribute type.");
+            }
 
             var args = (PyObject[]) tp[1].AsManagedObject(typeof(PyObject[]));
             var dict = new PyDict(tp[2]);
@@ -168,9 +172,10 @@ static CustomAttributeBuilder AddAttribute(PyObject attr)
                     if (parameter.ParameterType.IsArray && null != parameter.GetCustomAttribute(typeof(ParamArrayAttribute)))
                     {
                         int cnt = args.Length - i;
-                        var values = Array.CreateInstance(parameter.ParameterType.GetElementType(), cnt);
+                        var elemType = parameter.ParameterType.GetElementType();
+                        var values = Array.CreateInstance(elemType, cnt);
                         for(int j = 0; j < cnt; j++)
-                            values.SetValue(args[i + j], j);
+                            values.SetValue(args[i + j].AsManagedObject(typeof(object)), j);
                         paramValues.Add(values);
                         break;
                     }
@@ -750,28 +755,61 @@ private static void AddPythonProperty(string propertyName, PyObject func, TypeBu
                                              MethodAttributes.SpecialName;
 
             using var pyPropertyType = func.GetAttr("_clr_property_type_");
-            var propertyType = pyPropertyType.AsManagedObject(typeof(Type)) as Type;
+            var pyNativeType = new PyType(pyPropertyType);
+            Converter.ToManaged(pyPropertyType, typeof(Type), out var result, false);
+            var propertyType = result as Type;
+            string pyTypeName = null;
+            string pyTypeModule = null;
             if (propertyType == null)
             {
-                throw new ArgumentException("_clr_property_type must be a CLR type");
+                propertyType = typeof(PyObject);
+                pyTypeModule = pyNativeType.GetAttr("__module__").ToString();
+                //throw new ArgumentException("_clr_property_type must be a CLR type");
+                pyTypeName = pyNativeType.Name;
             }
 
             PropertyBuilder propertyBuilder = typeBuilder.DefineProperty(propertyName,
                 PropertyAttributes.None,
                 propertyType,
                 null);
-                if (func.HasAttr("_clr_attributes_"))
+            if (func.HasAttr("_clr_attributes_"))
+            {
+                using (var attributes = new PyList(func.GetAttr("_clr_attributes_")))
+                {
+                    foreach (var attr in attributes)
+                    {
+                        var builder = AddAttribute(attr);
+                        if (builder == null) throw new Exception();
+                        propertyBuilder.SetCustomAttribute(builder);
+                    }
+                }
+            }
+
+            if (pyTypeName != null)
+            {
+                var cb = new CustomAttributeBuilder(typeof(PythonTypeAttribute).GetConstructors().First(),
+                    new object[] {pyTypeModule, pyTypeName});
+                propertyBuilder.SetCustomAttribute(cb);
+            }
+
+            {
+                // load attribute set on functions
+                foreach (var fname in new[]{ "fget", "fset" })
                 {
-                    using (var attributes = new PyList(func.GetAttr("_clr_attributes_")))
+                    using var pyfget = func.GetAttr(fname);
+                    if (methodAssoc.TryGetValue(pyfget, out var lst))
                     {
-                        foreach (var attr in attributes)
+                        foreach (var attr in lst)
                         {
                             var builder = AddAttribute(attr);
                             if (builder == null) throw new Exception();
                             propertyBuilder.SetCustomAttribute(builder);
                         }
+
+                        methodAssoc.Remove(func);
                     }
                 }
+            }
 
             if (func.HasAttr("fget"))
             {