async def _readline(self, limit=65536): """Read one line from the socket. It errs out when line length exceeds the limit. """ if self._buffer: ASSERT.equal(len(self._buffer), 1) line = self._search_line(0) if line is not None: return line while not self._ended and self._size <= limit: data = await self._sock.recv(limit + 1) if not data: self._ended = True break self._buffer.append(data) self._size += len(data) line = self._search_line(-1) if line is not None: ASSERT.in_(len(self._buffer), (0, 1)) return line if self._size > limit: raise _TooLong('request line length exceeds %d' % limit) if self._buffer: remaining = b''.join(self._buffer) self._buffer.clear() self._size = 0 return remaining else: return b''
def __post_init__(self): ASSERT.in_(self.kind, ('range', 'values')) if self.kind == 'range': ASSERT.equal(len(self.args), 2) ASSERT.all(self.args, lambda arg: isinstance(arg, int)) ASSERT.less_or_equal(self.args[0], self.args[1]) else: ASSERT.equal(self.kind, 'values') ASSERT.all(self.args, lambda arg: isinstance(arg, str))
def __post_init__(self): validate_app_name(self.name) if self.service_section is None: ASSERT.not_empty(self.exec) ASSERT.in_(self.type, _SERVICE_TYPES) ASSERT.in_(self.kill_mode, _KILL_MODES) else: ASSERT.empty(self.exec) ASSERT.none(self.type) ASSERT.none(self.kill_mode)
def add_if_not_exists_clause(index, connectable): """Add "IF NOT EXISTS" clause to create index statement. I don't know why but ``sqlalchemy.Index.create()`` does not take a ``checkfirst`` argument like the rest of others. """ stmt = str(CreateIndex(index).compile(connectable)) stmt = stmt.replace('CREATE INDEX', 'CREATE INDEX IF NOT EXISTS', 1) ASSERT.in_('IF NOT EXISTS', stmt) return stmt
def _iter_dirs(self, dir_object_type, target_top_path, env): ASSERT.in_(env, self.envs) # NOTE: rglob does NOT traverse into symlink directory (which is # good in this case). for link_path in (self.top_path / env).rglob('*'): if not link_path.is_symlink(): continue target_path = link_path.resolve() # XXX Is there a better way to match path prefix? if str(target_path).startswith(str(target_top_path)): yield dir_object_type(target_top_path, target_path)
def cmd_assign(args): oses.assert_root_privilege() ASSERT.in_( args.pod_id, tokens.load_active_pod_ids(pod_ops_dirs.make_ops_dirs()), ) with tokens.make_tokens_database().writing() as active_tokens: ASSERT.predicate(args.token_name, active_tokens.has_definition) active_tokens.assign(args.token_name, args.pod_id, args.name, args.value) return 0
def _apt_get(command, assume, extra_args): bases.run([ 'apt-get', '--assume-%s' % ASSERT.in_(assume, ('yes', 'no')), command, *extra_args, ])
def unrelease(self, env, label): ASSERT.in_(env, self.envs) _remove_file_and_maybe_parents( self.top_path / env / label.path / label.name, self.top_path / env, )
def _encode_value(self, value_type, value): """Encode a value into a raw value. This and ``_decode_raw_value`` complement each other. """ if typings.is_recursive_type(value_type): if value_type.__origin__ in (list, set, frozenset): element_type = value_type.__args__[0] return [ self._encode_value(element_type, element) for element in value ] elif value_type.__origin__ is tuple: ASSERT.equal(len(value), len(value_type.__args__)) return tuple( self._encode_value(element_type, element) for element_type, element in zip( value_type.__args__, value, )) elif typings.is_union_type(value_type): # Make a special case for ``None``. if value is None: ASSERT.in_(NoneType, value_type.__args__) return None # Make a special case for ``Optional[T]``. type_ = typings.match_optional_type(value_type) if type_: return self._encode_value(type_, value) for type_ in value_type.__args__: if typings.is_recursive_type(type_): if _match_recursive_type(type_, value): return { str(type_): self._encode_value(type_, value) } elif isinstance(value, type_): return { type_.__name__: self._encode_value(type_, value) } return ASSERT.unreachable( 'value is not any union element type: {!r} {!r}', value_type, value, ) else: return ASSERT.unreachable('unsupported generic: {!r}', value_type) elif wiredata.is_message(value): ASSERT.predicate(value_type, wiredata.is_message_type) return { f.name: self._encode_value(f.type, getattr(value, f.name)) for f in dataclasses.fields(value) } elif isinstance(value, datetime.datetime): ASSERT.issubclass(value_type, datetime.datetime) return value.isoformat() elif isinstance(value, enum.Enum): ASSERT.issubclass(value_type, enum.Enum) return value.name # JSON does not support binary type; so it has to be encoded. elif isinstance(value, bytes): ASSERT.issubclass(value_type, bytes) return base64.standard_b64encode(value).decode('ascii') elif isinstance(value, Exception): ASSERT.issubclass(value_type, Exception) return { type(value).__name__: [ ASSERT.isinstance(arg, _DIRECTLY_SERIALIZABLE_TYPES) for arg in value.args ] } elif isinstance(value, _DIRECTLY_SERIALIZABLE_TYPES): ASSERT.issubclass(value_type, _DIRECTLY_SERIALIZABLE_TYPES) return value else: return ASSERT.unreachable('unsupported value type: {!r} {!r}', value_type, value)
def _decode_raw_value(self, value_type, raw_value): """Decode a raw value into ``value_type``-typed value. This and ``_encode_value`` complement each other. """ if typings.is_recursive_type(value_type): if value_type.__origin__ in (list, set, frozenset): element_type = value_type.__args__[0] return value_type.__origin__( self._decode_raw_value(element_type, raw_element) for raw_element in raw_value) elif value_type.__origin__ is tuple: ASSERT.equal(len(raw_value), len(value_type.__args__)) return tuple( self._decode_raw_value(element_type, raw_element) for element_type, raw_element in zip( value_type.__args__, raw_value, )) elif typings.is_union_type(value_type): # Handle ``None`` special case. if raw_value is None: ASSERT.in_(NoneType, value_type.__args__) return None # Handle ``Optional[T]`` special case. type_ = typings.match_optional_type(value_type) if type_: return self._decode_raw_value(type_, raw_value) ASSERT.equal(len(raw_value), 1) type_name, raw_element = next(iter(raw_value.items())) for type_ in value_type.__args__: if typings.is_recursive_type(type_): candidate = str(type_) else: candidate = type_.__name__ if type_name == candidate: return self._decode_raw_value(type_, raw_element) return ASSERT.unreachable( 'raw value is not any union element type: {!r} {!r}', value_type, raw_value, ) else: return ASSERT.unreachable('unsupported generic: {!r}', value_type) elif wiredata.is_message_type(value_type): return value_type( **{ f.name: self._decode_raw_value(f.type, raw_value[f.name]) for f in dataclasses.fields(value_type) if f.name in raw_value }) elif not isinstance(value_type, type): # Non-``type`` instance cannot be passed to ``issubclass``. return ASSERT.unreachable('unsupported value type: {!r}', value_type) elif issubclass(value_type, datetime.datetime): return value_type.fromisoformat(raw_value) elif issubclass(value_type, enum.Enum): return value_type[raw_value] elif issubclass(value_type, bytes): return base64.standard_b64decode(raw_value.encode('ascii')) elif issubclass(value_type, Exception): ASSERT.equal(len(raw_value), 1) return value_type( *(ASSERT.isinstance(raw_arg, _DIRECTLY_SERIALIZABLE_TYPES) for raw_arg in raw_value[value_type.__name__])) elif issubclass(value_type, _DIRECTLY_SERIALIZABLE_TYPES): if value_type in _DIRECTLY_SERIALIZABLE_TYPES: return ASSERT.isinstance(raw_value, value_type) else: # Support sub-type of int, etc. return value_type(raw_value) else: return ASSERT.unreachable('unsupported value type: {!r}', value_type)
def disable(self, signum): """Disable receiving signal ``signum``.""" ASSERT.not_none(self._wakeup_fd) ASSERT.in_(signum, self._handlers) signal.signal(signum, self._handlers.pop(signum))
def _union_none_getter(reader, name): # pylint: disable=useless-return ASSERT.in_(reader[name], (None, _capnp.VOID)) return None