[Python] Add decorateTemplateAttribute

Author: dbrattli

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

@@ -16,11 +16,48 @@ module Py =
         [<Emit "$0">]
         abstract Instance: obj
 
+    /// <summary>
+    /// Base class for creating F#-side decorator attributes that transform functions at compile time.
+    /// This is similar to Python decorators but operates during Fable compilation, not at Python runtime.
+    /// </summary>
+    /// <remarks>
+    /// <para>Inherit from this class and implement the Decorate method to wrap or transform functions.</para>
+    /// <para>The decorated function is passed to Decorate, and the returned Callable replaces it.</para>
+    /// <para>Example:</para>
+    /// <code>
+    /// type LogAttribute() =
+    ///     inherit Py.DecoratorAttribute()
+    ///     override _.Decorate(fn) =
+    ///         Py.argsFunc (fun args ->
+    ///             printfn "Calling function"
+    ///             fn.Invoke(args))
+    /// </code>
+    /// <para>Note: This does NOT emit Python @decorator syntax. For emitting Python decorators,
+    /// use DecorateAttribute or DecorateTemplateAttribute instead.</para>
+    /// </remarks>
     [<AbstractClass>]
     type DecoratorAttribute() =
         inherit Attribute()
         abstract Decorate: fn: Callable -> Callable
 
+    /// <summary>
+    /// Base class for creating F#-side decorator attributes with access to reflection metadata.
+    /// Like DecoratorAttribute, but the Decorate method also receives MethodInfo for the decorated member.
+    /// </summary>
+    /// <remarks>
+    /// <para>Use this when your decorator needs information about the decorated method (name, parameters, etc.).</para>
+    /// <para>Example:</para>
+    /// <code>
+    /// type LogWithNameAttribute() =
+    ///     inherit Py.ReflectedDecoratorAttribute()
+    ///     override _.Decorate(fn, info) =
+    ///         Py.argsFunc (fun args ->
+    ///             printfn "Calling %s" info.Name
+    ///             fn.Invoke(args))
+    /// </code>
+    /// <para>Note: This does NOT emit Python @decorator syntax. For emitting Python decorators,
+    /// use DecorateAttribute or DecorateTemplateAttribute instead.</para>
+    /// </remarks>
     [<AbstractClass>]
     type ReflectedDecoratorAttribute() =
         inherit Attribute()
@@ -49,7 +86,31 @@ module Py =
         /// Decorator with import but no parameters
         new(decorator: string, importFrom: string) = DecorateAttribute(decorator, importFrom, "")
 
-    /// Decorator with all parameters
+    /// <summary>
+    /// Marks a custom attribute class as a decorator template, enabling library authors to create
+    /// ergonomic decorator attributes that users can apply without knowing the underlying Python syntax.
+    /// </summary>
+    /// <remarks>
+    /// <para>Place this attribute on a custom attribute class. The template string uses {0}, {1}, etc.
+    /// as placeholders for the custom attribute's constructor arguments.</para>
+    /// <para>Example - defining a custom decorator attribute:</para>
+    /// <code>
+    /// [&lt;Py.DecorateTemplate("app.get(\"{0}\")")&gt;]
+    /// type GetAttribute(path: string) = inherit Attribute()
+    /// </code>
+    /// <para>Example - using the custom decorator:</para>
+    /// <code>
+    /// [&lt;Get("/users")&gt;]
+    /// static member get_users() = ...
+    /// // Generates: @app.get("/users")
+    /// </code>
+    /// </remarks>
+    [<AttributeUsage(AttributeTargets.Class)>]
+    type DecorateTemplateAttribute(template: string) =
+        inherit Attribute()
+        /// Template with import specification
+        new(template: string, importFrom: string) = DecorateTemplateAttribute(template)
+
     /// <summary>
     /// Marks a static member to be emitted as a Python @classmethod instead of @staticmethod.
     /// </summary>

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

@@ -2674,7 +2674,7 @@ let declareClassType
 
     // Generate custom decorators from [<Decorate>] attributes
     let customDecorators =
-        let decoratorInfos = Util.getDecoratorInfo ent.Attributes
+        let decoratorInfos = Util.getDecoratorInfo com ent.Attributes
         Util.generateDecorators com ctx decoratorInfos
 
     stmts
@@ -2908,7 +2908,7 @@ let transformAttachedProperty
             // Instance properties use the traditional approach (properties style)
             // Get custom decorators from Py.Decorate attributes
             let customDecorators =
-                let decoratorInfos = Util.getDecoratorInfo info.Attributes
+                let decoratorInfos = Util.getDecoratorInfo com info.Attributes
                 Util.generateDecorators com ctx decoratorInfos
 
             let decorators =
