import builtins
import contextlib
import copy
import inspect
import functools
import sys
import traceback
import types
from typing import *

from crosshair.condition_parser import Conditions, get_fn_conditions, ClassConditions, get_class_conditions, fn_globals
from crosshair.util import IdentityWrapper, AttributeHolder


class PreconditionFailed(BaseException):
    pass


class PostconditionFailed(BaseException):
    pass


def is_singledispatcher(fn: Callable) -> bool:
    return hasattr(fn, 'registry') and isinstance(fn.registry, Mapping)  # type: ignore


def EnforcementWrapper(fn: Callable, conditions: Conditions, enforced: 'EnforcedConditions') -> Callable:
    signature = conditions.sig

    def wrapper(*a, **kw):
        fns_enforcing = enforced.fns_enforcing
        if fns_enforcing is None or fn in fns_enforcing:
            return fn(*a, **kw)
        #print('Calling enforcement wrapper ', fn)
        bound_args = signature.bind(*a, **kw)
        bound_args.apply_defaults()
        old = {}
        mutable_args = conditions.mutable_args
        mutable_args_remaining = set(mutable_args) if mutable_args is not None else set()
        for argname, argval in bound_args.arguments.items():
            old[argname] = copy.copy(argval)
            if argname in mutable_args_remaining:
                mutable_args_remaining.remove(argname)
        if mutable_args_remaining:
            raise PostconditionFailed('Unrecognized mutable argument(s) in postcondition: "{}"'.format(
                ','.join(mutable_args_remaining)))
        with enforced.currently_enforcing(fn):
            for precondition in conditions.pre:
                #print(' precondition eval ', precondition.expr_source)
                args = {**fn_globals(fn), **bound_args.arguments}
                if not eval(precondition.expr, args):
                    raise PreconditionFailed(
                        f'Precondition "{precondition.expr_source}" was not satisfied '
                        f'before calling "{fn.__name__}"')
        ret = fn(*a, **kw)
        with enforced.currently_enforcing(fn):
            lcls = {**bound_args.arguments, '__return__': ret,
                    '_': ret, '__old__': AttributeHolder(old)}
            args = {**fn_globals(fn), **lcls}
            for postcondition in conditions.post:
                #print(' postcondition eval ', postcondition.expr_source, fn, lcls['_'])
                if postcondition.expr and not eval(postcondition.expr, args):
                    raise PostconditionFailed('Postcondition failed at {}:{}'.format(
                        postcondition.filename, postcondition.line))
        #print('Completed enforcement wrapper ', fn)
        return ret
    return wrapper


