Advanced File Manager

✏️ Mengedit: validators.py

"""
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)

❌ Batal

Nama	Ukuran	Dimodifikasi	Permission	Aksi
📁 __pycache__	-	2025-09-22 22:58	0755
💻 __init__.py	1.1 KB	2022-06-16 13:09	0644	✏️ Edit ⬇
💻 _compat.py	2.8 KB	2022-06-16 13:09	0644	✏️ Edit ⬇
💻 _config.py	514 B	2022-06-16 13:09	0644	✏️ Edit ⬇
💻 _funcs.py	7.7 KB	2022-06-16 13:09	0644	✏️ Edit ⬇
💻 _make.py	34.8 KB	2022-06-16 13:09	0644	✏️ Edit ⬇
💻 converters.py	531 B	2022-06-16 13:09	0644	✏️ Edit ⬇
💻 exceptions.py	919 B	2022-06-16 13:09	0644	✏️ Edit ⬇
💻 filters.py	1.1 KB	2022-06-16 13:09	0644	✏️ Edit ⬇
💻 validators.py	4.9 KB	2022-06-16 13:09	0644	✏️ Edit ⬇

📂 Advanced File Manager

✏️ Mengedit: validators.py

✍️ Rename: