File Manager

X7ROOT File Manager

Current Path: /opt/alt/python37/lib/python3.7/site-packages/attr

opt / alt / python37 / lib / python3.7 / site-packages / attr /

?? ..
?? __init__.py(1.58 KB)
?? __init__.pyi(14.49 KB)
?? __pycache__
?? _cmp.py(4.04 KB)
?? _cmp.pyi(318 B)
?? _compat.py(7.38 KB)
?? _config.py(514 B)
?? _funcs.py(13.08 KB)
?? _make.py(95.45 KB)
?? _next_gen.py(3.98 KB)
?? _version_info.py(2.11 KB)
?? _version_info.pyi(209 B)
?? converters.py(2.97 KB)
?? converters.pyi(382 B)
?? exceptions.py(1.9 KB)
?? exceptions.pyi(540 B)
?? filters.py(1.07 KB)
?? filters.pyi(216 B)
?? py.typed(0 B)
?? setters.py(1.4 KB)
?? setters.pyi(574 B)
?? validators.py(11.23 KB)
?? validators.pyi(1.83 KB)

Editing: _next_gen.py

"""
These are Python 3.6+-only and keyword-only APIs that call `attr.s` and
`attr.ib` with different default values.
"""

from functools import partial

from attr.exceptions import UnannotatedAttributeError

from . import setters
from ._make import NOTHING, _frozen_setattrs, attrib, attrs

def define(
    maybe_cls=None,
    *,
    these=None,
    repr=None,
    hash=None,
    init=None,
    slots=True,
    frozen=False,
    weakref_slot=True,
    str=False,
    auto_attribs=None,
    kw_only=False,
    cache_hash=False,
    auto_exc=True,
    eq=None,
    order=False,
    auto_detect=True,
    getstate_setstate=None,
    on_setattr=None,
    field_transformer=None,
):
    r"""
    The only behavioral differences are the handling of the *auto_attribs*
    option:

:param Optional[bool] auto_attribs: If set to `True` or `False`, it behaves
       exactly like `attr.s`. If left `None`, `attr.s` will try to guess:

1. If any attributes are annotated and no unannotated `attr.ib`\ s
          are found, it assumes *auto_attribs=True*.
       2. Otherwise it assumes *auto_attribs=False* and tries to collect
          `attr.ib`\ s.

and that mutable classes (``frozen=False``) validate on ``__setattr__``.

.. versionadded:: 20.1.0
    """

def do_it(cls, auto_attribs):
        return attrs(
            maybe_cls=cls,
            these=these,
            repr=repr,
            hash=hash,
            init=init,
            slots=slots,
            frozen=frozen,
            weakref_slot=weakref_slot,
            str=str,
            auto_attribs=auto_attribs,
            kw_only=kw_only,
            cache_hash=cache_hash,
            auto_exc=auto_exc,
            eq=eq,
            order=order,
            auto_detect=auto_detect,
            collect_by_mro=True,
            getstate_setstate=getstate_setstate,
            on_setattr=on_setattr,
            field_transformer=field_transformer,
        )

def wrap(cls):
        """
        Making this a wrapper ensures this code runs during class creation.

We also ensure that frozen-ness of classes is inherited.
        """
        nonlocal frozen, on_setattr

had_on_setattr = on_setattr not in (None, setters.NO_OP)

# By default, mutable classes validate on setattr.
        if frozen is False and on_setattr is None:
            on_setattr = setters.validate

# However, if we subclass a frozen class, we inherit the immutability
        # and disable on_setattr.
        for base_cls in cls.__bases__:
            if base_cls.__setattr__ is _frozen_setattrs:
                if had_on_setattr:
                    raise ValueError(
                        "Frozen classes can't use on_setattr "
                        "(frozen-ness was inherited)."
                    )

on_setattr = setters.NO_OP
                break

if auto_attribs is not None:
            return do_it(cls, auto_attribs)

try:
            return do_it(cls, True)
        except UnannotatedAttributeError:
            return do_it(cls, False)

# maybe_cls's type depends on the usage of the decorator.  It's a class
    # if it's used as `@attrs` but ``None`` if used as `@attrs()`.
    if maybe_cls is None:
        return wrap
    else:
        return wrap(maybe_cls)

mutable = define
frozen = partial(define, frozen=True, on_setattr=None)

def field(
    *,
    default=NOTHING,
    validator=None,
    repr=True,
    hash=None,
    init=True,
    metadata=None,
    converter=None,
    factory=None,
    kw_only=False,
    eq=None,
    order=None,
    on_setattr=None,
):
    """
    Identical to `attr.ib`, except keyword-only and with some arguments
    removed.

.. versionadded:: 20.1.0
    """
    return attrib(
        default=default,
        validator=validator,
        repr=repr,
        hash=hash,
        init=init,
        metadata=metadata,
        converter=converter,
        factory=factory,
        kw_only=kw_only,
        eq=eq,
        order=order,
        on_setattr=on_setattr,
    )

X7ROOT File Manager

Editing: _next_gen.py

Upload File

Create Folder