pythonnet · lostmsu · Jan 5, 2021 · Dec 16, 2020 · Dec 17, 2020 · Dec 17, 2020
diff --git a/AUTHORS.md b/AUTHORS.md
@@ -24,6 +24,7 @@
 -   Benoît Hudson ([@benoithudson](https://github.com/benoithudson))
 -   Bradley Friedman ([@leith-bartrich](https://github.com/leith-bartrich))
 -   Callum Noble ([@callumnoble](https://github.com/callumnoble))
+-   Christabella Irwanto([@christabella](https://github.com/christabella))
 -   Christian Heimes ([@tiran](https://github.com/tiran))
 -   Christoph Gohlke ([@cgohlke](https://github.com/cgohlke))
 -   Christopher Bremner ([@chrisjbremner](https://github.com/chrisjbremner))

diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -10,6 +10,7 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 ### Added
 
 -   Ability to instantiate new .NET arrays using `Array[T](dim1, dim2, ...)` syntax
+-   Python operator method will call C# operator method for supported binary and unary operators ([#1324][p1324]).
 
 ### Changed
 -   Drop support for Python 2, 3.4, and 3.5

diff --git a/src/embed_tests/TestOperator.cs b/src/embed_tests/TestOperator.cs
@@ -0,0 +1,332 @@
+using NUnit.Framework;
+
+using Python.Runtime;
+
+using System.Linq;
+using System.Reflection;
+
+namespace Python.EmbeddingTest
+{
+    public class TestOperator
+    {
+        [OneTimeSetUp]
+        public void SetUp()
+        {
+            PythonEngine.Initialize();
+        }
+
+        [OneTimeTearDown]
+        public void Dispose()
+        {
+            PythonEngine.Shutdown();
+        }
+
+        public class OperableObject
+        {
+            public int Num { get; set; }
+
+            public OperableObject(int num)
+            {
+                Num = num;
+            }
+
+            public static OperableObject operator ~(OperableObject a)
+            {
+                return new OperableObject(~a.Num);
+            }
+
+            public static OperableObject operator +(OperableObject a)
+            {
+                return new OperableObject(+a.Num);
+            }
+
+            public static OperableObject operator -(OperableObject a)
+            {
+                return new OperableObject(-a.Num);
+            }
+
+            public static OperableObject operator +(int a, OperableObject b)
+            {
+                return new OperableObject(a + b.Num);
+            }
+            public static OperableObject operator +(OperableObject a, OperableObject b)
+            {
+                return new OperableObject(a.Num + b.Num);
+            }
+            public static OperableObject operator +(OperableObject a, int b)
+            {
+                return new OperableObject(a.Num + b);
+            }
+
+            public static OperableObject operator -(int a, OperableObject b)
+            {
+                return new OperableObject(a - b.Num);
+            }
+            public static OperableObject operator -(OperableObject a, OperableObject b)
+            {
+                return new OperableObject(a.Num - b.Num);
+            }
+            public static OperableObject operator -(OperableObject a, int b)
+            {
+                return new OperableObject(a.Num - b);
+            }
+
+            public static OperableObject operator *(int a, OperableObject b)
+            {
+                return new OperableObject(a * b.Num);
+            }
+            public static OperableObject operator *(OperableObject a, OperableObject b)
+            {
+                return new OperableObject(a.Num * b.Num);
+            }
+            public static OperableObject operator *(OperableObject a, int b)
+            {
+                return new OperableObject(a.Num * b);
+            }
+
+            public static OperableObject operator /(int a, OperableObject b)
+            {
+                return new OperableObject(a / b.Num);
+            }
+            public static OperableObject operator /(OperableObject a, OperableObject b)
+            {
+                return new OperableObject(a.Num / b.Num);
+            }
+            public static OperableObject operator /(OperableObject a, int b)
+            {
+                return new OperableObject(a.Num / b);
+            }
+
+            public static OperableObject operator %(int a, OperableObject b)
+            {
+                return new OperableObject(a % b.Num);
+            }
+            public static OperableObject operator %(OperableObject a, OperableObject b)
+            {
+                return new OperableObject(a.Num % b.Num);
+            }
+            public static OperableObject operator %(OperableObject a, int b)
+            {
+                return new OperableObject(a.Num % b);
+            }
+
+            public static OperableObject operator &(int a, OperableObject b)
+            {
+                return new OperableObject(a & b.Num);
+            }
+            public static OperableObject operator &(OperableObject a, OperableObject b)
+            {
+                return new OperableObject(a.Num & b.Num);
+            }
+            public static OperableObject operator &(OperableObject a, int b)
+            {
+                return new OperableObject(a.Num & b);
+            }
+
+            public static OperableObject operator |(int a, OperableObject b)
+            {
+                return new OperableObject(a | b.Num);
+            }
+            public static OperableObject operator |(OperableObject a, OperableObject b)
+            {
+                return new OperableObject(a.Num | b.Num);
+            }
+            public static OperableObject operator |(OperableObject a, int b)
+            {
+                return new OperableObject(a.Num | b);
+            }
+
+            public static OperableObject operator ^(int a, OperableObject b)
+            {
+                return new OperableObject(a ^ b.Num);
+            }
+            public static OperableObject operator ^(OperableObject a, OperableObject b)
+            {
+                return new OperableObject(a.Num ^ b.Num);
+            }
+            public static OperableObject operator ^(OperableObject a, int b)
+            {
+                return new OperableObject(a.Num ^ b);
+            }
+
+            public static OperableObject operator <<(OperableObject a, int offset)
+            {
+                return new OperableObject(a.Num << offset);
+            }
+
+            public static OperableObject operator >>(OperableObject a, int offset)
+            {
+                return new OperableObject(a.Num >> offset);
+            }
+        }
+
+        [Test]
+        public void OperatorOverloads()
+        {
+            string name = string.Format("{0}.{1}",
+                typeof(OperableObject).DeclaringType.Name,
+                typeof(OperableObject).Name);
+            string module = MethodBase.GetCurrentMethod().DeclaringType.Namespace;
+
+            PythonEngine.Exec($@"
+from {module} import *
+cls = {name}
+a = cls(-2)
+b = cls(10)
+c = ~a
+assert c.Num == ~a.Num
+
+c = +a
+assert c.Num == +a.Num
+
+a = cls(2)
+c = -a
+assert c.Num == -a.Num
+
+c = a + b
+assert c.Num == a.Num + b.Num
+
+c = a - b
+assert c.Num == a.Num - b.Num
+
+c = a * b
+assert c.Num == a.Num * b.Num
+
+c = a / b
+assert c.Num == a.Num // b.Num
+
+c = a % b
+assert c.Num == a.Num % b.Num
+
+c = a & b
+assert c.Num == a.Num & b.Num
+
+c = a | b
+assert c.Num == a.Num | b.Num
+
+c = a ^ b
+assert c.Num == a.Num ^ b.Num
+");
+        }
+
+        [Test]
+        public void OperatorOverloadMissingArgument()
+        {
+            string name = string.Format("{0}.{1}",
+                typeof(OperableObject).DeclaringType.Name,
+                typeof(OperableObject).Name);
+            string module = MethodBase.GetCurrentMethod().DeclaringType.Namespace;
+
+            Assert.Throws<PythonException>(() =>
+            PythonEngine.Exec($@"
+from {module} import *
+cls = {name}
+a = cls(2)
+b = cls(10)
+a.op_Addition()
+"));
+        }
+
+        [Test]
+        public void ForwardOperatorOverloads()
+        {
+            string name = string.Format("{0}.{1}",
+                typeof(OperableObject).DeclaringType.Name,
+                typeof(OperableObject).Name);
+            string module = MethodBase.GetCurrentMethod().DeclaringType.Namespace;
+
+            PythonEngine.Exec($@"
+from {module} import *
+cls = {name}
+a = cls(2)
+b = 10
+c = a + b
+assert c.Num == a.Num + b
+
+c = a - b
+assert c.Num == a.Num - b
+
+c = a * b
+assert c.Num == a.Num * b
+
+c = a / b
+assert c.Num == a.Num // b
+
+c = a % b
+assert c.Num == a.Num % b
+
+c = a & b
+assert c.Num == a.Num & b
+
+c = a | b
+assert c.Num == a.Num | b
+
+c = a ^ b
+assert c.Num == a.Num ^ b
+");
+        }
+
+
+        [Test]
+        public void ReverseOperatorOverloads()
+        {
+            string name = string.Format("{0}.{1}",
+                typeof(OperableObject).DeclaringType.Name,
+                typeof(OperableObject).Name);
+            string module = MethodBase.GetCurrentMethod().DeclaringType.Namespace;
+
+            PythonEngine.Exec($@"
+from {module} import *
+cls = {name}
+a = 2
+b = cls(10)
+
+c = a + b
+assert c.Num == a + b.Num
+
+c = a - b
+assert c.Num == a - b.Num
+
+c = a * b
+assert c.Num == a * b.Num
+
+c = a / b
+assert c.Num == a // b.Num
+
+c = a % b
+assert c.Num == a % b.Num
+
+c = a & b
+assert c.Num == a & b.Num
+
+c = a | b
+assert c.Num == a | b.Num
+
+c = a ^ b
+assert c.Num == a ^ b.Num
+");
+
+        }
+        [Test]
+        public void ShiftOperatorOverloads()
+        {
+            string name = string.Format("{0}.{1}",
+                typeof(OperableObject).DeclaringType.Name,
+                typeof(OperableObject).Name);
+            string module = MethodBase.GetCurrentMethod().DeclaringType.Namespace;
+
+            PythonEngine.Exec($@"
+from {module} import *
+cls = {name}
+a = cls(2)
+b = cls(10)
+
+c = a << b.Num
+assert c.Num == a.Num << b.Num
+
+c = a >> b.Num
+assert c.Num == a.Num >> b.Num
+");
+        }
+    }
+}
diff --git a/src/runtime/classmanager.cs b/src/runtime/classmanager.cs
@@ -470,6 +470,19 @@ private static ClassInfo GetClassInfo(Type type)
 
                 ob = new MethodObject(type, name, mlist);
                 ci.members[name] = ob;
+                if (mlist.Any(OperatorMethod.IsOperatorMethod))
+                {
+                    string pyName = OperatorMethod.GetPyMethodName(name);
+                    string pyNameReverse = OperatorMethod.ReversePyMethodName(pyName);
+                    MethodInfo[] forwardMethods, reverseMethods;
+                    OperatorMethod.FilterMethods(mlist, out forwardMethods, out reverseMethods);
+                    // Only methods where the left operand is the declaring type.
+                    if (forwardMethods.Length > 0)
+                        ci.members[pyName] = new MethodObject(type, name, forwardMethods);
+                    // Only methods where only the right operand is the declaring type.
+                    if (reverseMethods.Length > 0)
+                        ci.members[pyNameReverse] = new MethodObject(type, name, reverseMethods);
+                }
             }
 
             if (ci.indexer == null && type.IsClass)