Skip to content

result

This module contains the Result variants returned by all Client calls.

Correct usage

client = wom.Client()

result = await client.players.update_player("Jonxslays")

if result.is_ok:
    print(result.unwrap())
else:
    print(result.unwrap_err())

Incorrect usage

client = wom.Client()

result = await client.players.update_player("eeeeeeeeeeeee")

print(result.unwrap()) # <-- Exception raised
# Raises UnwrapError because the username was too long

Err

Bases: Result[T, E]

The Err variant of a Result.

Info

You will receive instances of this class as a result of calling Client methods, and should not have to instantiate it yourself.

Source code in wom/result.py 
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
@t.final
class Err(Result[T, E]):
    """The [`Err`][wom.Err] variant of a [`Result`][wom.Result].

    !!! info

        You will receive instances of this class as a result of
        calling [`Client`][wom.Client] methods, and should not have to
        instantiate it yourself.
    """

    __slots__ = ()

    def __init__(self, error: E) -> None:
        self._error = error

    @property
    def is_ok(self) -> bool:
        """Always returns `False` for the [`Err`][wom.Err] variant."""
        return False

    @property
    def is_err(self) -> bool:
        """Always returns `True` for the [`Err`][wom.Err] variant."""
        return True

    def unwrap(self) -> T:
        """Always throws an exception for the [`Err`][wom.Err] variant.

        Raises:
            UnwrapError: Because the result was an [`Err`][wom.Err]
                variant.
        """
        raise errors.UnwrapError(f"Called unwrap on an error value - {self._error}")

    def unwrap_err(self) -> E:
        """Unwraps the result to produce the error.

        Returns:
            The unwrapped error.
        """
        return self._error

is_err property 

is_err: bool

Always returns True for the Err variant.

is_ok property 

is_ok: bool

Always returns False for the Err variant.

unwrap 

unwrap() -> T

Always throws an exception for the Err variant.

Raises:

Type Description
UnwrapError

Because the result was an Err variant.
Source code in wom/result.py 
183
184
185
186
187
188
189
190
def unwrap(self) -> T:
    """Always throws an exception for the [`Err`][wom.Err] variant.

    Raises:
        UnwrapError: Because the result was an [`Err`][wom.Err]
            variant.
    """
    raise errors.UnwrapError(f"Called unwrap on an error value - {self._error}")

unwrap_err 

unwrap_err() -> E

Unwraps the result to produce the error.

Returns:

Type Description
E

The unwrapped error.
Source code in wom/result.py 
192
193
194
195
196
197
198
def unwrap_err(self) -> E:
    """Unwraps the result to produce the error.

    Returns:
        The unwrapped error.
    """
    return self._error

Ok

Bases: Result[T, E]

The Ok variant of a Result.

Info

You will receive instances of this class as a result of calling Client methods, and should not have to instantiate it yourself.

Source code in wom/result.py 
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
@t.final
class Ok(Result[T, E]):
    """The [`Ok`][wom.Ok] variant of a [`Result`][wom.Result].

    !!! info

        You will receive instances of this class as a result of
        calling [`Client`][wom.Client] methods, and should not have to
        instantiate it yourself.
    """

    __slots__ = ()

    def __init__(self, value: T) -> None:
        self._value = value

    @property
    def is_ok(self) -> bool:
        """Always returns `True` for the [`Ok`][wom.Ok] variant."""
        return True

    @property
    def is_err(self) -> bool:
        """Always returns `False` for the [`Ok`][wom.Ok] variant."""
        return False

    def unwrap(self) -> T:
        """Unwraps the result to produce the value.

        Returns:
            The unwrapped value.
        """
        return self._value

    def unwrap_err(self) -> E:
        """Always throws an exception for the [`Ok`][wom.Ok] variant.

        Raises:
            UnwrapError: Because the result was an [`Ok`][wom.Ok]
                variant.
        """
        actual = self._value.__class__.__name__
        raise errors.UnwrapError(f"Called unwrap error on a non error value of type {actual!r}")