@@ -2960,7 +2960,7 @@ let transformAttachedMethod (com: IPythonCompiler) ctx (info: Fable.MemberFuncti
 
     // Get custom decorators from Py.Decorate attributes
     let customDecorators =
-        let decoratorInfos = Util.getDecoratorInfo info.Attributes
+        let decoratorInfos = Util.getDecoratorInfo com info.Attributes
         Util.generateDecorators com ctx decoratorInfos
 
     let decorators =
@@ -3723,6 +3723,9 @@ let rec transformDeclaration (com: IPythonCompiler) ctx (decl: Fable.Declaration
         elif hasEraseAttribute && ent.IsInterface then
             // Erased interfaces should not generate any code
             []
+        elif hasEraseAttribute then
+            // Erased classes (e.g., custom attribute types) should not generate any code
+            []
         else
             // Check for PythonClass attribute and extract parameters
             let classAttributes =

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

@@ -70,9 +70,36 @@ module Util =
         )
         |> Option.defaultValue defaultParams
 
+    /// Tries to find a DecorateTemplateAttribute on the attribute's type
+    /// and format the template with the attribute's constructor args
+    let private tryGetTemplateDecoratorInfo (com: Fable.Compiler) (att: Fable.Attribute) =
+        com.TryGetEntity(att.Entity)
+        |> Option.bind (fun attEntity ->
+            attEntity.Attributes
+            |> Seq.tryFind (fun a -> a.Entity.FullName = Atts.pyDecorateTemplate)
+            |> Option.bind (fun templateAtt ->
+                match templateAtt.ConstructorArgs with
+                | [ :? string as template ] ->
+                    Some
+                        {
+                            Decorator = String.Format(template, att.ConstructorArgs |> List.toArray)
+                            Parameters = ""
+                            ImportFrom = ""
+                        }
+                | [ :? string as template; :? string as importFrom ] ->
+                    Some
+                        {
+                            Decorator = String.Format(template, att.ConstructorArgs |> List.toArray)
+                            Parameters = ""
+                            ImportFrom = importFrom
+                        }
+                | _ -> None
+            )
+        )
+
     /// Extracts decorator information from entity attributes
     /// Constructor args order: (decorator, importFrom, parameters)
-    let getDecoratorInfo (atts: Fable.Attribute seq) =
+    let getDecoratorInfo (com: Fable.Compiler) (atts: Fable.Attribute seq) =
         atts
         |> Seq.choose (fun att ->
             if att.Entity.FullName = Atts.pyDecorate then
@@ -100,7 +127,8 @@ module Util =
                         }
                 | _ -> None // Invalid decorator
             else
-                None
+                // Try to find a DecorateTemplateAttribute on this attribute's type
+                tryGetTemplateDecoratorInfo com att
         )
         |> Seq.toList
 

src/Fable.Transforms/Transforms.Util.fs

@@ -124,6 +124,9 @@ module Atts =
     [<Literal>]
     let pyDecorate = "Fable.Core.Py.DecorateAttribute" // typeof<Fable.Core.Py.DecorateAttribute>.FullName
 
+    [<Literal>]
+    let pyDecorateTemplate = "Fable.Core.Py.DecorateTemplateAttribute" // typeof<Fable.Core.Py.DecorateTemplateAttribute>.FullName
+
     [<Literal>]
     let pyClassAttributes = "Fable.Core.Py.ClassAttributes" // typeof<Fable.Core.Py.ClassAttributes>.FullName
 

tests/Python/TestPyInterop.fs

@@ -283,26 +283,26 @@ type NativeCode =
 
 [<Fact>]
 let ``test importAll`` () =
-    let nativeCode: NativeCode = importAll "./native_code.py"
+    let nativeCode: NativeCode = importAll "./py/native_code.py"
     3 |> nativeCode.add5 |> equal 8
 
-let add5 (x: int): int = importMember "./native_code.py"
+let add5 (x: int): int = importMember "./py/native_code.py"
 
 [<Fact>]
 let ``test importMember`` () =
     add5 -1 |> equal 4
 
     // Cannot use the same name as Fable will mangle the identifier
-    let add7: int -> int = importMember "./native_code.py"
+    let add7: int -> int = importMember "./py/native_code.py"
     add7 12 |> equal 19
 
-    let add5': int -> int = import "add5" "./native_code.py"
+    let add5': int -> int = import "add5" "./py/native_code.py"
     add5' 12 |> equal 17
 
-    let multiply3 (x: int): int = importMember "./more_native_code.py"
+    let multiply3 (x: int): int = importMember "./py/more_native_code.py"
     multiply3 9 |> equal 27
 
-[<ImportAll("./native_code.py")>]
+[<ImportAll("./py/native_code.py")>]
 let nativeCode: NativeCode = nativeOnly
 
 [<Fact>]
@@ -612,7 +612,7 @@ let ``test PropertiesUserWithInit`` () =
 // Test Py.Decorate without import (local variable decorator like FastAPI app.get)
 
 // Simulate a decorator factory (like FastAPI's app instance)