class EnforcedConditions:
    def __init__(self, *envs, interceptor=lambda x: x):
        self.envs = envs
        self.interceptor = interceptor
        self.fns_enforcing: Optional[Set[Callable]] = set()
        self.wrapper_map: Dict[Callable, Callable] = {}
        self.original_map: Dict[IdentityWrapper[Callable], Callable] = {}

    def _wrap_class(self, cls: type, class_conditions: ClassConditions) -> None:
        #print('wrapping class ', cls)
        method_conditions = dict(class_conditions.methods)
        for method_name, method in list(inspect.getmembers(cls, inspect.isfunction)):
            conditions = method_conditions.get(method_name)
            if conditions is None:
                continue
            wrapper = self._wrap_fn(method, conditions)
            setattr(cls, method_name, wrapper)

    def _transform_singledispatch(self, fn, transformer):
        overloads = list(fn.registry.items())
        wrapped = functools.singledispatch(transformer(overloads[0][1]))
        for overload_typ, overload_fn in overloads[1:]:
            wrapped.register(overload_typ)(transformer(overload_fn))
        return wrapped

    def is_enforcement_wrapper(self, value):
        return IdentityWrapper(value) in self.original_map

    @contextlib.contextmanager
    def currently_enforcing(self, fn: Callable):
        if self.fns_enforcing is None:
            yield None
        else:
            self.fns_enforcing.add(fn)
            try:
                yield None
            finally:
                self.fns_enforcing.remove(fn)

    @contextlib.contextmanager
    def disabled_enforcement(self):
        prev = self.fns_enforcing
        assert prev is not None
        self.fns_enforcing = None
        try:
            yield None
        finally:
            self.fns_enforcing = prev

    @contextlib.contextmanager
    def enabled_enforcement(self):
        prev = self.fns_enforcing
        assert prev is None
        self.fns_enforcing = set()
        try:
            yield None
        finally:
            self.fns_enforcing = prev

    def __enter__(self):
        next_envs = [env.copy() for env in self.envs]
        for env, next_env in zip(self.envs, next_envs):
            for (k, v) in env.items():
                if isinstance(v, (types.FunctionType, types.BuiltinFunctionType)):
                    if is_singledispatcher(v):
                        wrapper = self._transform_singledispatch(
                            v, self._wrap_fn)
                    else:
                        wrapper = self._wrap_fn(v)
                        if wrapper is v:
                            continue
                    next_env[k] = wrapper
                elif isinstance(v, type):
                    conditions = get_class_conditions(v)
                    if conditions.has_any():
                        self._wrap_class(v, conditions)
        for env, next_env in zip(self.envs, next_envs):
            env.update(next_env)
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        next_envs = [env.copy() for env in self.envs]
        for env, next_env in zip(self.envs, next_envs):
            for (k, v) in list(env.items()):
                next_env[k] = self._unwrap(v)
        for env, next_env in zip(self.envs, next_envs):
            env.update(next_env)
        return False

    def _unwrap(self, value):
        if self.is_enforcement_wrapper(value):
            return self.original_map[IdentityWrapper(value)]
        elif is_singledispatcher(value):
            return self._transform_singledispatch(value, self._unwrap)
        elif isinstance(value, type):
            self._unwrap_class(value)
        return value

    def _unwrap_class(self, cls: type):
        for method_name, method in list(inspect.getmembers(cls, inspect.isfunction)):
            if self.is_enforcement_wrapper(method):
                setattr(cls, method_name,
                        self.original_map[IdentityWrapper(method)])

    def _wrap_fn(self, fn: Callable, conditions: Optional[Conditions] = None) -> Callable:
        wrapper = self.wrapper_map.get(fn)
        if wrapper is not None:
            return wrapper
        if self.is_enforcement_wrapper(fn):
            return fn

        conditions = conditions or get_fn_conditions(fn)
        if conditions and conditions.has_any():
            wrapper = EnforcementWrapper(
                self.interceptor(fn), conditions, self)
            functools.update_wrapper(wrapper, fn)
        else:
            wrapper = fn
        self.wrapper_map[fn] = wrapper
        self.original_map[IdentityWrapper(wrapper)] = fn
        return wrapper

ebdbde3f9aab4712af471a4a0007a4597db8494d
<mask token>


class EnforcedConditions:

    def __init__(self, *envs, interceptor=lambda x: x):
        self.envs = envs
        self.interceptor = interceptor
        self.fns_enforcing: Optional[Set[Callable]] = set()
        self.wrapper_map: Dict[Callable, Callable] = {}
        self.original_map: Dict[IdentityWrapper[Callable], Callable] = {}
    <mask token>

    def _transform_singledispatch(self, fn, transformer):
        overloads = list(fn.registry.items())
        wrapped = functools.singledispatch(transformer(overloads[0][1]))
        for overload_typ, overload_fn in overloads[1:]:
            wrapped.register(overload_typ)(transformer(overload_fn))
        return wrapped

    def is_enforcement_wrapper(self, value):
        return IdentityWrapper(value) in self.original_map
    <mask token>

    @contextlib.contextmanager
    def disabled_enforcement(self):
        prev = self.fns_enforcing
        assert prev is not None
        self.fns_enforcing = None
        try:
            yield None
        finally:
            self.fns_enforcing = prev

    @contextlib.contextmanager
    def enabled_enforcement(self):
        prev = self.fns_enforcing
        assert prev is None
        self.fns_enforcing = set()
        try:
            yield None
        finally:
            self.fns_enforcing = prev

    def __enter__(self):
        next_envs = [env.copy() for env in self.envs]
        for env, next_env in zip(self.envs, next_envs):
            for k, v in env.items():
                if isinstance(v, (types.FunctionType, types.
                    BuiltinFunctionType)):
                    if is_singledispatcher(v):
                        wrapper = self._transform_singledispatch(v, self.
                            _wrap_fn)
                    else:
                        wrapper = self._wrap_fn(v)
                        if wrapper is v:
                            continue
                    next_env[k] = wrapper
                elif isinstance(v, type):
                    conditions = get_class_conditions(v)
                    if conditions.has_any():
                        self._wrap_class(v, conditions)
        for env, next_env in zip(self.envs, next_envs):
            env.update(next_env)
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        next_envs = [env.copy() for env in self.envs]
        for env, next_env in zip(self.envs, next_envs):
            for k, v in list(env.items()):
                next_env[k] = self._unwrap(v)
        for env, next_env in zip(self.envs, next_envs):
            env.update(next_env)
        return False
    <mask token>

    def _unwrap_class(self, cls: type):
        for method_name, method in list(inspect.getmembers(cls, inspect.
            isfunction)):
            if self.is_enforcement_wrapper(method):
                setattr(cls, method_name, self.original_map[IdentityWrapper
                    (method)])

    def _wrap_fn(self, fn: Callable, conditions: Optional[Conditions]=None
        ) ->Callable:
        wrapper = self.wrapper_map.get(fn)
        if wrapper is not None:
            return wrapper
        if self.is_enforcement_wrapper(fn):
            return fn
        conditions = conditions or get_fn_conditions(fn)
        if conditions and conditions.has_any():
            wrapper = EnforcementWrapper(self.interceptor(fn), conditions, self
                )
            functools.update_wrapper(wrapper, fn)
        else:
            wrapper = fn
        self.wrapper_map[fn] = wrapper
        self.original_map[IdentityWrapper(wrapper)] = fn
        return wrapper

<mask token>


class EnforcedConditions:

    def __init__(self, *envs, interceptor=lambda x: x):
        self.envs = envs
        self.interceptor = interceptor
        self.fns_enforcing: Optional[Set[Callable]] = set()
        self.wrapper_map: Dict[Callable, Callable] = {}
        self.original_map: Dict[IdentityWrapper[Callable], Callable] = {}
    <mask token>

    def _transform_singledispatch(self, fn, transformer):
        overloads = list(fn.registry.items())
        wrapped = functools.singledispatch(transformer(overloads[0][1]))
        for overload_typ, overload_fn in overloads[1:]:
            wrapped.register(overload_typ)(transformer(overload_fn))
        return wrapped

    def is_enforcement_wrapper(self, value):
        return IdentityWrapper(value) in self.original_map

    @contextlib.contextmanager
    def currently_enforcing(self, fn: Callable):
        if self.fns_enforcing is None:
            yield None
        else:
            self.fns_enforcing.add(fn)
            try:
                yield None
            finally:
                self.fns_enforcing.remove(fn)

    @contextlib.contextmanager
    def disabled_enforcement(self):
        prev = self.fns_enforcing
        assert prev is not None
        self.fns_enforcing = None
        try:
            yield None
        finally:
            self.fns_enforcing = prev

    @contextlib.contextmanager
    def enabled_enforcement(self):
        prev = self.fns_enforcing
        assert prev is None
        self.fns_enforcing = set()
        try:
            yield None
        finally:
            self.fns_enforcing = prev

    def __enter__(self):
        next_envs = [env.copy() for env in self.envs]
        for env, next_env in zip(self.envs, next_envs):
            for k, v in env.items():
                if isinstance(v, (types.FunctionType, types.
                    BuiltinFunctionType)):
                    if is_singledispatcher(v):
                        wrapper = self._transform_singledispatch(v, self.
                            _wrap_fn)
                    else:
                        wrapper = self._wrap_fn(v)
                        if wrapper is v:
                            continue
                    next_env[k] = wrapper
                elif isinstance(v, type):
                    conditions = get_class_conditions(v)
                    if conditions.has_any():
                        self._wrap_class(v, conditions)
        for env, next_env in zip(self.envs, next_envs):
            env.update(next_env)
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        next_envs = [env.copy() for env in self.envs]
        for env, next_env in zip(self.envs, next_envs):
            for k, v in list(env.items()):
                next_env[k] = self._unwrap(v)
        for env, next_env in zip(self.envs, next_envs):
            env.update(next_env)
        return False
    <mask token>

    def _unwrap_class(self, cls: type):
        for method_name, method in list(inspect.getmembers(cls, inspect.
            isfunction)):
            if self.is_enforcement_wrapper(method):
                setattr(cls, method_name, self.original_map[IdentityWrapper
                    (method)])

    def _wrap_fn(self, fn: Callable, conditions: Optional[Conditions]=None
        ) ->Callable:
        wrapper = self.wrapper_map.get(fn)
        if wrapper is not None:
            return wrapper
        if self.is_enforcement_wrapper(fn):
            return fn
        conditions = conditions or get_fn_conditions(fn)
        if conditions and conditions.has_any():
            wrapper = EnforcementWrapper(self.interceptor(fn), conditions, self
                )
            functools.update_wrapper(wrapper, fn)
        else:
            wrapper = fn
        self.wrapper_map[fn] = wrapper
        self.original_map[IdentityWrapper(wrapper)] = fn
        return wrapper

