Skip to content

FromKwargs

Bases: FromIter[tuple[K, V]], ABC


              flowchart TD
              pyochain.abc.constructors.FromKwargs[FromKwargs]
              pyochain.abc.constructors.FromIter[FromIter]

                              pyochain.abc.constructors.FromIter --> pyochain.abc.constructors.FromKwargs
                


              click pyochain.abc.constructors.FromKwargs href "" "pyochain.abc.constructors.FromKwargs"
              click pyochain.abc.constructors.FromIter href "" "pyochain.abc.constructors.FromIter"
Source code in pyochain/abc/constructors.pyi 
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
@type_check_only
class FromKwargs[K, V](FromIter[tuple[K, V]], ABC):
    @staticmethod
    @abstractmethod
    def of[E](**elements: E) -> FromKwargs[str, E]:
        """Create the instance from a variable number of keyword arguments.

        Args:
            **elements (E): The elements to create the instance from.

        Returns:
            FromKwargs[str, E]: A new instance containing the provided `elements`.

        Example:
            ```python
            from pyochain import Dict

            d = Dict.of(a=1, b=2)
            assert d == Dict(a=1, b=2)
            assert repr(d) == "Dict('a': 1, 'b': 2)"
            assert Dict.of(a=1, b=2, c=3) == Dict({"a": 1, "b": 2, "c": 3})
            ```
        """

of(**elements) abstractmethod staticmethod

Create the instance from a variable number of keyword arguments.

Parameters:

Name Type Description Default
**elements E

The elements to create the instance from.

 {}

Returns:

Type Description
FromKwargs[str, E]

FromKwargs[str, E]: A new instance containing the provided elements.
Example 
from pyochain import Dict

d = Dict.of(a=1, b=2)
assert d == Dict(a=1, b=2)
assert repr(d) == "Dict('a': 1, 'b': 2)"
assert Dict.of(a=1, b=2, c=3) == Dict({"a": 1, "b": 2, "c": 3})
Source code in pyochain/abc/constructors.pyi 
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
@staticmethod
@abstractmethod
def of[E](**elements: E) -> FromKwargs[str, E]:
    """Create the instance from a variable number of keyword arguments.

    Args:
        **elements (E): The elements to create the instance from.

    Returns:
        FromKwargs[str, E]: A new instance containing the provided `elements`.

    Example:
        ```python
        from pyochain import Dict

        d = Dict.of(a=1, b=2)
        assert d == Dict(a=1, b=2)
        assert repr(d) == "Dict('a': 1, 'b': 2)"
        assert Dict.of(a=1, b=2, c=3) == Dict({"a": 1, "b": 2, "c": 3})
        ```
    """