async def test_inner_value(subtests):
"""Ensure that coroutine correct value is preserved for all units."""
containers = [
# We have to define these values inside the test, because
# otherwise `anyio` will `await` reused coroutines.
# And they have to be fresh. That's why we use subtests for it.
Future.from_futureresult(FutureResult.from_success(1)),
Future.from_futureresult(FutureResult.from_failure(1)),
]
for container in containers:
with subtests.test(container=container):
assert isinstance(await container, IO)
async def test_non_flatten_future(subtests):
"""Ensures that `flatten` is always returning the correct type."""
futures = [
# Not flattens:
FutureResult.from_failure(FutureResult.from_failure(1)),
]
for cont in futures:
with subtests.test(container=cont):
assert isinstance(
(await flatten(cont)).failure()._inner_value, # noqa: WPS437
FutureResult,
)
async def test_flatten_future(subtests):
"""Ensures that `flatten` is always returning the correct type."""
futures = [
# Flattens:
(Future.from_value(Future.from_value(1)), Future.from_value(1)),
(
FutureResult.from_value(FutureResult.from_value(1)),
FutureResult.from_value(1),
),
]
for container, merged in futures:
with subtests.test(container=container, merged=merged):
assert await flatten(container) == await merged # type: ignore
def __call__(
self,
inner_value: str,
use_result: Result[str, str],
) -> FutureResult[None, str]:
self._logs.append((inner_value, use_result))
return FutureResult.from_value(None)
def from_ioresult_context(
cls,
inner_value:
'ReaderIOResult[_NewValueType, _NewErrorType, _NewEnvType]',
) -> 'ReaderFutureResult[_NewValueType, _NewErrorType, _NewEnvType]':
"""
Creates new container from ``RequiresContextIOResult`` as a unit value.
.. code:: python
>>> import anyio
>>> from returns.context import RequiresContextIOResult
>>> from returns.io import IOSuccess, IOFailure
>>> assert anyio.run(
... RequiresContextFutureResult.from_ioresult_context(
... RequiresContextIOResult.from_value(1),
... ),
... RequiresContextFutureResult.empty,
... ) == IOSuccess(1)
>>> assert anyio.run(
... RequiresContextFutureResult.from_ioresult_context(
... RequiresContextIOResult.from_failure(1),
... ),
... RequiresContextFutureResult.empty,
... ) == IOFailure(1)
"""
return RequiresContextFutureResult(
lambda deps: FutureResult.from_ioresult(inner_value(deps)), )
def from_failed_future(
cls,
inner_value: Future[_NewErrorType],
) -> RequiresContextFutureResult[Any, _NewErrorType, NoDeps]:
"""
Creates new container with failed ``Future`` as a unit value.
.. code:: python
>>> import anyio
>>> from returns.context import RequiresContextFutureResult
>>> from returns.future import Future
>>> from returns.io import IOFailure
>>> assert anyio.run(
... RequiresContextFutureResult.from_failed_future(
... Future.from_value(1),
... ),
... RequiresContextFutureResult.no_args,
... ) == IOFailure(1)
"""
return RequiresContextFutureResult(
lambda _: FutureResult.from_failed_future(inner_value),
)
def from_ioresult(
cls,
inner_value: IOResult[_NewValueType, _NewErrorType],
) -> 'RequiresContextFutureResult[_NewValueType, _NewErrorType, NoDeps]':
"""
Creates new container with ``IOResult`` as a unit value.
.. code:: python
>>> import anyio
>>> from returns.context import RequiresContextFutureResult
>>> from returns.io import IOSuccess, IOFailure
>>> assert anyio.run(
... RequiresContextFutureResult.from_ioresult(IOSuccess(1)),
... RequiresContextFutureResult.empty,
... ) == IOSuccess(1)
>>> assert anyio.run(
... RequiresContextFutureResult.from_ioresult(IOFailure(1)),
... RequiresContextFutureResult.empty,
... ) == IOFailure(1)
"""
return RequiresContextFutureResult(
lambda _: FutureResult.from_ioresult(inner_value), )
def compose_result(
self,
function: Callable[
[Result[_ValueType, _ErrorType]],
Kind3[
RequiresContextFutureResult,
_NewValueType,
_ErrorType,
_EnvType,
],
],
) -> RequiresContextFutureResult[_NewValueType, _ErrorType, _EnvType]:
"""
Composes inner ``Result`` with ``ReaderFutureResult`` returning func.
Can be useful when you need an access to both states of the result.
.. code:: python
>>> import anyio
>>> from returns.context import ReaderFutureResult, NoDeps
>>> from returns.io import IOSuccess, IOFailure
>>> from returns.result import Result
>>> def count(
... container: Result[int, int],
... ) -> ReaderFutureResult[int, int, NoDeps]:
... return ReaderFutureResult.from_result(
... container.map(lambda x: x + 1).alt(abs),
... )
>>> success = ReaderFutureResult.from_value(1)
>>> failure = ReaderFutureResult.from_failure(-1)
>>> assert anyio.run(
... success.compose_result(count), ReaderFutureResult.no_args,
... ) == IOSuccess(2)
>>> assert anyio.run(
... failure.compose_result(count), ReaderFutureResult.no_args,
... ) == IOFailure(1)
"""
return RequiresContextFutureResult(
lambda deps: FutureResult(
_reader_future_result.async_compose_result(
function, self, deps,
),
),
)
def bind_async(
self,
function: Callable[
[_ValueType],
Awaitable[
Kind3[
RequiresContextFutureResult,
_NewValueType,
_ErrorType,
_EnvType,
],
],
],
) -> RequiresContextFutureResult[_NewValueType, _ErrorType, _EnvType]:
"""
Composes this container with a async function returning the same type.
.. code:: python
>>> import anyio
>>> from returns.context import RequiresContextFutureResult
>>> from returns.io import IOSuccess, IOFailure
>>> async def function(
... number: int,
... ) -> RequiresContextFutureResult[str, int, int]:
... return RequiresContextFutureResult.from_value(number + 1)
>>> assert anyio.run(
... RequiresContextFutureResult.from_value(1).bind_async(
... function,
... ),
... RequiresContextFutureResult.no_args,
... ) == IOSuccess(2)
>>> assert anyio.run(
... RequiresContextFutureResult.from_failure(1).bind_async(
... function,
... ),
... RequiresContextFutureResult.no_args,
... ) == IOFailure(1)
"""
return RequiresContextFutureResult(
lambda deps: FutureResult(_reader_future_result.async_bind_async(
function, self, deps,
)),
)
def from_value(
cls,
inner_value: _FirstType,
) -> RequiresContextFutureResult[_FirstType, Any, NoDeps]:
"""
Creates new container with successful ``FutureResult`` as a unit value.
.. code:: python
>>> import anyio
>>> from returns.context import RequiresContextFutureResult
>>> from returns.io import IOSuccess
>>> assert anyio.run(RequiresContextFutureResult.from_value(1)(
... RequiresContextFutureResult.empty,
... ).awaitable) == IOSuccess(1)
"""
return RequiresContextFutureResult(
lambda _: FutureResult.from_value(inner_value), )
def from_failure(
cls,
inner_value: _FirstType,
) -> 'RequiresContextFutureResult[Any, _FirstType, NoDeps]':
"""
Creates new container with failed ``FutureResult`` as a unit value.
.. code:: python
>>> import anyio
>>> from returns.context import RequiresContextFutureResult
>>> from returns.io import IOFailure
>>> assert anyio.run(RequiresContextFutureResult.from_failure(1)(
... RequiresContextFutureResult.empty,
... ).awaitable) == IOFailure(1)
"""
return RequiresContextFutureResult(
lambda _: FutureResult.from_failure(inner_value), )
def from_io(
cls,
inner_value: IO[_NewValueType],
) -> 'RequiresContextFutureResult[_NewValueType, Any, NoDeps]':
"""
Creates new container from successful ``IO`` value.
.. code:: python
>>> import anyio
>>> from returns.io import IO, IOSuccess
>>> from returns.context import RequiresContextFutureResult
>>> assert anyio.run(
... RequiresContextFutureResult.from_io(IO(1)),
... RequiresContextFutureResult.empty,
... ) == IOSuccess(1)
"""
return RequiresContextFutureResult(
lambda deps: FutureResult.from_io(inner_value), )
def from_failed_io(
cls,
inner_value: IO[_NewErrorType],
) -> 'RequiresContextFutureResult[Any, _NewErrorType, NoDeps]':
"""
Creates a new container from failed ``IO`` value.
.. code:: python
>>> import anyio
>>> from returns.io import IO, IOFailure
>>> from returns.context import RequiresContextFutureResult
>>> assert anyio.run(
... RequiresContextFutureResult.from_failed_io(IO(1)),
... RequiresContextFutureResult.empty,
... ) == IOFailure(1)
"""
return RequiresContextFutureResult(
lambda deps: FutureResult.from_failed_io(inner_value), )
def from_future(
cls,
inner_value: Future[_NewValueType],
) -> 'RequiresContextFutureResult[_NewValueType, Any, NoDeps]':
"""
Creates new container with successful ``Future`` as a unit value.
.. code:: python
>>> import anyio
>>> from returns.context import RequiresContextFutureResult
>>> from returns.future import Future
>>> from returns.io import IOSuccess
>>> assert anyio.run(
... RequiresContextFutureResult.from_future(Future.from_value(1)),
... RequiresContextFutureResult.empty,
... ) == IOSuccess(1)
"""
return RequiresContextFutureResult(
lambda _: FutureResult.from_future(inner_value), )
def from_failed_context(
cls,
inner_value: 'RequiresContext[_NewValueType, _NewEnvType]',
) -> 'RequiresContextFutureResult[Any, _NewValueType, _NewEnvType]':
"""
Creates new container from ``RequiresContext`` as a failure unit.
.. code:: python
>>> import anyio
>>> from returns.context import RequiresContext
>>> from returns.io import IOFailure
>>> assert anyio.run(
... RequiresContextFutureResult.from_failed_context(
... RequiresContext.from_value(1),
... ),
... RequiresContextFutureResult.empty,
... ) == IOFailure(1)
"""
return RequiresContextFutureResult(
lambda deps: FutureResult.from_failure(inner_value(deps)), )
def from_context(
cls,
inner_value: 'RequiresContext[_FirstType, _EnvType]',
) -> 'RequiresContextFutureResult[_FirstType, Any, _EnvType]':
"""
Creates new container from ``RequiresContext`` as a success unit.
.. code:: python
>>> import anyio
>>> from returns.context import RequiresContext
>>> from returns.io import IOSuccess
>>> assert anyio.run(
... RequiresContextFutureResult.from_context(
... RequiresContext.from_value(1),
... ),
... RequiresContextFutureResult.empty,
... ) == IOSuccess(1)
"""
return RequiresContextFutureResult(
lambda deps: FutureResult.from_value(inner_value(deps)), )
def _acquire_success() -> FutureResult[str, str]:
return FutureResult.from_value('acquire success')
def _future_result_function(argument: int) -> FutureResult[str, float]:
return FutureResult.from_value(str(argument + 1))
def test_nonequality():
"""Ensures that containers can be compared."""
assert FutureResult.from_success(1) != FutureResult.from_success(1)
assert hash(FutureResult.from_success(1))
from returns.maybe import Maybe
from returns.primitives.asserts import assert_equal
from returns.primitives.container import BaseContainer
from returns.result import Result
_containers: Sequence[BaseContainer] = (
Result.from_failure(1),
Result.from_value(1),
IO(1),
IOResult.from_failure(1),
IOResult.from_value(1),
Maybe.from_value(1),
Maybe.from_value(None),
Maybe.from_optional(None),
Future.from_value(1),
FutureResult.from_value(1),
FutureResult.from_failure(1),
Reader.from_value(1),
ReaderResult.from_value(1),
ReaderResult.from_failure(1),
ReaderIOResult.from_value(1),
ReaderIOResult.from_failure(1),
ReaderFutureResult.from_value(1),
ReaderFutureResult.from_failure(1),
)
@pytest.mark.parametrize('container', _containers)
def test_assert_equal(container, anyio_backend_name: str):
"""Ensure that containers can be equal."""
assert_equal(container, container, backend=anyio_backend_name)
def test_return_false_with_future_result_container(): # noqa: WPS118
"""Ensures `is_io` function will return False for FutureResult."""
assert is_io(FutureResult.from_failure('failure')) is False
def __call__(
self,
inner_value: str,
use_result: Result[str, str],
) -> FutureResult[None, str]:
return FutureResult.from_failure('release failure')
async def test_inner_value(subtests):
"""Ensure that coroutine correct value is preserved for all units."""
containers = [
# We have to define these values inside the test, because
# otherwise `anyio` will `await` reused coroutines.
# And they have to be fresh. That's why we use subtests for it.
FutureResult.from_value(1),
FutureResult.from_failure(1),
FutureResult.from_io(IO(1)),
FutureResult.from_failed_io(IO(1)),
FutureResult.from_ioresult(IOSuccess(1)),
FutureResult.from_ioresult(IOFailure(1)),
FutureResult.from_result(Success(1)),
FutureResult.from_result(Failure(1)),
FutureResult.from_future(Future.from_value(1)),
FutureResult.from_failed_future(Future.from_value(1)),
FutureResult.from_typecast(Future.from_value(Success(1))),
]
for container in containers:
with subtests.test(container=container):
result_inst = await container
assert result_inst._inner_value._inner_value == 1 # noqa: WPS437
def _use_failure(inner_value: str) -> FutureResult[str, str]:
return FutureResult.from_failure('use failure')
def _use_success(inner_value: str) -> FutureResult[str, str]:
return FutureResult.from_value('use success')
async def test_bind_future_result():
"""Ensures that functions can be composed and return type is correct."""
assert await bind(_future_result_function)(
FutureResult.from_value(1), ) == IOSuccess('2')
assert await bind(_future_result_function)(
FutureResult.from_failure(1.0), ) == IOFailure(1.0)
async def _future_pipeline(self, inner_value):
used = self._use(inner_value)
inner_result = await used._inner_value # noqa: WPS437
await self._release(inner_value, inner_result)
return FutureResult.from_result(inner_result)
def factory(deps):
return _managed(
lambda inner: self._use(inner)(deps),
lambda inner, pure: self._release(inner, pure)(deps),
)(FutureResult.from_value(inner_value))
def _acquire_failure() -> FutureResult[str, str]:
return FutureResult.from_failure('acquire failure')
from returns.future import FutureResult
from returns.primitives.interfaces import (
Altable,
Bindable,
Fixable,
Mappable,
Rescueable,
Unifiable,
Unitable,
Unwrapable,
)
@pytest.mark.parametrize('container', [
FutureResult.from_success(1),
FutureResult.from_failure(1),
])
@pytest.mark.parametrize('protocol', [
Bindable,
Mappable,
Rescueable,
Altable,
Fixable,
Unwrapable,
Unifiable,
Unitable,
])
def test_protocols(container, protocol):
"""Ensures that Future has all the right protocols."""
assert isinstance(container, protocol)
