Problem Description

This problem requires implementing a small Python "feature" framework using metaprogramming. The goal is to define a system that can parse type-annotated classes into Feature objects, parse functions into Resolver objects, and then automatically compute desired output features by chaining these resolvers based on known input feature values.

You must implement the parts marked Implement me! so that all provided tests pass without modification.

Step 1: Parse Features from Annotated Classes

Implement the @features class decorator. This decorator should transform a class definition as follows:

• For each type-annotated attribute in the decorated class, a Feature instance must be created. The Feature dataclass is defined with name: str and typ: type.
  • The name of the Feature should be "<ClassName>.<field_name>" (for example, "User.name").
  • The typ of the Feature should be the Python type of that attribute. This includes resolving forward references (string annotations like "User" should resolve to the actual User class).
• The decorated class must gain a class attribute named features, which is a list of all Feature instances for that class, ordered by their declaration.
• Each annotated attribute of the class (e.g., User.id, User.email) must evaluate to its corresponding Feature instance, such that expressions like User.id == Feature(name="User.id", typ=int) are true.

Step 2: Parse Resolvers from Functions

Implement the @resolver function decorator. This decorator should transform a function definition as follows:

• The original function must be wrapped within a Resolver dataclass instance. The Resolver dataclass is defined with inputs: list[Feature], output: Feature, and fn: Callable.
• The inputs list must be extracted from the function's parameter annotations, in order. These annotations are assumed to be Feature objects (e.g., id: User.id).
• The output must be extracted from the function's return annotation, which is also assumed to be a Feature object.
• The original function must be stored in the Resolver.fn attribute so it can be called later.

You may choose to register all created Resolver instances in a global registry for use by the execute function in Step 3; the exact mechanism is up to you, as long as the behavior matches the tests.

Step 3: Implement the Execution Engine

Implement the execute function with the signature execute(inputs: dict[Feature | Any, Any], outputs: list[Feature | Any]) -> dict[Feature, Any].

• The inputs parameter is a dictionary mapping Feature objects (or alternative keys you choose to support) to their concrete values (e.g., {User.id: 1}).
• The outputs parameter is a list of requested output Feature objects (or something you map to a Feature).
• The function must return a dictionary mapping Feature objects to their computed values for all requested outputs.
• It must use the Resolver objects created by the @resolver decorator.
• It must repeatedly apply resolvers whose input features are all known, continuing until all requested outputs are computed or no further progress can be made.
• For the cases in the provided tests, it must successfully compute User.is_fraud from User.id by chaining through the appropriate resolvers.

Useful Tools (Not Required)

You may find the following Python tools useful:

• cls.__annotations__
• cls.__name__
• setattr(obj, key, value)
• inspect.signature(fn)
• typing.get_type_hints