def _create_event(team: Team, game: Game) -> Result[Event, ErrCode]:
if not game.opening_whistle:
return Result.from_failure(ErrCode.MISSING_OPENING_WHISTLE)
venue = 'Heimspiel' if game.home_team == team else 'Auswärtsspiel'
summary = f'{venue} - {game.opponent_of(team).short_name}'
leg_title = game.leg_title()
description = f'{leg_title} gegen {game.opponent_of(team).name}'
if game.sports_hall:
description += '\nSporthalle: ' + str(game.sports_hall.name)
dated_games = game.other_games().filter(opening_whistle__isnull=False)
for other in sorted(dated_games, key=lambda g: g.opening_whistle):
if other.home_goals is not None:
description += f'\n{other.leg_title()}: {other.home_goals}:{other.guest_goals} ({_outcome(other, team)})'
start = game.opening_whistle
end = start + timedelta(minutes=90)
dtstamp = datetime.now()
location = game.sports_hall.address if game.sports_hall else None
uid = f'game/{game.number}@hbscorez.de'
event = Event()
event.add('summary', summary)
event.add('description', description)
event.add('dtstart', start)
event.add('dtend', end)
event.add('dtstamp', dtstamp)
if location:
event['location'] = vText(location)
event['uid'] = uid
return Result.from_value(event)
def assert_failure(actual: Result[..., ...], expected: Any) -> None:
if isinstance(expected, Exception):
if isinstance(actual, Result.success_type):
raise AssertionError(f"Expected a failure but got {actual}.")
failure = actual.failure()
if isinstance(failure, Exception):
assert failure.__class__ == expected.__class__ and failure.args == expected.args, \
f"Expected f{expected} but got {actual}."
else:
raise AssertionError(f"Expected f{expected} but got {actual}.")
else:
assert actual == Result.from_failure(expected)
from returns.context import (
Reader,
ReaderFutureResult,
ReaderIOResult,
ReaderResult,
)
from returns.contrib.pytest import ReturnsAsserts
from returns.future import Future, FutureResult
from returns.io import IO, IOResult
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),
def test_return_false_with_result_container():
"""Ensures `is_io` function will return False for Result."""
assert is_io(Result.from_failure('failure')) is False
from abc import ABC
from collections import OrderedDict
from typing import Final, final
from bge.types import KX_GameObject, KX_PythonComponent
from returns.result import Result, ResultE
from alleycat.common import AlreadyDisposedError, LoggingSupport, NotStartedError
from alleycat.core import ArgumentsHolder
RESULT_NOT_STARTED: Final = Result.from_failure(
NotStartedError("The proxy has not been started yet."))
RESULT_DISPOSED: Final = Result.from_failure(
AlreadyDisposedError("The proxy instance has been disposed already."))
class BaseProxy(ArgumentsHolder, LoggingSupport, ABC):
_start_args: ResultE[OrderedDict] = RESULT_NOT_STARTED
@final
@property
def start_args(self) -> ResultE[OrderedDict]:
return self._start_args
@property
def valid(self) -> bool:
return isinstance(self.start_args, Result.success_type)
def start(self, args: OrderedDict) -> None:
self._start_args = Result.from_value(args)