is_err property 

is_err: bool

Always returns False for the Ok variant.

is_ok property 

is_ok: bool

Always returns True for the Ok variant.

unwrap 

unwrap() -> T

Unwraps the result to produce the value.

Returns:

Type Description
T

The unwrapped value.
Source code in wom/result.py 
138
139
140
141
142
143
144
def unwrap(self) -> T:
    """Unwraps the result to produce the value.

    Returns:
        The unwrapped value.
    """
    return self._value

unwrap_err 

unwrap_err() -> E

Always throws an exception for the Ok variant.

Raises:

Type Description
UnwrapError

Because the result was an Ok variant.
Source code in wom/result.py 
146
147
148
149
150
151
152
153
154
def unwrap_err(self) -> E:
    """Always throws an exception for the [`Ok`][wom.Ok] variant.

    Raises:
        UnwrapError: Because the result was an [`Ok`][wom.Ok]
            variant.
    """
    actual = self._value.__class__.__name__
    raise errors.UnwrapError(f"Called unwrap error on a non error value of type {actual!r}")

Result

Bases: t.Generic[T, E], abc.ABC

Represents a potential Ok or Err result.

Note

This class cannot be instantiated, only its variants can be.

Source code in wom/result.py 
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
class Result(t.Generic[T, E], abc.ABC):
    """Represents a potential [`Ok`][wom.Ok] or [`Err`][wom.Err] result.

    !!! note

        This class cannot be instantiated, only its variants can be.
    """

    __slots__ = ("_error", "_value")

    def __repr__(self) -> str:
        inner = self._value if self.is_ok else self._error  # type: ignore [attr-defined]
        return f"{self.__class__.__name__}({inner})"

    @property
    @abc.abstractmethod
    def is_ok(self) -> bool:
        """`True` if this result is the [`Ok`][wom.Ok] variant."""

    @property
    @abc.abstractmethod
    def is_err(self) -> bool:
        """`True` if this result is the [`Err`][wom.Err] variant."""

    @abc.abstractmethod
    def unwrap(self) -> T:
        """Unwraps the result to produce the value.

        Returns:
            The unwrapped value.

        Raises:
            UnwrapError: If the result was an [`Err`][wom.Err] and not
                [`Ok`][wom.Ok].
        """

    @abc.abstractmethod
    def unwrap_err(self) -> E:
        """Unwraps the result to produce the error.

        Returns:
            The unwrapped error.

        Raises:
            UnwrapError: If the result was [`Ok`][wom.Ok] and not an
                [`Err`][wom.Err].
        """

is_err abstractmethod property 

is_err: bool

True if this result is the Err variant.

is_ok abstractmethod property 

is_ok: bool

True if this result is the Ok variant.

unwrap abstractmethod 

unwrap() -> T

Unwraps the result to produce the value.

Returns:

Type Description
T

The unwrapped value.

Raises:

Type Description
UnwrapError

If the result was an Err and not Ok.
Source code in wom/result.py 
87
88
89
90
91
92
93
94
95
96
97
@abc.abstractmethod
def unwrap(self) -> T:
    """Unwraps the result to produce the value.

    Returns:
        The unwrapped value.

    Raises:
        UnwrapError: If the result was an [`Err`][wom.Err] and not
            [`Ok`][wom.Ok].
    """

unwrap_err abstractmethod 

unwrap_err() -> E

Unwraps the result to produce the error.

Returns:

Type Description
E

The unwrapped error.

Raises:

Type Description
UnwrapError

If the result was Ok and not an Err.
Source code in wom/result.py 
 99
100
101
102
103
104
105
106
107
108
109
@abc.abstractmethod
def unwrap_err(self) -> E:
    """Unwraps the result to produce the error.

    Returns:
        The unwrapped error.

    Raises:
        UnwrapError: If the result was [`Ok`][wom.Ok] and not an
            [`Err`][wom.Err].
    """