-let my_decorator (path: string) : (obj -> obj) = import "my_decorator" "./native_code.py"
+let my_decorator (path: string) : (obj -> obj) = import "my_decorator" "./py/native_code.py"
 
 [<AttachMembers>]
 type ClassWithLocalDecorator() =
@@ -722,4 +722,64 @@ let ``test fable_library version is local build`` () =
     // instead of the locally built fable-library
     equal "0.0.0" fableLibraryVersion
 
+// Test DecorateTemplate attribute for creating custom decorator attributes
+// This demonstrates how library authors can create ergonomic FastAPI-style attributes
+
+// Simulated FastAPI app instance (imported from native code)
+let app: obj = import "app" "./py/native_code.py"
+
+// Custom decorator attributes using DecorateTemplate
+// Library authors define these once, users get clean syntax
+[<Erase; Py.DecorateTemplate("app.get(\"{0}\")")>]
+type GetAttribute(path: string) =
+    inherit Attribute()
+
+[<Erase; Py.DecorateTemplate("app.post(\"{0}\")")>]
+type PostAttribute(path: string) =
+    inherit Attribute()
+
+[<Erase; Py.DecorateTemplate("app.delete(\"{0}\")")>]
+type DeleteAttribute(path: string) =
+    inherit Attribute()
+
+// Users get clean, intuitive API similar to Python FastAPI:
+[<Py.ClassAttributes(style = Py.ClassAttributeStyle.Attributes, init = false)>]
+type TestAPI() =
+    [<Get("/")>]
+    static member root() = {| message = "Hello World" |}
+
+    [<Get("/items/{item_id}")>]
+    static member get_item(item_id: int) = {| item_id = item_id |}
+
+    [<Post("/items")>]
+    static member create_item(name: string) = {| name = name; created = true |}
+
+    [<Delete("/items/{item_id}")>]
+    static member delete_item(item_id: int) = {| deleted = item_id |}
+
+[<Fact>]
+let ``test DecorateTemplate generates FastAPI-style decorators`` () =
+    // Test that @app.get("/") decorator is applied and works
+    let result = TestAPI.root()
+    result.["message"] |> equal "Hello World"
+
+[<Fact>]
+let ``test DecorateTemplate with path parameter`` () =
+    // Test that @app.get("/items/{item_id}") decorator works with path params
+    let result = TestAPI.get_item(42)
+    result.["item_id"] |> equal 42
+
+[<Fact>]
+let ``test DecorateTemplate POST endpoint`` () =
+    // Test that @app.post("/items") decorator works
+    let result = TestAPI.create_item("test-item")
+    result.["name"] |> equal "test-item"
+    result.["created"] |> equal true
+
+[<Fact>]
+let ``test DecorateTemplate DELETE endpoint`` () =
+    // Test that @app.delete("/items/{item_id}") decorator works
+    let result = TestAPI.delete_item(123)
+    result.["deleted"] |> equal 123
+
 #endif

tests/Python/native_code.py

@@ -0,0 +1,68 @@
+from collections.abc import Callable
+from typing import ParamSpec, TypeVar
+
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+# Simulated FastAPI-like app for testing DecorateTemplate
+class MockFastAPI:
+    """A mock FastAPI app that simulates route decorators."""
+
+    def get(self, path: str) -> Callable[[Callable[P, R]], Callable[P, R]]:
+        """Simulate @app.get(path) decorator."""
+
+        def decorator(func: Callable[P, R]) -> Callable[P, R]:
+            return func
+
+        return decorator
+
+    def post(self, path: str) -> Callable[[Callable[P, R]], Callable[P, R]]:
+        """Simulate @app.post(path) decorator."""
+
+        def decorator(func: Callable[P, R]) -> Callable[P, R]:
+            return func
+
+        return decorator
+
+    def delete(self, path: str) -> Callable[[Callable[P, R]], Callable[P, R]]:
+        """Simulate @app.delete(path) decorator."""
+
+        def decorator(func: Callable[P, R]) -> Callable[P, R]:
+            return func
+
+        return decorator
+
+    def put(self, path: str) -> Callable[[Callable[P, R]], Callable[P, R]]:
+        """Simulate @app.put(path) decorator."""
+
+        def decorator(func: Callable[P, R]) -> Callable[P, R]:
+            return func
+
+        return decorator
+
+
+# Global app instance for tests
+app = MockFastAPI()
+
+
+def add5(x: int) -> int:
+    return x + 5
+
+
+def add7(x: int) -> int:
+    return x + 7
+
+
+def my_decorator(path: str) -> Callable[[Callable[P, R]], Callable[P, str]]:
+    """A decorator factory that simulates FastAPI's app.get/post pattern."""
+
+    def decorator(func: Callable[P, R]) -> Callable[P, str]:
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> str:
+            result = func(*args, **kwargs)
+            return f"decorated: {result}"
+
+        return wrapper
+
+    return decorator