Mercurial > hg
view mercurial/thirdparty/attr/validators.py @ 35935:00b9e26d727b
sshpeer: establish SSH connection before class instantiation
We want to move the handshake to before peers are created so
we can instantiate a different peer class depending on the
results of the handshake. This necessitates moving the SSH
process invocation to outside the peer class.
As part of the code move, some variables were renamed for
clarity. util.popen4() returns stdin, stdout, and stderr in
their typical file descriptor order. However, stdin and stdout
were being mapped to "pipeo" and "pipei" respectively. "o"
for "stdin" and "i" for "stdout" is a bit confusing. Although
it does make sense for "output" and "input" from the perspective
of the client. But in the context of the new function, it makes
sense to refer to these as their file descriptor names.
In addition, the last use of self._path disappeared, so we stop
setting that attribute and we can delete the redundant URL
parsing necessary to set it.
Differential Revision: https://phab.mercurial-scm.org/D2031
author | Gregory Szorc <gregory.szorc@gmail.com> |
---|---|
date | Mon, 05 Feb 2018 14:05:59 -0800 |
parents | 765eb17a7eb8 |
children | e1c586b9a43c |
line wrap: on
line source
""" Commonly useful validators. """ from __future__ import absolute_import, division, print_function from ._make import attr, attributes, and_, _AndValidator __all__ = [ "and_", "in_", "instance_of", "optional", "provides", ] @attributes(repr=False, slots=True, hash=True) class _InstanceOfValidator(object): type = attr() def __call__(self, inst, attr, value): """ We use a callable class to be able to change the ``__repr__``. """ if not isinstance(value, self.type): raise TypeError( "'{name}' must be {type!r} (got {value!r} that is a " "{actual!r})." .format(name=attr.name, type=self.type, actual=value.__class__, value=value), attr, self.type, value, ) def __repr__(self): return ( "<instance_of validator for type {type!r}>" .format(type=self.type) ) def instance_of(type): """ A validator that raises a :exc:`TypeError` if the initializer is called with a wrong type for this particular attribute (checks are perfomed using :func:`isinstance` therefore it's also valid to pass a tuple of types). :param type: The type to check for. :type type: type or tuple of types :raises TypeError: With a human readable error message, the attribute (of type :class:`attr.Attribute`), the expected type, and the value it got. """ return _InstanceOfValidator(type) @attributes(repr=False, slots=True, hash=True) class _ProvidesValidator(object): interface = attr() def __call__(self, inst, attr, value): """ We use a callable class to be able to change the ``__repr__``. """ if not self.interface.providedBy(value): raise TypeError( "'{name}' must provide {interface!r} which {value!r} " "doesn't." .format(name=attr.name, interface=self.interface, value=value), attr, self.interface, value, ) def __repr__(self): return ( "<provides validator for interface {interface!r}>" .format(interface=self.interface) ) def provides(interface): """ A validator that raises a :exc:`TypeError` if the initializer is called with an object that does not provide the requested *interface* (checks are performed using ``interface.providedBy(value)`` (see `zope.interface <https://zopeinterface.readthedocs.io/en/latest/>`_). :param zope.interface.Interface interface: The interface to check for. :raises TypeError: With a human readable error message, the attribute (of type :class:`attr.Attribute`), the expected interface, and the value it got. """ return _ProvidesValidator(interface) @attributes(repr=False, slots=True, hash=True) class _OptionalValidator(object): validator = attr() def __call__(self, inst, attr, value): if value is None: return self.validator(inst, attr, value) def __repr__(self): return ( "<optional validator for {what} or None>" .format(what=repr(self.validator)) ) def optional(validator): """ A validator that makes an attribute optional. An optional attribute is one which can be set to ``None`` in addition to satisfying the requirements of the sub-validator. :param validator: A validator (or a list of validators) that is used for non-``None`` values. :type validator: callable or :class:`list` of callables. .. versionadded:: 15.1.0 .. versionchanged:: 17.1.0 *validator* can be a list of validators. """ if isinstance(validator, list): return _OptionalValidator(_AndValidator(validator)) return _OptionalValidator(validator) @attributes(repr=False, slots=True, hash=True) class _InValidator(object): options = attr() def __call__(self, inst, attr, value): if value not in self.options: raise ValueError( "'{name}' must be in {options!r} (got {value!r})" .format(name=attr.name, options=self.options, value=value) ) def __repr__(self): return ( "<in_ validator with options {options!r}>" .format(options=self.options) ) def in_(options): """ A validator that raises a :exc:`ValueError` if the initializer is called with a value that does not belong in the options provided. The check is performed using ``value in options``. :param options: Allowed options. :type options: list, tuple, :class:`enum.Enum`, ... :raises ValueError: With a human readable error message, the attribute (of type :class:`attr.Attribute`), the expected options, and the value it got. .. versionadded:: 17.1.0 """ return _InValidator(options)