<mask token>


class PreconditionFailed(BaseException):
    pass


class PostconditionFailed(BaseException):
    pass


<mask token>


def EnforcementWrapper(fn: Callable, conditions: Conditions, enforced:
    'EnforcedConditions') ->Callable:
    signature = conditions.sig

    def wrapper(*a, **kw):
        fns_enforcing = enforced.fns_enforcing
        if fns_enforcing is None or fn in fns_enforcing:
            return fn(*a, **kw)
        bound_args = signature.bind(*a, **kw)
        bound_args.apply_defaults()
        old = {}
        mutable_args = conditions.mutable_args
        mutable_args_remaining = set(mutable_args
            ) if mutable_args is not None else set()
        for argname, argval in bound_args.arguments.items():
            old[argname] = copy.copy(argval)
            if argname in mutable_args_remaining:
                mutable_args_remaining.remove(argname)
        if mutable_args_remaining:
            raise PostconditionFailed(
                'Unrecognized mutable argument(s) in postcondition: "{}"'.
                format(','.join(mutable_args_remaining)))
        with enforced.currently_enforcing(fn):
            for precondition in conditions.pre:
                args = {**fn_globals(fn), **bound_args.arguments}
                if not eval(precondition.expr, args):
                    raise PreconditionFailed(
                        f'Precondition "{precondition.expr_source}" was not satisfied before calling "{fn.__name__}"'
                        )
        ret = fn(*a, **kw)
        with enforced.currently_enforcing(fn):
            lcls = {**bound_args.arguments, '__return__': ret, '_': ret,
                '__old__': AttributeHolder(old)}
            args = {**fn_globals(fn), **lcls}
            for postcondition in conditions.post:
                if postcondition.expr and not eval(postcondition.expr, args):
                    raise PostconditionFailed('Postcondition failed at {}:{}'
                        .format(postcondition.filename, postcondition.line))
        return ret
    return wrapper


