Cache and extend AttributeError member-name suggestions (static members and enum values) (#130)

* Cache AttributeError member-name suggestions per type and (type, name)

Building the "Did you mean ...?" hint for a missing attribute reflected over the
managed type's full member set (GetMembers with FlattenHierarchy), snake_cased
every member, and ran a Levenshtein scan -- on every miss, with no caching.
getattr(obj, name, default) and hasattr trigger it too, since the work happens on
the miss path before CPython suppresses the error. A workload that probes the
same missing names repeatedly (e.g. a per-bar getattr(self, "_optional", None) on
a .NET-derived object) therefore paid the full O(members) reflection + ranking
cost on every access.

Add two caches in ClassBase:
- _candidateNameCache (Type -> string[]): the reflected, deduplicated snake_case
  member names, computed once per type.
- _suggestionCache ((Type, name) -> string[]): the ranked suggestion list,
  memoized so repeated misses of the same name are a dictionary lookup.

Suggestions and error messages are unchanged; only the repeated computation is
removed. On a real Lean multi-symbol minute backtest the suggestion path
dominated ~93% of OnData CPU; with this change the backtest goes from not
finishing (aborted, >15x slower) to ~93s, on par with the last build without the
suggestion feature (~90s), with identical results.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Cache the built suggestion hint string instead of the member-name list

Store the fully-built " Did you mean: ...?" hint (empty when there is nothing
to suggest) in _suggestionCache rather than the ranked string[]. The hint is
now assembled once inside ComputeSimilarMemberNames and memoized per
(type, missing-name); GetSuggestionHint just returns the cached string and
appends it, dropping the per-miss Count check, Select and string.Join.

Behavior and message text are unchanged; a repeated miss is now a single
dictionary lookup returning the ready-made hint.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Move suggestion caches to the class field block; simplify candidate collection

Move the _candidateNameCache and _suggestionCache declarations up to the class
field block with the other fields. In GetCandidateMemberNames, collect the
snake_case names into a single HashSet (named names) instead of a HashSet plus a
List, and return the set directly; deduplication and storage are the same
collection. Candidate iteration order no longer matters -- suggestions are
ordered by edit distance and then by name.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Extend AttributeError suggestions to type-object (static and enum) misses

A missing attribute on a reflected type object -- a mistyped static member or
enum value such as DayOfWeek.Sundey -- previously raised the bare CPython
"type object 'X' has no attribute 'Y'" with no hint, because the miss hook was
installed on reflected types (governing their instances) but type-object access
is governed by the CLR metatype.

Install the same miss-only __getattr__ hook on the CLR metatype (allowing the
redirect when tp_getattro is type_getattro, not just the generic getattr), so a
type-object miss is enriched the same way instance misses are. BuildMissing
AttributeMessage now resolves the target from either a CLRObject (instance) or a
ClassBase (type object) and uses CPython's "type object 'T'" wording for the
latter.

Suggestions reuse the existing ranking/cache and the snake_case convention
Python exposes members under (ToSnakeCaseMemberName): methods become lower_snake
while enum values, consts and static-readonly members become UPPER_SNAKE, e.g.
DayOfWeek.Sundey -> "Did you mean: 'SUNDAY'?", Math.PII -> 'PI', String.Empy ->
'EMPTY'. All suggested names resolve. Hits, imports and hasattr on type objects
are unaffected (the hook is miss-only).

Adds tests for enum, static const, static-readonly field and static method
misses, the no-similar case and hasattr, in test_enum.py and test_class.py.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Update version to 2.0.58

Bump the package <Version>, AssemblyVersion/AssemblyFileVersion and the perf-test
baseline reference to 2.0.58 for the AttributeError suggestion caching and the
static/enum suggestion extension in this PR.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: jhonabreul

src/perf_tests/Python.PerformanceTests.csproj

@@ -13,7 +13,7 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.*" />
-    <PackageReference Include="quantconnect.pythonnet" Version="2.0.57" GeneratePathProperty="true">
+    <PackageReference Include="quantconnect.pythonnet" Version="2.0.58" GeneratePathProperty="true">
       <IncludeAssets>compile</IncludeAssets>
     </PackageReference>
   </ItemGroup>
@@ -25,7 +25,7 @@
   </Target>
 
   <Target Name="CopyBaseline" AfterTargets="Build">
-    <Copy SourceFiles="$(NuGetPackageRoot)quantconnect.pythonnet\2.0.57\lib\net10.0\Python.Runtime.dll" DestinationFolder="$(OutDir)baseline" />
+    <Copy SourceFiles="$(NuGetPackageRoot)quantconnect.pythonnet\2.0.58\lib\net10.0\Python.Runtime.dll" DestinationFolder="$(OutDir)baseline" />
   </Target>
 
   <Target Name="CopyNewBuild" AfterTargets="Build">

src/runtime/AttributeErrorHint.cs

@@ -40,6 +40,10 @@ internal static class AttributeErrorHint
         private static IntPtr _hookSlot;
         // Address of PyObject_GenericGetAttr, used to detect types we may safely redirect.
         private static IntPtr _genericGetAttr;
+        // Address of type_getattro (PyType_Type.tp_getattro). The CLR metatype uses it, so we
+        // allow redirecting it too: that is how attribute access on a reflected type object
+        // (static members, enum values) gets the miss hook.
+        private static IntPtr _typeGetAttro;
 
         private static bool IsReady => _methodDef != IntPtr.Zero && _hookSlot != IntPtr.Zero;
 
@@ -48,6 +52,7 @@ internal static void Initialize()
             try
             {
                 _genericGetAttr = Util.ReadIntPtr(Runtime.PyBaseObjectType, TypeOffset.tp_getattro);
+                _typeGetAttro = Util.ReadIntPtr(Runtime.PyTypeType, TypeOffset.tp_getattro);
 
                 if (_methodDef == IntPtr.Zero)
                 {
@@ -70,6 +75,11 @@ internal static void Initialize()
 
                 using var probe = globals["__clr_getattr_probe__"];
                 _hookSlot = Util.ReadIntPtr(probe.Reference, TypeOffset.tp_getattro);
+
+                // Install the hook on the CLR metatype so that a miss on a reflected type
+                // object's own attribute (a mistyped static member or enum value, e.g.
+                // DayOfWeek.Sundey) is enriched the same way instance attribute misses are.
+                Install(MetaType.ClrMetaTypeReference);
             }
             catch (Exception e)
             {
@@ -94,7 +104,12 @@ internal static void Install(BorrowedReference type)
                 return;
             }
 
-            if (Util.ReadIntPtr(type, TypeOffset.tp_getattro) != _genericGetAttr)
+            var getattro = Util.ReadIntPtr(type, TypeOffset.tp_getattro);
+            // Only redirect types that still use one of the standard lookups: instances use the
+            // generic getattr, the CLR metatype uses type_getattro. Types with a custom
+            // tp_getattro (dynamic objects, modules, interfaces, ...) handle misses themselves
+            // and are left untouched.
+            if (getattro != _genericGetAttr && getattro != _typeGetAttro)
             {
                 return;
             }
@@ -158,6 +173,7 @@ internal static void Shutdown()
             // are reused by the next Initialize.
             _hookSlot = IntPtr.Zero;
             _genericGetAttr = IntPtr.Zero;
+            _typeGetAttro = IntPtr.Zero;
         }
     }
 }

