Skip to content

result

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

Correct usage

client = wom.Client()

await client.start()

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

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

Incorrect usage

client = wom.Client()

await client.start()

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 
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
@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

    def to_dict(self) -> t.Dict[str, t.Any]:
        """Converts the result into a dictionary.

        Returns:
            The requested dictionary.
        """
        error: t.Any

        if isinstance(self._error, BaseModel):
            error = self._error.to_dict()
        elif isinstance(self._error, (dict, int, str, bool)):
            error = self._error
        elif isinstance(self._error, Exception):
            error = str(self._error)
        elif isinstance(self._error, list):
            if self._error:
                if isinstance(self._error[0], BaseModel):
                    error = [e.to_dict() for e in self._error]  # pyright: ignore
                elif isinstance(self._error[0], (dict, int, str, bool)):
                    error = self._error
                else:
                    raise RuntimeError(
                        f"Cant convert Result(Err) to dict, please report this: {self._error}"
                    )
            else:
                error = []
        else:
            raise RuntimeError(
                f"Cant convert Result(Err) to dict, please report this: {self._error}"
            )

        return {"value": None, "error": 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.

to_dict 

to_dict() -> t.Dict[str, t.Any]

Converts the result into a dictionary.

Returns:

Type Description
Dict[str, Any]

The requested dictionary.
Source code in wom/result.py 
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
def to_dict(self) -> t.Dict[str, t.Any]:
    """Converts the result into a dictionary.

    Returns:
        The requested dictionary.
    """
    error: t.Any

    if isinstance(self._error, BaseModel):
        error = self._error.to_dict()
    elif isinstance(self._error, (dict, int, str, bool)):
        error = self._error
    elif isinstance(self._error, Exception):
        error = str(self._error)
    elif isinstance(self._error, list):
        if self._error:
            if isinstance(self._error[0], BaseModel):
                error = [e.to_dict() for e in self._error]  # pyright: ignore
            elif isinstance(self._error[0], (dict, int, str, bool)):
                error = self._error
            else:
                raise RuntimeError(
                    f"Cant convert Result(Err) to dict, please report this: {self._error}"
                )
        else:
            error = []
    else:
        raise RuntimeError(
            f"Cant convert Result(Err) to dict, please report this: {self._error}"
        )

    return {"value": None, "error": error}

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 
230
231
232
233
234
235
236
237
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 
239
240
241
242
243
244
245
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 
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
155
156
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
199
200
201
@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}")

    def to_dict(self) -> t.Dict[str, t.Any]:
        """Converts the result into a dictionary.

        Returns:
            The requested dictionary.
        """
        value: t.Any
        actual = self._value.__class__.__name__

        if isinstance(self._value, BaseModel):
            value = self._value.to_dict()
        elif isinstance(self._value, list):
            if self._value:
                if isinstance(self._value[0], BaseModel):
                    value = [v.to_dict() for v in self._value]  # pyright: ignore
                elif isinstance(self._value[0], (dict, int, str, bool)):
                    value = self._value
                else:
                    raise RuntimeError(
                        f"Cant convert Result(Ok) to dict, please report this: {actual!r}"
                    )
            else:
                value = []
        elif isinstance(self._value, (dict, int, str, bool)):
            value = self._value
        else:
            raise RuntimeError(f"Cant convert Result(Ok) to dict, please report this: {actual!r}")

        return {"value": value, "error": None}

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.

to_dict 

to_dict() -> t.Dict[str, t.Any]

Converts the result into a dictionary.

Returns:

Type Description
Dict[str, Any]

The requested dictionary.
Source code in wom/result.py 
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
199
200
201
def to_dict(self) -> t.Dict[str, t.Any]:
    """Converts the result into a dictionary.

    Returns:
        The requested dictionary.
    """
    value: t.Any
    actual = self._value.__class__.__name__

    if isinstance(self._value, BaseModel):
        value = self._value.to_dict()
    elif isinstance(self._value, list):
        if self._value:
            if isinstance(self._value[0], BaseModel):
                value = [v.to_dict() for v in self._value]  # pyright: ignore
            elif isinstance(self._value[0], (dict, int, str, bool)):
                value = self._value
            else:
                raise RuntimeError(
                    f"Cant convert Result(Ok) to dict, please report this: {actual!r}"
                )
        else:
            value = []
    elif isinstance(self._value, (dict, int, str, bool)):
        value = self._value
    else:
        raise RuntimeError(f"Cant convert Result(Ok) to dict, please report this: {actual!r}")

    return {"value": value, "error": None}

unwrap 

unwrap() -> T

Unwraps the result to produce the value.

Returns:

Type Description
T

The unwrapped value.
Source code in wom/result.py 
155
156
157
158
159
160
161
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 
163
164
165
166
167
168
169
170
171
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: Generic[T, E], 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 
 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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
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].
        """

    @abc.abstractmethod
    def to_dict(self) -> t.Dict[str, t.Any]:
        """Converts the result into a dictionary.

        If this result is [`Ok`][wom.Ok], the "value" property will be set.

        If this result is [`Err`][wom.Err], the "error" property will be set.

        Returns:
            The requested dictionary.
        """

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.

to_dict abstractmethod 

to_dict() -> t.Dict[str, t.Any]

Converts the result into a dictionary.

If this result is Ok, the "value" property will be set.

If this result is Err, the "error" property will be set.

Returns:

Type Description
Dict[str, Any]

The requested dictionary.
Source code in wom/result.py 
116
117
118
119
120
121
122
123
124
125
126
@abc.abstractmethod
def to_dict(self) -> t.Dict[str, t.Any]:
    """Converts the result into a dictionary.

    If this result is [`Ok`][wom.Ok], the "value" property will be set.

    If this result is [`Err`][wom.Err], the "error" property will be set.

    Returns:
        The requested dictionary.
    """

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 
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
@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 
104
105
106
107
108
109
110
111
112
113
114
@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].
    """