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)