def _read_txt(self, stream): ''' Load a PLY element from an ASCII-format PLY file. The element may contain list properties. ''' self._data = _np.empty(self.count, dtype=self.dtype()) k = 0 for line in _islice(iter(stream.readline, b''), self.count): fields = iter(line.strip().split()) for prop in self.properties: try: self._data[prop.name][k] = prop._from_fields(fields) except StopIteration: raise PlyElementParseError("early end-of-line", self, k, prop) except ValueError: raise PlyElementParseError("malformed input", self, k, prop) try: next(fields) except StopIteration: pass else: raise PlyElementParseError("expected end-of-line", self, k) k += 1 if k < self.count: del self._data raise PlyElementParseError("early end-of-file", self, k)
def _from_fields(self, fields): (len_t, val_t) = self.list_dtype() n = int(_np.dtype(len_t).type(next(fields))) data = _np.loadtxt(list(_islice(fields, n)), val_t, ndmin=1) if len(data) < n: raise StopIteration return data
def _from_fields(self, fields): ''' Parse textual data from a generator. ''' (len_t, val_t) = self.list_dtype() n = int(next(fields)) return _np.loadtxt(list(_islice(fields, n)), val_t, ndmin=1)
def notify(self, n=1): if not self._is_owned(): raise RuntimeError("cannot notify on un-acquired lock") all_waiters = self._waiters waiters_to_notify = _deque(_islice(all_waiters, n)) if not waiters_to_notify: return for waiter in waiters_to_notify: waiter.release() try: all_waiters.remove(waiter) except ValueError: pass
def consume_payload(self, it: _Union[_ByteString, _Iterator[int]]) -> None: it = iter(it) self.protocol = _iterutils.consume_varint(it) self.address = _iterutils.consume_string(it) self.port = int.from_bytes(_islice(it, 2), 'big') self.next_state, = it assert self.protocol == 578 assert self.address assert self.port > 0 assert self.next_state in [1, 2]
def _read_txt(self, stream): ''' Load a PLY element from an ASCII-format PLY file. The element may contain list properties. ''' self.data = _np.empty(self.count, dtype=self.dtype()) for (k, line) in enumerate(_islice(iter(stream.readline, ''), self.count)): fields = iter(line.strip().split()) for prop in self.properties: self.data[prop.name][k] = prop._from_fields(fields)
def unzip(n, iterable): '''inverse of zip() unzip(n, iterable) -> n lists assert all(len(list(e)) == n for e in iterable) ''' if not n >= 0: raise ValueError('not n >= 0') lsls = tuple([] for _ in range(n)) for xs in iterable: xs = _islice(xs, n + 1) xs = tuple(xs) if not len(xs) == n: raise ValueError('not all(len(list(e)) == n for e in iterable)') for x, ls in zip(xs, lsls): ls.append(x) return lsls
def notify(self, n=1): """Wake up one or more threads waiting on this condition, if any. If the calling thread has not acquired the lock when this method is called, a RuntimeError is raised. This method wakes up at most n of the threads waiting for the condition variable; it is a no-op if no threads are waiting. """ if not self._is_owned(): raise RuntimeError("cannot notify on un-acquired lock") all_waiters = self._waiters waiters_to_notify = _deque(_islice(all_waiters, n)) if not waiters_to_notify: return for waiter in waiters_to_notify: waiter.release() try: all_waiters.remove(waiter) except ValueError: pass
def cycle_thru_list(list_obj, i): """ Cycles through a list Parameters ---------- list_obj : list List to be cycled through i : int Index of list to be put in the first position Returns ------- cycled_list : list List with index `i` now in the first position """ cycle_obj = _cycle(list_obj) L = len(list_obj) slice_obj = _islice(cycle_obj, i, i + L) cycled_list = list(slice_obj) return(cycled_list)
def _read(self, stream, text, byte_order): ''' Read the actual data from a PLY file. ''' if self._have_list: # There are list properties, so a simple load is # impossible. if text: self._read_txt(stream) else: self._read_bin(stream, byte_order) else: # There are no list properties, so loading the data is # much more straightforward. if text: self.data = _np.loadtxt( _islice(iter(stream.readline, ''), self.count), self.dtype()) else: self.data = _np.fromfile( stream, self.dtype(byte_order), self.count)
def _read(self, stream, text, byte_order): ''' Read the actual data from a PLY file. ''' if self._have_list: # There are list properties, so a simple load is # impossible. if text: self._read_txt(stream) else: self._read_bin(stream, byte_order) else: # There are no list properties, so loading the data is # much more straightforward. if text: self.data = _np.loadtxt( _islice(iter(stream.readline, ''), self.count), self.dtype()) else: self.data = _np.fromfile(stream, self.dtype(byte_order), self.count)
def consume_string(it: _Iterator[int]) -> str: n = consume_varint(it) return bytes(_islice(it, n)).decode()
def clean(self): self._lock.clean() for waiters in _deque(_islice(self._waiters, len(self._waiters))): waiters.clean()
def take(n, iterable): "Return first n items of the iterable as a tuple" return tuple(_islice(iterable, n))
def Islice(iterable, start, stop, step): return _islice(iterable, start if start is None else start % len(iterable), stop if stop is None else stop % len(iterable), step)