feat(python): class method attribute

Author: dbrattli

src/Fable.Core/Fable.Core.Py.fs

@@ -28,8 +28,8 @@ module Py =
         abstract Decorate: fn: Callable * info: Reflection.MethodInfo -> Callable
 
     /// <summary>
-    /// Adds Python decorators to generated classes, enabling integration with Python
-    /// frameworks like dataclasses, attrs, functools, and any other decorator-based
+    /// Adds Python decorators to generated classes or methods, enabling integration with Python
+    /// frameworks like dataclasses, attrs, functools, Pydantic, and any other decorator-based
     /// libraries.
     /// </summary>
     /// <remarks>
@@ -38,15 +38,33 @@ module Py =
     /// <para>Multiple [&lt;Decorate&gt;] attributes are applied in reverse order
     /// (bottom to top), following Python's standard decorator stacking behavior.</para>
     /// <para>Examples:</para>
-    /// <para>[&lt;Decorate("dataclasses.dataclass")&gt;] - Simple decorator</para>
+    /// <para>[&lt;Decorate("dataclasses.dataclass")&gt;] - Simple class decorator</para>
     /// <para>[&lt;Decorate("functools.lru_cache", "maxsize=128")&gt;] - Decorator with
     /// parameters</para>
+    /// <para>[&lt;Decorate("pydantic.field_validator", "'Name'")&gt;] - Method decorator for
+    /// Pydantic validators</para>
     /// </remarks>
-    [<AttributeUsage(AttributeTargets.Class, AllowMultiple = true)>]
+    [<AttributeUsage(AttributeTargets.Class ||| AttributeTargets.Method, AllowMultiple = true)>]
     type DecorateAttribute(decorator: string) =
         inherit Attribute()
         new(decorator: string, parameters: string) = DecorateAttribute(decorator)
 
+    /// <summary>
+    /// Marks a static member to be emitted as a Python @classmethod instead of @staticmethod.
+    /// </summary>
+    /// <remarks>
+    /// <para>Use this attribute on static members when you need the first parameter to receive
+    /// the class (cls) instead of being a regular static method.</para>
+    /// <para>This is commonly needed for Pydantic validators and other Python frameworks that
+    /// require @classmethod decorators.</para>
+    /// <para>Example:</para>
+    /// <para>[&lt;Py.ClassMethod&gt;]</para>
+    /// <para>static member validate_name(cls, v: string) = ...</para>
+    /// </remarks>
+    [<AttributeUsage(AttributeTargets.Method)>]
+    type ClassMethodAttribute() =
+        inherit Attribute()
+
     [<RequireQualifiedAccess>]
     type ClassAttributeStyle =
         // Translates to properties with instance attributes backing

src/Fable.Transforms/Python/Fable2Python.Transforms.fs

@@ -2906,8 +2906,14 @@ let transformAttachedProperty
             []
         else
             // Instance properties use the traditional approach (properties style)
+            // Get custom decorators from Py.Decorate attributes
+            let customDecorators =
+                let decoratorInfos = Util.getDecoratorInfo info.Attributes
+                Util.generateDecorators com ctx decoratorInfos
+
             let decorators =