class EnforcedConditions:

    def __init__(self, *envs, interceptor=lambda x: x):
        self.envs = envs
        self.interceptor = interceptor
        self.fns_enforcing: Optional[Set[Callable]] = set()
        self.wrapper_map: Dict[Callable, Callable] = {}
        self.original_map: Dict[IdentityWrapper[Callable], Callable] = {}

    def _wrap_class(self, cls: type, class_conditions: ClassConditions) ->None:
        method_conditions = dict(class_conditions.methods)
        for method_name, method in list(inspect.getmembers(cls, inspect.
            isfunction)):
            conditions = method_conditions.get(method_name)
            if conditions is None:
                continue
            wrapper = self._wrap_fn(method, conditions)
            setattr(cls, method_name, wrapper)

    def _transform_singledispatch(self, fn, transformer):
        overloads = list(fn.registry.items())
        wrapped = functools.singledispatch(transformer(overloads[0][1]))
        for overload_typ, overload_fn in overloads[1:]:
            wrapped.register(overload_typ)(transformer(overload_fn))
        return wrapped

    def is_enforcement_wrapper(self, value):
        return IdentityWrapper(value) in self.original_map

    @contextlib.contextmanager
    def currently_enforcing(self, fn: Callable):
        if self.fns_enforcing is None:
            yield None
        else:
            self.fns_enforcing.add(fn)
            try:
                yield None
            finally:
                self.fns_enforcing.remove(fn)

    @contextlib.contextmanager
    def disabled_enforcement(self):
        prev = self.fns_enforcing
        assert prev is not None
        self.fns_enforcing = None
        try:
            yield None
        finally:
            self.fns_enforcing = prev

    @contextlib.contextmanager
    def enabled_enforcement(self):
        prev = self.fns_enforcing
        assert prev is None
        self.fns_enforcing = set()
        try:
            yield None
        finally:
            self.fns_enforcing = prev

    def __enter__(self):
        next_envs = [env.copy() for env in self.envs]
        for env, next_env in zip(self.envs, next_envs):
            for k, v in env.items():
                if isinstance(v, (types.FunctionType, types.
                    BuiltinFunctionType)):
                    if is_singledispatcher(v):
                        wrapper = self._transform_singledispatch(v, self.
                            _wrap_fn)
                    else:
                        wrapper = self._wrap_fn(v)
                        if wrapper is v:
                            continue
                    next_env[k] = wrapper
                elif isinstance(v, type):
                    conditions = get_class_conditions(v)
                    if conditions.has_any():
                        self._wrap_class(v, conditions)
        for env, next_env in zip(self.envs, next_envs):
            env.update(next_env)
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        next_envs = [env.copy() for env in self.envs]
        for env, next_env in zip(self.envs, next_envs):
            for k, v in list(env.items()):
                next_env[k] = self._unwrap(v)
        for env, next_env in zip(self.envs, next_envs):
            env.update(next_env)
        return False

    def _unwrap(self, value):
        if self.is_enforcement_wrapper(value):
            return self.original_map[IdentityWrapper(value)]
        elif is_singledispatcher(value):
            return self._transform_singledispatch(value, self._unwrap)
        elif isinstance(value, type):
            self._unwrap_class(value)
        return value

    def _unwrap_class(self, cls: type):
        for method_name, method in list(inspect.getmembers(cls, inspect.
            isfunction)):
            if self.is_enforcement_wrapper(method):
                setattr(cls, method_name, self.original_map[IdentityWrapper
                    (method)])

    def _wrap_fn(self, fn: Callable, conditions: Optional[Conditions]=None
        ) ->Callable:
        wrapper = self.wrapper_map.get(fn)
        if wrapper is not None:
            return wrapper
        if self.is_enforcement_wrapper(fn):
            return fn
        conditions = conditions or get_fn_conditions(fn)
        if conditions and conditions.has_any():
            wrapper = EnforcementWrapper(self.interceptor(fn), conditions, self
                )
            functools.update_wrapper(wrapper, fn)
        else:
            wrapper = fn
        self.wrapper_map[fn] = wrapper
        self.original_map[IdentityWrapper(wrapper)] = fn
        return wrapper

import builtins
import contextlib
import copy
import inspect
import functools
import sys
import traceback
import types
from typing import *
from crosshair.condition_parser import Conditions, get_fn_conditions, ClassConditions, get_class_conditions, fn_globals
from crosshair.util import IdentityWrapper, AttributeHolder


class PreconditionFailed(BaseException):
    pass


class PostconditionFailed(BaseException):
    pass


def is_singledispatcher(fn: Callable) ->bool:
    return hasattr(fn, 'registry') and isinstance(fn.registry, Mapping)


