aDriv4 website!

Linux premium39.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64
LiteSpeed
198.187.29.188

_compat.py

# SPDX-License-Identifier: MIT

import inspect
import platform
import sys
import threading
import types
import warnings

from collections.abc import Mapping, Sequence  # noqa
from typing import _GenericAlias

PYPY = platform.python_implementation() == "PyPy"
PY_3_9_PLUS = sys.version_info[:2] >= (3, 9)
PY310 = sys.version_info[:2] >= (3, 10)
PY_3_12_PLUS = sys.version_info[:2] >= (3, 12)

def just_warn(*args, **kw):
    warnings.warn(
        "Running interpreter doesn't sufficiently support code object "
        "introspection.  Some features like bare super() or accessing "
        "__class__ will not work with slotted classes.",
        RuntimeWarning,
        stacklevel=2,
    )

class _AnnotationExtractor:
    """
    Extract type annotations from a callable, returning None whenever there
    is none.
    """

__slots__ = ["sig"]

def __init__(self, callable):
        try:
            self.sig = inspect.signature(callable)
        except (ValueError, TypeError):  # inspect failed
            self.sig = None

def get_first_param_type(self):
        """
        Return the type annotation of the first argument if it's not empty.
        """
        if not self.sig:
            return None

params = list(self.sig.parameters.values())
        if params and params[0].annotation is not inspect.Parameter.empty:
            return params[0].annotation

return None

def get_return_type(self):
        """
        Return the return type if it's not empty.
        """
        if (
            self.sig
            and self.sig.return_annotation is not inspect.Signature.empty
        ):
            return self.sig.return_annotation

return None

def make_set_closure_cell():
    """Return a function of two arguments (cell, value) which sets
    the value stored in the closure cell `cell` to `value`.
    """
    # pypy makes this easy. (It also supports the logic below, but
    # why not do the easy/fast thing?)
    if PYPY:

def set_closure_cell(cell, value):
            cell.__setstate__((value,))

return set_closure_cell

# Otherwise gotta do it the hard way.

try:
        if sys.version_info >= (3, 8):

def set_closure_cell(cell, value):
                cell.cell_contents = value

else:
            # Create a function that will set its first cellvar to `value`.
            def set_first_cellvar_to(value):
                x = value
                return

# This function will be eliminated as dead code, but
                # not before its reference to `x` forces `x` to be
                # represented as a closure cell rather than a local.
                def force_x_to_be_a_cell():  # pragma: no cover
                    return x

# Extract the code object and make sure our assumptions about
            # the closure behavior are correct.
            co = set_first_cellvar_to.__code__
            if co.co_cellvars != ("x",) or co.co_freevars != ():
                raise AssertionError  # pragma: no cover

# Convert this code object to a code object that sets the
            # function's first _freevar_ (not cellvar) to the argument.
            args = [co.co_argcount]
            args.append(co.co_kwonlyargcount)
            args.extend(
                [
                    co.co_nlocals,
                    co.co_stacksize,
                    co.co_flags,
                    co.co_code,
                    co.co_consts,
                    co.co_names,
                    co.co_varnames,
                    co.co_filename,
                    co.co_name,
                    co.co_firstlineno,
                    co.co_lnotab,
                    # These two arguments are reversed:
                    co.co_cellvars,
                    co.co_freevars,
                ]
            )
            set_first_freevar_code = types.CodeType(*args)

def set_closure_cell(cell, value):
                # Create a function using the set_first_freevar_code,
                # whose first closure cell is `cell`. Calling it will
                # change the value of that cell.
                setter = types.FunctionType(
                    set_first_freevar_code, {}, "setter", (), (cell,)
                )
                # And call it to set the cell.
                setter(value)

# Make sure it works on this interpreter:
        def make_func_with_cell():
            x = None

def func():
                return x  # pragma: no cover

return func

cell = make_func_with_cell().__closure__[0]
        set_closure_cell(cell, 100)
        if cell.cell_contents != 100:
            raise AssertionError  # pragma: no cover

except Exception:
        return just_warn
    else:
        return set_closure_cell

set_closure_cell = make_set_closure_cell()

# Thread-local global to track attrs instances which are already being repr'd.
# This is needed because there is no other (thread-safe) way to pass info
# about the instances that are already being repr'd through the call stack
# in order to ensure we don't perform infinite recursion.
#
# For instance, if an instance contains a dict which contains that instance,
# we need to know that we're already repr'ing the outside instance from within
# the dict's repr() call.
#
# This lives here rather than in _make.py so that the functions in _make.py
# don't have a direct reference to the thread-local in their globals dict.
# If they have such a reference, it breaks cloudpickle.
repr_context = threading.local()

def get_generic_base(cl):
    """If this is a generic class (A[str]), return the generic base for it."""
    if cl.__class__ is _GenericAlias:
        return cl.__origin__
    return None

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	0755	2026-02-06 09:30:55
..	dir	-	root/root	0755	2026-02-11 09:30:47
__pycache__	dir	-	root/root	0755	2026-02-06 09:31:43
__init__.py	text/x-python	3.17 KB	root/root	0644	2026-01-20 01:01:48
__init__.pyi	text/x-python	17.2 KB	root/root	0644	2026-01-20 01:01:48
_cmp.py	text/x-python	4 KB	root/root	0644	2026-01-20 01:01:48
_cmp.pyi	text/x-python	399 B	root/root	0644	2026-01-20 01:01:48
_compat.py	text/x-python	5.67 KB	root/root	0644	2026-01-20 01:01:48
_config.py	text/x-python	826 B	root/root	0644	2026-01-20 01:01:48
_funcs.py	text/x-python	16.34 KB	root/root	0644	2026-01-20 01:01:48
_make.py	text/x-python	94.71 KB	root/root	0644	2026-01-20 01:01:48
_next_gen.py	text/x-python	6.12 KB	root/root	0644	2026-01-20 01:01:48
_typing_compat.pyi	text/x-python	469 B	root/root	0644	2026-01-20 01:01:48
_version_info.py	text/x-python	2.07 KB	root/root	0644	2026-01-20 01:01:48
_version_info.pyi	text/x-python	209 B	root/root	0644	2026-01-20 01:01:48
converters.py	text/x-python	3.52 KB	root/root	0644	2026-01-20 01:01:48
converters.pyi	text/x-python	406 B	root/root	0644	2026-01-20 01:01:48
exceptions.py	text/x-python	1.85 KB	root/root	0644	2026-01-20 01:01:48
exceptions.pyi	text/x-python	539 B	root/root	0644	2026-01-20 01:01:48
filters.py	text/x-python	1.44 KB	root/root	0644	2026-01-20 01:01:48
filters.pyi	text/x-python	225 B	root/root	0644	2026-01-20 01:01:48
py.typed	application/x-empty	0 B	root/root	0644	2026-01-20 01:01:48
setters.py	text/x-python	1.37 KB	root/root	0644	2026-01-20 01:01:48
setters.pyi	text/x-python	567 B	root/root	0644	2026-01-20 01:01:48
validators.py	text/x-python	20.22 KB	root/root	0644	2026-01-20 01:01:48
validators.pyi	text/x-python	2.52 KB	root/root	0644	2026-01-20 01:01:48

For more Private tool come to me!

https://t.me/aDriv4vz