From annotated functions to meshes

[thorwhalen]

Consider the code below that is meant to express the interface of a Groups class via the methods it contains, as well as their annotations.

from typing import MutableMapping, Iterable, Any, NewType, Callable

Group = NewType('Group', str)
Item = NewType('Item', Any)

class Groups:
    add_item_to_group: Callable[[Item, Group], Any]
    add_items_to_group: Callable[[Iterable[Item], Group], Any]
    list_groups: Callable[[], Iterable[Group]]
    items_for_group: Callable[[Group],Iterable[Item]]

The Groups class above, or rather, just the annotated methods it holds (and it's really the only role of that Groups class: To hold empty annotated methods) is sufficient information to define a protocol:

from typing import Protocol

class GroupsProtocol(Protocol):
    def add_items_to_group(self, item: Item, group: Group) -> Any:
        pass
        
    def add_items_to_group(self, items: Iterable[Item], group: Group) -> Any:
        pass
    
    def list_groups(self) -> Iterable[Group]:
        pass
        
    def items_for_group(self, group: Group) -> Iterable[Item]:
        pass

or a dataclass with the same interface, or some mesh/dag that would hook the methods/functions up according to their annotations.

For example, we'd have a function:

def func_types_to_protocol(func_types: Dict[str, typing._CallableGenericAlias]) -> typing.Protocol:
    """Produces a typing.Protocol based on a dictionary of `(method_name, Callable_type)` specification"""

[thorwhalen]

See some working code to (1) create protocols dynamically from callable annotations and (2) create a scaffold (generated code string) from callable annotations in the annotations_to_meshes module

[thorwhalen]

Groups.__annotations__ is a {name: func_annotation, ...} dict.

import i2

from meshed.scrap.annotations_to_meshes import (
    func_types_to_scaffold, 
    func_types_to_protocol
)

GroupsProtocol = func_types_to_protocol(Groups.__annotations__)
groups_scaffold_str = func_types_to_scaffold(Groups.__annotations__)

See that GroupsProtocol has methods for each item of the Groups.__annotations__ dict.
Each method bares a signature compatible with the annotations.

i2.Sig(GroupsProtocol.add_item_to_group)
# <Sig (self, item: __main__.Item, group: __main__.Group) -> Any>

print(groups_scaffold_str)

class GeneratedClass:
    def add_item_to_group(self, item: Item, group: Group) -> Any:
	    pass

    def add_items_to_group(self, iterable: Iterable, group: Group) -> Any:
	    pass

    def list_groups(self) -> Iterable:
	    pass

    def items_for_group(self, group: Group) -> Iterable:
	    pass