def EnforcementWrapper(fn: Callable, conditions: Conditions, enforced:
    'EnforcedConditions') ->Callable:
    signature = conditions.sig

    def wrapper(*a, **kw):
        fns_enforcing = enforced.fns_enforcing
        if fns_enforcing is None or fn in fns_enforcing:
            return fn(*a, **kw)
        bound_args = signature.bind(*a, **kw)
        bound_args.apply_defaults()
        old = {}
        mutable_args = conditions.mutable_args
        mutable_args_remaining = set(mutable_args
            ) if mutable_args is not None else set()
        for argname, argval in bound_args.arguments.items():
            old[argname] = copy.copy(argval)
            if argname in mutable_args_remaining:
                mutable_args_remaining.remove(argname)
        if mutable_args_remaining:
            raise PostconditionFailed(
                'Unrecognized mutable argument(s) in postcondition: "{}"'.
                format(','.join(mutable_args_remaining)))
        with enforced.currently_enforcing(fn):
            for precondition in conditions.pre:
                args = {**fn_globals(fn), **bound_args.arguments}
                if not eval(precondition.expr, args):
                    raise PreconditionFailed(
                        f'Precondition "{precondition.expr_source}" was not satisfied before calling "{fn.__name__}"'
                        )
        ret = fn(*a, **kw)
        with enforced.currently_enforcing(fn):
            lcls = {**bound_args.arguments, '__return__': ret, '_': ret,
                '__old__': AttributeHolder(old)}
            args = {**fn_globals(fn), **lcls}
            for postcondition in conditions.post:
                if postcondition.expr and not eval(postcondition.expr, args):
                    raise PostconditionFailed('Postcondition failed at {}:{}'
                        .format(postcondition.filename, postcondition.line))
        return ret
    return wrapper


class EnforcedConditions:

    def __init__(self, *envs, interceptor=lambda x: x):
        self.envs = envs
        self.interceptor = interceptor
        self.fns_enforcing: Optional[Set[Callable]] = set()
        self.wrapper_map: Dict[Callable, Callable] = {}
        self.original_map: Dict[IdentityWrapper[Callable], Callable] = {}

    def _wrap_class(self, cls: type, class_conditions: ClassConditions) ->None:
        method_conditions = dict(class_conditions.methods)
        for method_name, method in list(inspect.getmembers(cls, inspect.
            isfunction)):
            conditions = method_conditions.get(method_name)
            if conditions is None:
                continue
            wrapper = self._wrap_fn(method, conditions)
            setattr(cls, method_name, wrapper)

    def _transform_singledispatch(self, fn, transformer):
        overloads = list(fn.registry.items())
        wrapped = functools.singledispatch(transformer(overloads[0][1]))
        for overload_typ, overload_fn in overloads[1:]:
            wrapped.register(overload_typ)(transformer(overload_fn))
        return wrapped

    def is_enforcement_wrapper(self, value):
        return IdentityWrapper(value) in self.original_map

    @contextlib.contextmanager
    def currently_enforcing(self, fn: Callable):
        if self.fns_enforcing is None:
            yield None
        else:
            self.fns_enforcing.add(fn)
            try:
                yield None
            finally:
                self.fns_enforcing.remove(fn)

    @contextlib.contextmanager
    def disabled_enforcement(self):
        prev = self.fns_enforcing
        assert prev is not None
        self.fns_enforcing = None
        try:
            yield None
        finally:
            self.fns_enforcing = prev

    @contextlib.contextmanager
    def enabled_enforcement(self):
        prev = self.fns_enforcing
        assert prev is None
        self.fns_enforcing = set()
        try:
            yield None
        finally:
            self.fns_enforcing = prev

    def __enter__(self):
        next_envs = [env.copy() for env in self.envs]
        for env, next_env in zip(self.envs, next_envs):
            for k, v in env.items():
                if isinstance(v, (types.FunctionType, types.
                    BuiltinFunctionType)):
                    if is_singledispatcher(v):
                        wrapper = self._transform_singledispatch(v, self.
                            _wrap_fn)
                    else:
                        wrapper = self._wrap_fn(v)
                        if wrapper is v:
                            continue
                    next_env[k] = wrapper
                elif isinstance(v, type):
                    conditions = get_class_conditions(v)
                    if conditions.has_any():
                        self._wrap_class(v, conditions)
        for env, next_env in zip(self.envs, next_envs):
            env.update(next_env)
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        next_envs = [env.copy() for env in self.envs]
        for env, next_env in zip(self.envs, next_envs):
            for k, v in list(env.items()):
                next_env[k] = self._unwrap(v)
        for env, next_env in zip(self.envs, next_envs):
            env.update(next_env)
        return False

    def _unwrap(self, value):
        if self.is_enforcement_wrapper(value):
            return self.original_map[IdentityWrapper(value)]
        elif is_singledispatcher(value):
            return self._transform_singledispatch(value, self._unwrap)
        elif isinstance(value, type):
            self._unwrap_class(value)
        return value

    def _unwrap_class(self, cls: type):
        for method_name, method in list(inspect.getmembers(cls, inspect.
            isfunction)):
            if self.is_enforcement_wrapper(method):
                setattr(cls, method_name, self.original_map[IdentityWrapper
                    (method)])

    def _wrap_fn(self, fn: Callable, conditions: Optional[Conditions]=None
        ) ->Callable:
        wrapper = self.wrapper_map.get(fn)
        if wrapper is not None:
            return wrapper
        if self.is_enforcement_wrapper(fn):
            return fn
        conditions = conditions or get_fn_conditions(fn)
        if conditions and conditions.has_any():
            wrapper = EnforcementWrapper(self.interceptor(fn), conditions, self
                )
            functools.update_wrapper(wrapper, fn)
        else:
            wrapper = fn
        self.wrapper_map[fn] = wrapper
        self.original_map[IdentityWrapper(wrapper)] = fn
        return wrapper