src/runtime/Properties/AssemblyInfo.cs

@@ -4,5 +4,5 @@
 [assembly: InternalsVisibleTo("Python.EmbeddingTest, PublicKey=00240000048000009400000006020000002400005253413100040000110000005ffd8f49fb44ab0641b3fd8d55e749f716e6dd901032295db641eb98ee46063cbe0d4a1d121ef0bc2af95f8a7438d7a80a3531316e6b75c2dae92fb05a99f03bf7e0c03980e1c3cfb74ba690aca2f3339ef329313bcc5dccced125a4ffdc4531dcef914602cd5878dc5fbb4d4c73ddfbc133f840231343e013762884d6143189")]
 [assembly: InternalsVisibleTo("Python.Test, PublicKey=00240000048000009400000006020000002400005253413100040000110000005ffd8f49fb44ab0641b3fd8d55e749f716e6dd901032295db641eb98ee46063cbe0d4a1d121ef0bc2af95f8a7438d7a80a3531316e6b75c2dae92fb05a99f03bf7e0c03980e1c3cfb74ba690aca2f3339ef329313bcc5dccced125a4ffdc4531dcef914602cd5878dc5fbb4d4c73ddfbc133f840231343e013762884d6143189")]
 
-[assembly: AssemblyVersion("2.0.57")]
-[assembly: AssemblyFileVersion("2.0.57")]
+[assembly: AssemblyVersion("2.0.58")]
+[assembly: AssemblyFileVersion("2.0.58")]

src/runtime/Python.Runtime.csproj

@@ -5,7 +5,7 @@
     <RootNamespace>Python.Runtime</RootNamespace>
     <AssemblyName>Python.Runtime</AssemblyName>
     <PackageId>QuantConnect.pythonnet</PackageId>
-    <Version>2.0.57</Version>
+    <Version>2.0.58</Version>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
     <RepositoryUrl>https://github.com/pythonnet/pythonnet</RepositoryUrl>

src/runtime/Types/ClassBase.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
@@ -28,6 +29,18 @@ internal class ClassBase : ManagedType, IDeserializationCallback
         internal readonly Dictionary<int, MethodObject> richcompare = new();
         internal MaybeType type;
 
