From e9adda0aef94dcda8efd6a8acfcc206683afd034 Mon Sep 17 00:00:00 2001
From: Jhonathan Abreu <jdabreu25@gmail.com>
Date: Thu, 31 Jul 2025 15:56:59 -0400
Subject: [PATCH] Add int implicit conversion operator to enums

---
 .../GeneratorTests.cs                         | 39 +++++++++++++++++++
 .../Parser/MethodParser.cs                    | 20 ++++++++++
 2 files changed, 59 insertions(+)

diff --git a/QuantConnectStubsGenerator.Tests/GeneratorTests.cs b/QuantConnectStubsGenerator.Tests/GeneratorTests.cs
index 9c721a4..5048802 100644
--- a/QuantConnectStubsGenerator.Tests/GeneratorTests.cs
+++ b/QuantConnectStubsGenerator.Tests/GeneratorTests.cs
@@ -503,6 +503,45 @@ internal event EventHandler InternalPropertyEvent
             Assert.IsNull(internalFieldEvent);
         }
 
+        [Test]
+        public void GeneratesIntImplicitConversionOperatorForEnums()
+        {
+            var testGenerator = new TestGenerator
+            {
+                Files = new()
+                {
+                    {
+                        "Test.cs",
+                        @"
+using System;
+
+namespace QuantConnect.Test
+{
+    public enum TestEnum
+    {
+        Value1,
+        Value2,
+        Value3
+    }
+}"
+                    }
+                }
+            };
+
+            var result = testGenerator.GenerateModelsPublic();
+
+            var ns = result.GetNamespaces().Single(x => x.Name == "QuantConnect.Test");
+            var classes = ns.GetClasses().ToList();
+            var testEnum = classes.Single(x => x.Type.Name == "TestEnum");
+
+            Assert.IsTrue(testEnum.IsEnum());
+
+            var intImplicitConversionMethod = testEnum.Methods.SingleOrDefault(m => m.Name == "__int__");
+            Assert.IsNotNull(intImplicitConversionMethod);
+            Assert.AreEqual(0, intImplicitConversionMethod.Parameters.Count);
+            Assert.AreEqual(new PythonType("int"), intImplicitConversionMethod.ReturnType);
+        }
+
         internal class TestGenerator : Generator
         {
             public Dictionary<string, string> Files { get; set; }
diff --git a/QuantConnectStubsGenerator/Parser/MethodParser.cs b/QuantConnectStubsGenerator/Parser/MethodParser.cs
index ae25b20..3517239 100644
--- a/QuantConnectStubsGenerator/Parser/MethodParser.cs
+++ b/QuantConnectStubsGenerator/Parser/MethodParser.cs
@@ -69,6 +69,17 @@ public MethodParser(ParseContext context, SemanticModel model) : base(context, m
         {
         }
 
+        protected override void EnterClass(BaseTypeDeclarationSyntax node)
+        {
+            base.EnterClass(node);
+
+            // Pythonnet adds __int__() method to enums to allow implicit conversion to int
+            if (_currentClass.IsEnum())
+            {
+                AddIntImplicitOperatorMethod();
+            }
+        }
+
         public override void VisitMethodDeclaration(MethodDeclarationSyntax node)
         {
             PythonType genericType = null;
@@ -579,6 +590,15 @@ private void MakeComparableIfNecessary(Method method)
                 comparisonMethod.Class.Methods.Add(comparisonMethod);
             }
         }
+
+        /// <summary>
+        /// Adds the __int__() method to the class if it is an enum.
+        /// </summary>
+        private void AddIntImplicitOperatorMethod()
+        {
+            var intImplicitOperatorMethod = new Method("__int__", new PythonType("int")) { Class = _currentClass };
+            _currentClass.Methods.Add(intImplicitOperatorMethod);
+        }
     }
 }