import builtins
import contextlib
import copy
import inspect
import functools
import sys
import traceback
import types
from typing import *

from crosshair.condition_parser import Conditions, get_fn_conditions, ClassConditions, get_class_conditions, fn_globals
from crosshair.util import IdentityWrapper, AttributeHolder


class PreconditionFailed(BaseException):
    pass


class PostconditionFailed(BaseException):
    pass


def is_singledispatcher(fn: Callable) -> bool:
    return hasattr(fn, 'registry') and isinstance(fn.registry, Mapping)  # type: ignore


def EnforcementWrapper(fn: Callable, conditions: Conditions, enforced: 'EnforcedConditions') -> Callable:
    signature = conditions.sig

    def wrapper(*a, **kw):
        fns_enforcing = enforced.fns_enforcing
        if fns_enforcing is None or fn in fns_enforcing:
            return fn(*a, **kw)
        #print('Calling enforcement wrapper ', fn)
        bound_args = signature.bind(*a, **kw)
        bound_args.apply_defaults()
        old = {}
        mutable_args = conditions.mutable_args
        mutable_args_remaining = set(mutable_args) if mutable_args is not None else set()
        for argname, argval in bound_args.arguments.items():
            old[argname] = copy.copy(argval)
            if argname in mutable_args_remaining:
                mutable_args_remaining.remove(argname)
        if mutable_args_remaining:
            raise PostconditionFailed('Unrecognized mutable argument(s) in postcondition: "{}"'.format(
                ','.join(mutable_args_remaining)))
        with enforced.currently_enforcing(fn):
            for precondition in conditions.pre:
                #print(' precondition eval ', precondition.expr_source)
                args = {**fn_globals(fn), **bound_args.arguments}
                if not eval(precondition.expr, args):
                    raise PreconditionFailed(
                        f'Precondition "{precondition.expr_source}" was not satisfied '
                        f'before calling "{fn.__name__}"')
        ret = fn(*a, **kw)
        with enforced.currently_enforcing(fn):
            lcls = {**bound_args.arguments, '__return__': ret,
                    '_': ret, '__old__': AttributeHolder(old)}
            args = {**fn_globals(fn), **lcls}
            for postcondition in conditions.post:
                #print(' postcondition eval ', postcondition.expr_source, fn, lcls['_'])
                if postcondition.expr and not eval(postcondition.expr, args):
                    raise PostconditionFailed('Postcondition failed at {}:{}'.format(
                        postcondition.filename, postcondition.line))
        #print('Completed enforcement wrapper ', fn)
        return ret
    return wrapper


