def __getitem__(self, index): try: if isinstance(index, slice): molecules = [] info = list(self._molecules_ordered_all_gen()) for info in islice_extended(self._molecules_ordered_all_gen(), index.start, index.stop, index.step): itp_index, gro_start, gro_end = info residues = self.system_gro[gro_start:gro_end] mol = self.different_molecules[itp_index].copy(residues) molecules.append(mol) return molecules elif isinstance(index, int): if index == -1: info = last(self._molecules_ordered_all_gen()) else: info = next( islice_extended(self._molecules_ordered_all_gen(), index, index + 1)) itp_index, gro_start, gro_end = info residues = self.system_gro[gro_start:gro_end] mol = self.different_molecules[itp_index].copy(residues) return mol else: raise TypeError(('System indices must be integers or slices,' f' not {type(index)}.')) except StopIteration: raise IndexError('Molecule index out of range')
def __getitem__(self, index): try: if isinstance(index, slice): molecules = [] for _, start, len_mol in islice_extended( self._molecules_ordered_all_gen(), index.start, index.stop, index.step): self._open_fgro.seek_atom(start) molecules.append( Residue([ AtomGro(next(self._open_fgro)) for _ in range(len_mol) ])) return molecules if isinstance(index, int): if index == -1: info = last(self._molecules_ordered_all_gen()) else: info = next( islice_extended(self._molecules_ordered_all_gen(), index, index + 1)) _, start, len_mol = info self._open_fgro.seek_atom(start) return Residue( [AtomGro(next(self._open_fgro)) for _ in range(len_mol)]) else: raise TypeError( ('SystemGro indices must be integers or slices,' f' not {type(index)}.')) except StopIteration: raise IndexError('Residue index out of range')
def write_to_folder(self, folder: pathlib.Path, *, chunk: int = 10, max_length: Optional[int] = None) -> Iterator[State]: from .animating import animate ### Preparing folder: ################################################# # # if not folder.exists(): folder.mkdir(parents=True) assert folder.is_dir() assert not any(folder.iterdir()) # # ### Finished preparing folder. ######################################## paths = ((folder / f'{i:06d}.json') for i in range(10**6)) state_iterator, state_iterator_copy = itertools.tee( self.culture.iterate_game(self, max_length=max_length)) transition_iterator = animate(state_iterator_copy) for path in paths: chunked_iterator = more_itertools.islice_extended( zip(state_iterator, transition_iterator, strict=True))[:chunk] transition_chunk = [] for state, transition in chunked_iterator: transition_chunk.append(transition) yield state if not transition_chunk: # Game ended, either naturally or reached `max_length`. return assert len(transition_chunk) <= chunk with path.open('w') as file: json.dump(transition_chunk, file)
def make_initial(culture: Culture, *, board_size: int, starting_score: int = 0, concurrent_food_tiles: int = 40) -> State: n_players = len(culture.strategies) random_positions_firehose = utils.iterate_deduplicated( State.iterate_random_positions(board_size=board_size)) random_positions = tuple( more_itertools.islice_extended( random_positions_firehose)[:(n_players + concurrent_food_tiles)] ) player_positions = random_positions[:n_players] food_positions = frozenset(random_positions[n_players:]) assert len(food_positions) == concurrent_food_tiles player_id_to_observation = {} for letter, player_position in zip(LETTERS, player_positions): player_id_to_observation[letter] = Observation(state=None, position=player_position, score=starting_score, letter=letter, last_action=None) state = State( culture=culture, board_size=board_size, player_id_to_observation=ImmutableDict(player_id_to_observation), food_positions=food_positions, ) for observation in player_id_to_observation.values(): observation.state = state return state
def __getitem__(self, key: Union[int, slice]) -> Union[Any, "ObjectQuery"]: """ If key is an integer it evaluates query and returns item. If key is a slice it returns another unevaluated ObjectQuery. Parameters ---------- key: Union[int, slice] Key represents index of item or slice object. Returns ------- Union [Any, ObjectQuery] Returns item or list of items. Examples -------- >>> ObjectQuery(range(10))[5] 5 >>> list(ObjectQuery(range(10))[5:0:-1]) [5, 4, 3, 2, 1] """ if isinstance(key, slice): return self.__class__( islice_extended(self.objects_source, key.start, key.stop, key.step)) return self._evaluate_query()[key]
def get_page_iterator(self, block_start, page): # we always skip the last blocks of the page which corresponds to the footer blocks = page.blocks[block_start:len(page.blocks) - self.nb_blocks_footer_] iterator = iter(self.get_next_word_from_blocks(blocks)) if self.nb_words_footer_ != 0: return mit.islice_extended(iterator, None, -self.nb_words_footer_) return iterator
def total_payoff(self, *, start: int = 0, discount: numbers.Real = 1): assert start >= 0 assert 0 <= discount <= 1 wip_payoff = collections.defaultdict(lambda: 0) payoffs = more_itertools.islice_extended(self.payoffs)[start:] for i, payoff in enumerate(payoffs): for player_id, reward in payoff.items(): wip_payoff[player_id] += (discount ** i) * reward return aggregating.Payoff(wip_payoff)
def __init__(self, n_players: int = 20, *, board_size: int = 20, core_strategies: Optional[Sequence[_GridRoyaleStrategy]] = None) -> None: self.board_size = board_size self.core_strategies = tuple(core_strategies or (Strategy(self) for _ in range(N_CORE_STRATEGIES))) self.strategies = tuple(more_itertools.islice_extended( itertools.cycle(self.core_strategies))[:n_players]) # self.executor = concurrent.futures.ProcessPoolExecutor(5) gamey.Culture.__init__(self, state_type=State, player_id_to_strategy=dict(zip(LETTERS, self.strategies)))
def test_simple(): culture = Culture({'A': Policy()}) game = Game.from_state_culture(State.make_initial(n_players=1), culture) assert len(game) == 1 (state_0, ) = game.states assert isinstance(state_0, State) assert len( state_0.food_positions) == grid_royale.constants.DEFAULT_N_FOOD_TILES assert len(state_0) == 1 # One player makes for one observation. assert state_0.board_size == grid_royale.constants.DEFAULT_BOARD_SIZE assert not state_0.is_end assert not state_0.bullets state_0_again, state_1, state_2 = more_itertools.islice_extended(game)[:3] assert state_0 is state_0_again assert type(state_0) is type(state_1) is type(state_2) is State assert len(game) == 3 observation: Observation = state_2['A'] assert observation.legal_actions
def cartesian_view(tensor1: torch.Tensor, tensor2: torch.Tensor, start: int, end: int) -> Tuple[torch.Tensor, torch.Tensor]: assert tensor1.dim() == tensor2.dim() start1, start2 = tensor1.size()[:start], tensor2.size()[:start] end1, end2 = tensor1.size()[end:], tensor2.size()[end:] mid1, mid2, mid_common = [], [], [] for dim1, dim2 in islice_extended(zip(tensor1.size(), tensor2.size()), start, end): if dim1 != dim2: mid1.extend((dim1, 1)) mid2.extend((1, dim2)) mid_common.extend((dim1, dim2)) else: mid1.append(dim1) mid2.append(dim2) mid_common.append(dim1) tensor1 = tensor1.view(*start1, *mid1, *end1).expand(*start1, *mid_common, *end1) tensor2 = tensor2.view(*start2, *mid2, *end2).expand(*start2, *mid_common, *end2) return tensor1, tensor2
self.train_iterate(make_initial_state, n_games=n_games, max_game_length=max_game_length, n_phases=n_phases)) def train_iterate(self, make_initial_state: Callable[[], gamey.State], *, n_games: int = 1_000, max_game_length: Optional[int] = None, n_phases: Optional[int] = None) -> Iterable[Policy]: from .gaming import Game culture = self games = [] games_buffer_max_size = 10 * n_games for _i_phase in more_itertools.islice_extended( itertools.count())[:n_phases]: games.extend( Game.from_state_culture(make_initial_state(), culture) for _ in range(n_games)) if len( games ) >= games_buffer_max_size: # Truncate to avoid memory leaks del games[:-games_buffer_max_size] Game.multi_crunch(games, n=max_game_length) culture = type(self)({ player_id: policy.train( tuple(game.narratives[player_id] for game in games)) for player_id, policy in culture.items() }) yield culture
def multi_crunch(games: Sequence[Game], n: Optional[int] = None) -> None: for _ in more_itertools.islice_extended(Game.multi_iterate(games))[:n]: pass
def crunch(self, n: Optional[int] = None) -> None: for _ in more_itertools.islice_extended(self)[:n]: pass assert self.states[-1].is_end or len(self.states) == n
import fileinput from more_itertools import islice_extended for line in islice_extended(fileinput.input(), -10, None): print(line, end='')