-                [
+                customDecorators
+                @ [
                     if isGetter then
                         Expression.name "property"
                     else
@@ -2947,11 +2953,26 @@ let transformAttachedMethod (com: IPythonCompiler) ctx (info: Fable.MemberFuncti
 
     let isStatic = not info.IsInstance
 
+    // Check if this method has Py.ClassMethod attribute
+    let hasClassMethodAttribute =
+        info.Attributes
+        |> Seq.exists (fun att -> att.Entity.FullName = Atts.pyClassMethod)
+
+    // Get custom decorators from Py.Decorate attributes
+    let customDecorators =
+        let decoratorInfos = Util.getDecoratorInfo info.Attributes
+        Util.generateDecorators com ctx decoratorInfos
+
     let decorators =
-        if isStatic then
-            [ Expression.name "staticmethod" ]
-        else
-            []
+        // Custom decorators come first (outermost), then static/classmethod decorator
+        customDecorators
+        @ if isStatic then
+              if hasClassMethodAttribute then
+                  [ Expression.name "classmethod" ]
+              else
+                  [ Expression.name "staticmethod" ]
+          else
+              []
 
     let makeMethod name args body decorators returnType =
         let key = memberFromName com ctx name |> nameFromKey com ctx

src/Fable.Transforms/Transforms.Util.fs

@@ -127,6 +127,9 @@ module Atts =
     [<Literal>]
     let pyClassAttributes = "Fable.Core.Py.ClassAttributes" // typeof<Fable.Core.Py.ClassAttributes>.FullName
 
+    [<Literal>]
+    let pyClassMethod = "Fable.Core.Py.ClassMethodAttribute" // typeof<Fable.Core.Py.ClassMethodAttribute>.FullName
+
     [<Literal>]
     let dartIsConst = "Fable.Core.Dart.IsConstAttribute" // typeof<Fable.Core.Dart.IsConstAttribute>.FullName
 

tests/Python/TestPyInterop.fs

@@ -590,6 +590,73 @@ let ``test PropertiesUserWithInit`` () =
     user.Email |> equal (Some "[email protected]")
     user.Enabled |> equal true
 
+// Test Py.Decorate on static methods
+
+[<AttachMembers>]
+type ClassWithDecoratedStaticMethod() =
+    member val Value: int = 0 with get, set
+
+    [<Py.Decorate("functools.lru_cache")>]
+    static member cached_function(x: int) : int =
+        x * 2
+
+[<Fact>]
+let ``test Py.Decorate on static method`` () =
+    // Test that @lru_cache decorator is applied to static method
+    let result1 = ClassWithDecoratedStaticMethod.cached_function(5)
+    let result2 = ClassWithDecoratedStaticMethod.cached_function(5)
+    result1 |> equal 10
+    result2 |> equal 10
+
+[<AttachMembers>]
+type ClassWithDecoratedStaticMethodWithParams() =
+    [<Py.Decorate("functools.lru_cache", "maxsize=32")>]
+    static member cached_with_params(x: int) : int =
+        x * 3
+
+[<Fact>]
+let ``test Py.Decorate on static method with parameters`` () =
+    // Test that decorator with parameters is applied to static method
+    let result = ClassWithDecoratedStaticMethodWithParams.cached_with_params(4)
+    result |> equal 12
+
+[<AttachMembers>]
+type ClassWithClassMethod() =
+    member val Name: string = "" with get, set
+
+    // Note: With @classmethod, Python automatically passes `cls` as first argument
+    // So from F# we only pass the remaining arguments
+    [<Py.ClassMethod>]
+    static member create_instance(cls: obj, name: string) : ClassWithClassMethod =
+        let instance = ClassWithClassMethod()
+        instance.Name <- name
+        instance
+
+[<Fact>]
+let ``test Py.ClassMethod attribute`` () =
+    // Test that @classmethod decorator is applied instead of @staticmethod
+    // Note: cls is automatically passed by Python, so we only pass the name argument
+    // We use Emit to call the method without the cls argument from F#
+    let instance = emitPyExpr<ClassWithClassMethod> [] "ClassWithClassMethod.create_instance('TestName')"
+    instance.Name |> equal "TestName"
+
+
+[<AttachMembers>]
+type ClassWithMultipleDecoratedMethods() =
+    [<Py.Decorate("functools.lru_cache", "maxsize=16")>]
+    static member method_a(x: int) : int = x * 2
+
+    [<Py.Decorate("functools.lru_cache", "maxsize=32")>]
+    static member method_b(x: int) : int = x * 3
+
+[<Fact>]
+let ``test multiple static methods with decorators`` () =
+    // Test that decorators work on multiple static methods in same class
+    let resultA = ClassWithMultipleDecoratedMethods.method_a(5)
+    let resultB = ClassWithMultipleDecoratedMethods.method_b(5)
+    resultA |> equal 10
+    resultB |> equal 15
+
 // Import fable_library version to verify we're using local build, not PyPI
 let fableLibraryVersion: string = import "__version__" "fable_library._version"