immutable Mapping hooks

[salotz]

• cattrs version: 23.2.3
• Python version: 3.11
• Operating System: Linux

Description

I am bringing in an immutable mapping data type (i.e. immutables.Map https://github.com/MagicStack/immutables) into my code.

I think given that issubclass(immutables.Map, Mapping == True the is_mapping predicate should work for it and there is really no special constructor for it.

What I Did

My first attempt was to register these hooks:

from immutables import Map as frozenmap
...
converter.register_structure_hook(frozenmap, lambda d, t: frozenmap(d))
converter.register_unstructure_hook(frozenmap, lambda d: dict(d))

Which works for a plain frozenmap annotation, but not for generic type specifiers. I can write the hook factory/predicate, but I don't see why the is_mapping code should be specific to mutable mappings:

cattrs/src/cattrs/_compat.py

Lines 407 to 419 in e2ce66b

	def is_mapping(type):
	return (
	type in (dict, Dict, TypingMapping, TypingMutableMapping, AbcMutableMapping)
	or (
	type.__class__ is _GenericAlias
	and is_subclass(type.__origin__, TypingMapping)
	)
	or (
	getattr(type, "__origin__", None)
	in (dict, AbcMutableMapping, AbcMapping)
	)
	or is_subclass(type, dict)
	)

[salotz]

For anyone curious of my solution in the meantime:

from typing import Type, Any, get_origin, TypeVar, Callable
import inspect

# Third Party Library
from cattrs import BaseConverter
from immutables import Map as frozenmap

T = TypeVar("T")
U = TypeVar("U")


def frozenmap_predicate(
        typ: Type[Any],
) -> bool:

    if inspect.isclass(typ):
        return issubclass(typ, frozenmap)
    elif is_generic_container_type(typ):
        return get_origin(typ) is frozenmap
    else:
        return False
    
def frozenmap_unstructure_factory(typ: Type[frozenmap[T,U]]) -> Callable[[frozenmap[T,U]], dict[T,U]]:
    return lambda d: dict(d)
    
def frozenmap_structure_factory(typ: Type[frozenmap[T,U]]) -> Callable[Any, Type[dict[T,U]], frozenmap[T,U]]:
    return lambda d, t: frozenmap(d)

def register_frozenmap_hooks(converter: BaseConverter) -> None:

    converter.register_structure_hook_factory(
        frozenmap_predicate,
        frozenmap_structure_factory,
    )
    converter.register_unstructure_hook_factory(
        frozenmap_predicate,
        frozenmap_unstructure_factory,
    )

[Tinche]

The predicate being used here is:

cattrs/src/cattrs/_compat.py

Line 407 in e2ce66b

def is_mapping(type):

and

cattrs/src/cattrs/_compat.py

Line 518 in e2ce66b

def is_mapping(type):

(for 3.8).

Can these be improved to also work for immutables?

[salotz]

Can these be improved to also work for immutables?

I would think so via handling of ABCs. I'll check over this new documentation. I can't promise being able to write an MR anytime soon though.

In general though perhaps there is a way to register standard hooks for anything satisfying subclass relations to collections.abc base classes, e.g. if issubclass(typ, Mapping) then hooks would be basic dict conversion. It might need to be an opt-in strategy but would reduce boilerplate for users.

[Tinche]

I also use immutables so I'm interested in getting this working. I started a PR to play around with this over the next couple of days.