+        // Reflecting over a managed type's full member set (with FlattenHierarchy) plus the
+        // snake_case conversion is expensive, and the result never changes for a given type.
+        // Compute it once per type.
+        private static readonly ConcurrentDictionary<Type, HashSet<string>> _candidateNameCache = new();
+
+        // A miss-heavy workload probes the same missing names over and over (e.g. a per-bar
+        // getattr(self, "_optional", None) on a .NET-derived object, or a mistyped enum value).
+        // Memoize the fully-built " Did you mean: ...?" hint (empty when there is nothing to
+        // suggest) per (type, missing-name) so repeats are a dictionary lookup instead of an
+        // O(members) reflection + Levenshtein scan on every miss.
+        private static readonly ConcurrentDictionary<(Type Type, string Name), string> _suggestionCache = new();
+
         internal ClassBase(Type tp)
         {
             if (tp is null) throw new ArgumentNullException(nameof(type));
@@ -663,26 +676,61 @@ internal static void AppendAttributeErrorSuggestions(BorrowedReference ob, Borro
         /// </summary>
         internal static string BuildMissingAttributeMessage(PyObject self, string name)
         {
-            var typeName = "object";
             try
             {
-                using var pyType = self.GetPythonType();
-                typeName = pyType.Name;
+                if (TryGetSuggestionTarget(self.Reference, out var type, out var staticScope))
+                {
+                    // Match CPython's wording: instances say "'T' object ...", whereas an access
+                    // on the type object itself (a missing static member or enum value) says
+                    // "type object 'T' ...".
+                    var baseMessage = staticScope
+                        ? $"type object '{type!.Name}' has no attribute '{name}'"
+                        : $"'{PythonTypeName(self)}' object has no attribute '{name}'";
+                    return baseMessage + GetSuggestionHint(type!, name);
+                }
             }
             catch
             {
-                // fall back to the generic type name
+                // never let message building turn into a different exception
             }
 
-            var message = $"'{typeName}' object has no attribute '{name}'";
+            return $"'{PythonTypeName(self)}' object has no attribute '{name}'";
+        }
+
+        private static string PythonTypeName(PyObject self)
+        {
             try
             {
-                return message + GetSuggestionHint(self.Reference, name);
+                using var pyType = self.GetPythonType();
+                return pyType.Name;
             }
             catch
             {
-                // never let suggestion building turn into a different exception
-                return message;
+                return "object";
+            }
+        }
+
+        /// <summary>
+        /// Resolves the managed <see cref="Type"/> whose members should be searched for a
+        /// missing-attribute suggestion, and whether the access was on the type object itself
+        /// (<paramref name="staticScope"/> = true, for static members and enum values) rather
+        /// than on an instance. Returns false for objects that are not reflected .NET types.
+        /// </summary>
+        private static bool TryGetSuggestionTarget(BorrowedReference ob, out Type? type, out bool staticScope)
+        {
+            type = null;
+            staticScope = false;
+            switch (GetManagedObject(ob))
+            {
+                case CLRObject clrObj when clrObj.inst is not null:
+                    type = clrObj.inst.GetType();
+                    return true;
+                case ClassBase classBase when classBase.type.Valid:
+                    type = classBase.type.Value;
+                    staticScope = true;
+                    return true;
+                default:
+                    return false;
             }
         }
 
@@ -694,23 +742,28 @@ internal static string BuildMissingAttributeMessage(PyObject self, string name)
         /// </summary>
         private static string GetSuggestionHint(BorrowedReference ob, string name)
         {
-            if (string.IsNullOrEmpty(name) || name.StartsWith("__", StringComparison.Ordinal))
+            if (!TryGetSuggestionTarget(ob, out var type, out _))
             {
                 return string.Empty;
             }
 
-            if (GetManagedObject(ob) is not CLRObject clrObj || clrObj.inst is null)
-            {
-                return string.Empty;
-            }
+            return GetSuggestionHint(type!, name);
+        }
 
-            var suggestions = GetSimilarMemberNames(clrObj.inst.GetType(), name);
-            if (suggestions.Count == 0)
+        private static string GetSuggestionHint(Type type, string name)
+        {
+            if (string.IsNullOrEmpty(name) || name.StartsWith("__", StringComparison.Ordinal))
             {
                 return string.Empty;
             }
 
-            return " Did you mean: " + string.Join(", ", suggestions.Select(s => $"'{s}'")) + "?";
+            // The hint is built and cached once per (type, name); on a repeated miss this is just
+            // a dictionary lookup. An empty string means there was nothing to suggest. The
+            // suggested names use the same snake_case convention Python exposes members under
+            // (see ToSnakeCaseMemberName), so they are independent of whether the access was on
+            // an instance or the type object.
+            return _suggestionCache.GetOrAdd((type, name),
+                static key => ComputeSimilarMemberNames(key.Type, key.Name));
         }
 
         private static string GetErrorMessage(BorrowedReference value, string fallbackName)
@@ -732,38 +785,52 @@ private static string GetErrorMessage(BorrowedReference value, string fallbackNa
             return $"object has no attribute '{fallbackName}'";
         }
 
-        private static List<string> GetSimilarMemberNames(Type type, string name)
+        // The snake_case candidate member names of a type, cached so the reflection and name
+        // conversion happen at most once per type rather than on every attribute miss. Instance
+        // and static members are both included, and each is converted with ToSnakeCaseMemberName
+        // so the suggestion matches the name Python exposes it under: methods become lower_snake,
+        // while enum values, consts and static-readonly members become UPPER_SNAKE (e.g.
+        // DayOfWeek.SUNDAY, Math.PI, String.EMPTY).
+        private static HashSet<string> GetCandidateMemberNames(Type type)
         {
-            const int MaxSuggestions = 5;
-            var threshold = Math.Max(2, name.Length / 3);
-
-            var seen = new HashSet<string>(StringComparer.Ordinal);
-            var scored = new List<(string Name, int Distance)>();
-
-            var members = type.GetMembers(BindingFlags.Public | BindingFlags.Instance
-                                          | BindingFlags.Static | BindingFlags.FlattenHierarchy);
-            foreach (var member in members)
+            return _candidateNameCache.GetOrAdd(type, static t =>
             {
-                // Skip property/event accessors, operators and other special-name methods,
-                // as well as compiler-generated members; none are accessible by name.
-                if (member is MethodBase { IsSpecialName: true })
-                {
-                    continue;
-                }
+                var names = new HashSet<string>(StringComparer.Ordinal);
 
-                if (member.Name.Length == 0 || member.Name[0] == '<')
+                var members = t.GetMembers(BindingFlags.Public | BindingFlags.Instance
+                                              | BindingFlags.Static | BindingFlags.FlattenHierarchy);
+                foreach (var member in members)
                 {
-                    continue;
-                }
+                    // Skip property/event accessors, operators and other special-name methods,
+                    // as well as compiler-generated members; none are accessible by name.
+                    if (member is MethodBase { IsSpecialName: true })
+                    {
+                        continue;
+                    }
 
-                // Suggest the snake_case alias, since that is the fork's PEP8-style
-                // public API surface (members are exposed in both Pascal and snake case).
-                var candidate = ToSnakeCaseMemberName(member);
-                if (!seen.Add(candidate))
-                {
-                    continue;
+                    if (member.Name.Length == 0 || member.Name[0] == '<')
+                    {
+                        continue;
+                    }
+
+                    names.Add(ToSnakeCaseMemberName(member));
                 }
 
+                return names;
+            });
+        }
+
+        // Builds the " Did you mean: 'x', 'y'?" hint for a missing attribute, or an empty
+        // string when no member is similar enough to suggest. The result is cached in
+        // _suggestionCache, so this runs at most once per (type, missing-name).
+        private static string ComputeSimilarMemberNames(Type type, string name)
+        {
+            const int MaxSuggestions = 5;
+            var threshold = Math.Max(2, name.Length / 3);
+
+            var scored = new List<(string Name, int Distance)>();
+            foreach (var candidate in GetCandidateMemberNames(type))
+            {
                 var distance = LevenshteinDistance(name, candidate);
                 var related = distance <= threshold
                     || candidate.IndexOf(name, StringComparison.OrdinalIgnoreCase) >= 0
@@ -774,12 +841,18 @@ private static List<string> GetSimilarMemberNames(Type type, string name)
                 }
             }
 
-            return scored
+            if (scored.Count == 0)
+            {
+                return string.Empty;
+            }
+
+            var suggestions = scored
                 .OrderBy(t => t.Distance)
                 .ThenBy(t => t.Name, StringComparer.OrdinalIgnoreCase)
                 .Take(MaxSuggestions)
-                .Select(t => t.Name)
-                .ToList();
+                .Select(t => $"'{t.Name}'");
+
+            return " Did you mean: " + string.Join(", ", suggestions) + "?";
         }
 
         private static string ToSnakeCaseMemberName(MemberInfo member)

src/runtime/Types/MetaType.cs

@@ -26,6 +26,13 @@ internal sealed class MetaType : ManagedType
             "__subclasscheck__",
         };
 
+        /// <summary>
+        /// The CLR metatype object. Reflected .NET types are instances of it, so wiring the
+        /// AttributeError miss hook here enriches misses on a type object's own attributes
+        /// (static members and enum values).
+        /// </summary>
+        internal static BorrowedReference ClrMetaTypeReference => PyCLRMetaType.Reference;
+
         /// <summary>
         /// Metatype initialization. This bootstraps the CLR metatype to life.
         /// </summary>