0UT1S's

opt/hc_python/lib/python3.12/site-packages/dns/

By Order of Mr.0UT1S

N/A

[DIR] __pycache__

N/A

[DIR] dnssecalgs

N/A

N/A

N/A

1.62 KB

_asyncbackend.py

2.34 KB

_asyncio_backend.py

8.84 KB

5.12 KB

2.43 KB

_immutable_ctx.py

2.40 KB

_trio_backend.py

8.27 KB

asyncbackend.py

2.73 KB

30.10 KB

asyncresolver.py

17.43 KB

40.74 KB

1.76 KB

3.88 KB

16.69 KB

4.14 KB

3.60 KB

5.81 KB

2.69 KB

2.09 KB

1.97 KB

5.64 KB

2.49 KB

6.40 KB

66.59 KB

41.78 KB

3.91 KB

9.88 KB

12.37 KB

2.67 KB

0 bytes

54.98 KB

4.06 KB

30.29 KB

2.91 KB

16.27 KB

7.27 KB

10.99 KB

72.00 KB

3.74 KB

8.96 KB

3.52 KB

9.00 KB

23.03 KB

22.06 KB

11.15 KB

2.57 KB

2.91 KB

11.96 KB

1.88 KB

11.49 KB

8.67 KB

2.76 KB

12.96 KB

50.87 KB

27.27 KB

690 bytes

# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license

# This implementation of the immutable decorator requires python >=
# 3.7, and is significantly more storage efficient when making classes
# with slots immutable.  It's also faster.

import contextvars
import inspect

_in__init__ = contextvars.ContextVar("_immutable_in__init__", default=False)

class _Immutable:
    """Immutable mixin class"""

# We set slots to the empty list to say "we don't have any attributes".
    # We do this so that if we're mixed in with a class with __slots__, we
    # don't cause a __dict__ to be added which would waste space.

__slots__ = ()

def __setattr__(self, name, value):
        if _in__init__.get() is not self:
            raise TypeError("object doesn't support attribute assignment")
        else:
            super().__setattr__(name, value)

def __delattr__(self, name):
        if _in__init__.get() is not self:
            raise TypeError("object doesn't support attribute assignment")
        else:
            super().__delattr__(name)

def _immutable_init(f):
    def nf(*args, **kwargs):
        previous = _in__init__.set(args[0])
        try:
            # call the actual __init__
            f(*args, **kwargs)
        finally:
            _in__init__.reset(previous)

nf.__signature__ = inspect.signature(f)
    return nf

def immutable(cls):
    if _Immutable in cls.__mro__:
        # Some ancestor already has the mixin, so just make sure we keep
        # following the __init__ protocol.
        cls.__init__ = _immutable_init(cls.__init__)
        if hasattr(cls, "__setstate__"):
            cls.__setstate__ = _immutable_init(cls.__setstate__)
        ncls = cls
    else:
        # Mixin the Immutable class and follow the __init__ protocol.
        class ncls(_Immutable, cls):
            # We have to do the __slots__ declaration here too!
            __slots__ = ()

@_immutable_init
            def __init__(self, *args, **kwargs):
                super().__init__(*args, **kwargs)

if hasattr(cls, "__setstate__"):

@_immutable_init
                def __setstate__(self, *args, **kwargs):
                    super().__setstate__(*args, **kwargs)

# make ncls have the same name and module as cls
        ncls.__name__ = cls.__name__
        ncls.__qualname__ = cls.__qualname__
        ncls.__module__ = cls.__module__
    return ncls