Generating collection of abstract base class type

[seyfahni]

Summary

I have an attrs class that contains a dict of other classes, but the annotated type is an abstract base class. How can I tell Polyfactory that it should use a specific sub-class factory for generating the elements of that dict?

Details

Structures

Given this simplified data structure code:

@attrs.define(eq=False)
class Element(metaclass=abc.ABCMeta):
    value: float

    @abc.abstractmethod
    def do_something(self) -> float: ...

class ConcreteElement(Element):
    def do_something(self) -> float:
        return self.value

@attrs.define
class Composite:
    element: Element

@attrs.define
class Container:
    elements: dict[str, Element]

Easy Factories

The factories for the first two concrete classes can be easily defined:

class ElementFactory(AttrsFactory[ConcreteElement]): ...

class CompositeFactory(AttrsFactory[Composite]):
    element = Use(ElementFactory.build)

Bad Solutions

But I don't see any good way to define a Factory for the third class. So I've tried various things, but the only two working solutions that I could find are as follows:

DIY Factory

This method completely looses any flexibility that Polyfactory offers, no just defining collection length unless it is re-implemented every time:

class MethodContainerFactory(AttrsFactory[Container]):
    @classmethod
    def elements(cls):
        return {"foo": ElementFactory.build()}

Writing to Protected Properties

This method works like a charm, but it feels wrong to use undocumented class-fields that might just change in between patch versions as it is not part of the official API.

class ContainerFactory(AttrsFactory[Container]): ...

BaseFactory._factory_type_mapping[Element] = ElementFactory

Default Factories

Looking at the code it seems that there is currently no official way besides __set_as_default_factory_for_type__ to define a factory as a default factory, not even for super-types. __set_as_default_factory_for_type__ does only accept booleans and sets the default factory only for the exact type of the model and nothing else:

        if cls.__set_as_default_factory_for_type__ and hasattr(cls, "__model__"):
            BaseFactory._factory_type_mapping[cls.__model__] = cls

---

How is this case to be handled? Did I miss anything? What would you recommend me to to?

---

Full Test Code & Example Output

import abc
from typing import Any

import attrs
from polyfactory import Use, BaseFactory
from polyfactory.factories.attrs_factory import AttrsFactory


@attrs.define(eq=False)
class Element(metaclass=abc.ABCMeta):
    value: float

    @abc.abstractmethod
    def do_something(self) -> float: ...


class ConcreteElement(Element):
    def do_something(self) -> float:
        return self.value


@attrs.define
class Composite:
    element: Element


@attrs.define
class Container:
    elements: dict[str, Element]


class ElementFactory(AttrsFactory[ConcreteElement]): ...

class BrokenCompositeFactory(AttrsFactory[Composite]):
    element = Use(ElementFactory)


class CompositeFactory(AttrsFactory[Composite]):
    element = Use(ElementFactory.build)


class ContainerFactory(AttrsFactory[Container]): ...


class UseContainerFactory(AttrsFactory[Container]):
    elements = Use(ElementFactory.build)


class ProviderMapContainerFactory(AttrsFactory[Container]):
    @classmethod
    def get_provider_map(cls) -> dict[type, Any]:
        providers_map = super().get_provider_map()

        return {
            Element: ElementFactory.build,
            **providers_map,
        }


class TypeOverrideContainerFactory(AttrsFactory[Container]):
    __type_overrides__ = {Element: ElementFactory.build}


class MethodContainerFactory(AttrsFactory[Container]):
    @classmethod
    def elements(cls):
        return {"foo": ElementFactory.build()}


def try_create(factory):
    try:
        obj = factory.build()
        print(f"{factory.__name__} - success: {repr(obj)}")
    except Exception as ex:
        print(f"{factory.__name__} - failed: {repr(ex)}")


try_create(ElementFactory)
try_create(BrokenCompositeFactory)
try_create(CompositeFactory)
try_create(ContainerFactory)
try_create(UseContainerFactory)
try_create(ProviderMapContainerFactory)
try_create(TypeOverrideContainerFactory)
try_create(MethodContainerFactory)
print("Registering ElementFactory for Element type...")
BaseFactory._factory_type_mapping[Element] = ElementFactory
try_create(ContainerFactory)

ElementFactory - success: ConcreteElement(value=-59956609021.1241)
BrokenCompositeFactory - success: Composite(element=<__main__.ElementFactory object at 0x7737bd613d70>)
CompositeFactory - success: Composite(element=ConcreteElement(value=9781733.7957184))
ContainerFactory - failed: TypeError("Can't instantiate abstract class Element without an implementation for abstract method 'do_something'")
UseContainerFactory - success: Container(elements=ConcreteElement(value=7977535438.98355))
ProviderMapContainerFactory - failed: TypeError("Can't instantiate abstract class Element without an implementation for abstract method 'do_something'")
TypeOverrideContainerFactory - failed: TypeError("Can't instantiate abstract class Element without an implementation for abstract method 'do_something'")
MethodContainerFactory - success: Container(elements={'foo': ConcreteElement(value=95.2503692953739)})
Registering ElementFactory for Element type...
ContainerFactory - success: Container(elements={'ZvjYPTTthGmsgTIHBgRa': ConcreteElement(value=6.12086637877049)})