def unzip(seq): """Inverse of ``zip`` >>> a, b = unzip([('a', 1), ('b', 2)]) >>> list(a) ['a', 'b'] >>> list(b) [1, 2] Unlike the naive implementation ``def unzip(seq): zip(*seq)`` this implementation can handle a finite sequence of infinite sequences. Caveats: * The implementation uses ``tee``, and so can use a significant amount of auxiliary storage if the resulting iterators are consumed at different times. * The top level sequence cannot be infinite. """ seq = iter(seq) # Check how many iterators we need try: first = tuple(next(seq)) except StopIteration: return tuple() # and create them niters = len(first) seqs = tee(cons(first, seq), niters) return tuple(starmap(pluck, enumerate(seqs)))
def __init__( self, vim: NvimFacade, config_path: Path, plugins: List[str], bases: List[Path], type_bases: Map[Path, List[str]], initial_projects: Maybe[Projects]=Empty() ) -> None: self._config_path = config_path self._bases = bases self._type_bases = type_bases self._initial_projects = initial_projects core = 'proteome.plugins.core' ProteomeState.__init__(self, vim, List.wrap(cons(core, plugins)))
def test_cons(): assert list(cons(1, [2, 3])) == [1, 2, 3]
def cons(self, item): return List.wrap(cons(item, self))
compose(list, partial(take, args.predictions_limit))), ujson.load(args.dataset_file))) sections = groupby(lambda x: tuple(map(x.get, ['make', 'model'])), dataset).items() evaluation_base_url = f'https://storage.cloud.google.com/dev_visual_search/evaluations/output/by-id/{args.evaluation_id}' def link_to_page(key): if key is None: return None make, model = key return f'{evaluation_base_url}/prediction-{make}-{model}.html' for prev, current, next in sliding_window( 3, cons(None, concat([sections, [None]]))): key, section = current make, model = key prev_key, _ = prev if prev is not None else (None, None) next_key, _ = next if next is not None else (None, None) page = to_page( section, { 'prev': link_to_page(prev_key), 'parent': '', 'next': link_to_page(next_key) }, { 'title': f'Prediction report for {make} / {model}', 'evaluation_id': args.evaluation_id, 'image_base_path': args.image_base_path,
def cons(self, item: A) -> 'List[A]': return List.wrap(cons(item, self))