class EnforcedConditions:
    def __init__(self, *envs, interceptor=lambda x: x):
        self.envs = envs
        self.interceptor = interceptor
        self.fns_enforcing: Optional[Set[Callable]] = set()
        self.wrapper_map: Dict[Callable, Callable] = {}
        self.original_map: Dict[IdentityWrapper[Callable], Callable] = {}

    def _wrap_class(self, cls: type, class_conditions: ClassConditions) -> None:
        #print('wrapping class ', cls)
        method_conditions = dict(class_conditions.methods)
        for method_name, method in list(inspect.getmembers(cls, inspect.isfunction)):
            conditions = method_conditions.get(method_name)
            if conditions is None:
                continue
            wrapper = self._wrap_fn(method, conditions)
            setattr(cls, method_name, wrapper)

    def _transform_singledispatch(self, fn, transformer):
        overloads = list(fn.registry.items())
        wrapped = functools.singledispatch(transformer(overloads[0][1]))
        for overload_typ, overload_fn in overloads[1:]:
            wrapped.register(overload_typ)(transformer(overload_fn))
        return wrapped

    def is_enforcement_wrapper(self, value):
        return IdentityWrapper(value) in self.original_map

    @contextlib.contextmanager
    def currently_enforcing(self, fn: Callable):
        if self.fns_enforcing is None:
            yield None
        else:
            self.fns_enforcing.add(fn)
            try:
                yield None
            finally:
                self.fns_enforcing.remove(fn)

    @contextlib.contextmanager
    def disabled_enforcement(self):
        prev = self.fns_enforcing
        assert prev is not None
        self.fns_enforcing = None
        try:
            yield None
        finally:
            self.fns_enforcing = prev

    @contextlib.contextmanager
    def enabled_enforcement(self):
        prev = self.fns_enforcing
        assert prev is None
        self.fns_enforcing = set()
        try:
            yield None
        finally:
            self.fns_enforcing = prev

    def __enter__(self):
        next_envs = [env.copy() for env in self.envs]
        for env, next_env in zip(self.envs, next_envs):
            for (k, v) in env.items():
                if isinstance(v, (types.FunctionType, types.BuiltinFunctionType)):
                    if is_singledispatcher(v):
                        wrapper = self._transform_singledispatch(
                            v, self._wrap_fn)
                    else:
                        wrapper = self._wrap_fn(v)
                        if wrapper is v:
                            continue
                    next_env[k] = wrapper
                elif isinstance(v, type):
                    conditions = get_class_conditions(v)
                    if conditions.has_any():
                        self._wrap_class(v, conditions)
        for env, next_env in zip(self.envs, next_envs):
            env.update(next_env)
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        next_envs = [env.copy() for env in self.envs]
        for env, next_env in zip(self.envs, next_envs):
            for (k, v) in list(env.items()):
                next_env[k] = self._unwrap(v)
        for env, next_env in zip(self.envs, next_envs):
            env.update(next_env)
        return False

    def _unwrap(self, value):
        if self.is_enforcement_wrapper(value):
            return self.original_map[IdentityWrapper(value)]
        elif is_singledispatcher(value):
            return self._transform_singledispatch(value, self._unwrap)
        elif isinstance(value, type):
            self._unwrap_class(value)
        return value

    def _unwrap_class(self, cls: type):
        for method_name, method in list(inspect.getmembers(cls, inspect.isfunction)):
            if self.is_enforcement_wrapper(method):
                setattr(cls, method_name,
                        self.original_map[IdentityWrapper(method)])

    def _wrap_fn(self, fn: Callable, conditions: Optional[Conditions] = None) -> Callable:
        wrapper = self.wrapper_map.get(fn)
        if wrapper is not None:
            return wrapper
        if self.is_enforcement_wrapper(fn):
            return fn

        conditions = conditions or get_fn_conditions(fn)
        if conditions and conditions.has_any():
            wrapper = EnforcementWrapper(
                self.interceptor(fn), conditions, self)
            functools.update_wrapper(wrapper, fn)
        else:
            wrapper = fn
        self.wrapper_map[fn] = wrapper
        self.original_map[IdentityWrapper(wrapper)] = fn
        return wrapper
