def __iter__(self):
_coconut_yield_from_1 = _coconut.iter(self.registered)
while True:
try:
yield _coconut.next(_coconut_yield_from_1)
except _coconut.StopIteration as _coconut_yield_err_0:
_coconut_yield_from_0 = _coconut_yield_err_0.args[
0] if _coconut.len(_coconut_yield_err_0.args) > 0 else None
break
_coconut_yield_from_0
_coconut_yield_from_3 = _coconut.iter(self.generators)
while True:
try:
yield _coconut.next(_coconut_yield_from_3)
except _coconut.StopIteration as _coconut_yield_err_1:
_coconut_yield_from_2 = _coconut_yield_err_1.args[
0] if _coconut.len(_coconut_yield_err_1.args) > 0 else None
break
_coconut_yield_from_2
_coconut_yield_from_5 = _coconut.iter(self.aliases)
while True:
try:
yield _coconut.next(_coconut_yield_from_5)
except _coconut.StopIteration as _coconut_yield_err_2:
_coconut_yield_from_4 = _coconut_yield_err_2.args[
0] if _coconut.len(_coconut_yield_err_2.args) > 0 else None
break
_coconut_yield_from_4
def __iter__(self):
_coconut_yield_from = _coconut.iter(self.registered)
while True:
try:
yield _coconut.next(_coconut_yield_from)
except _coconut.StopIteration as _coconut_yield_err:
_coconut_yield_from_0 = _coconut_yield_err.args[0] if _coconut.len(_coconut_yield_err.args) > 0 else None
break
_coconut_yield_from_0
_coconut_yield_from = _coconut.iter(self.generators)
while True:
try:
yield _coconut.next(_coconut_yield_from)
except _coconut.StopIteration as _coconut_yield_err:
_coconut_yield_from_1 = _coconut_yield_err.args[0] if _coconut.len(_coconut_yield_err.args) > 0 else None
break
_coconut_yield_from_1
_coconut_yield_from = _coconut.iter(self.aliases)
while True:
try:
yield _coconut.next(_coconut_yield_from)
except _coconut.StopIteration as _coconut_yield_err:
_coconut_yield_from_2 = _coconut_yield_err.args[0] if _coconut.len(_coconut_yield_err.args) > 0 else None
break
_coconut_yield_from_2
def __init__(*_coconut_match_args, **_coconut_match_kwargs):
"""
Construct a new BlackBoxOptimizer. You must either pass file=__file__ or
both data_dir="/path/to/some/dir" and data_name="my_project_name".
"""
_coconut_match_check_1 = False
_coconut_match_set_name_self = _coconut_sentinel
_coconut_match_set_name_data_dir = _coconut_sentinel
_coconut_match_set_name_data_name = _coconut_sentinel
_coconut_match_set_name_kwargs = _coconut_sentinel
_coconut_FunctionMatchError = _coconut_get_function_match_error()
if (_coconut.len(_coconut_match_args) <= 3) and (_coconut.sum((_coconut.len(_coconut_match_args) > 0, "self" in _coconut_match_kwargs)) == 1) and (_coconut.sum((_coconut.len(_coconut_match_args) > 1, "data_dir" in _coconut_match_kwargs)) == 1) and (_coconut.sum((_coconut.len(_coconut_match_args) > 2, "data_name" in _coconut_match_kwargs)) == 1):
_coconut_match_temp_0 = _coconut_match_args[0] if _coconut.len(_coconut_match_args) > 0 else _coconut_match_kwargs.pop("self")
_coconut_match_temp_1 = _coconut_match_args[1] if _coconut.len(_coconut_match_args) > 1 else _coconut_match_kwargs.pop("data_dir")
_coconut_match_temp_2 = _coconut_match_args[2] if _coconut.len(_coconut_match_args) > 2 else _coconut_match_kwargs.pop("data_name")
if ((isinstance)(_coconut_match_temp_1, Str)) and ((isinstance)(_coconut_match_temp_2, Str)):
_coconut_match_set_name_self = _coconut_match_temp_0
_coconut_match_set_name_data_dir = _coconut_match_temp_1
_coconut_match_set_name_data_name = _coconut_match_temp_2
_coconut_match_set_name_kwargs = _coconut_match_kwargs
_coconut_match_check_1 = True
if _coconut_match_check_1:
if _coconut_match_set_name_self is not _coconut_sentinel:
self = _coconut_match_temp_0
if _coconut_match_set_name_data_dir is not _coconut_sentinel:
data_dir = _coconut_match_temp_1
if _coconut_match_set_name_data_name is not _coconut_sentinel:
data_name = _coconut_match_temp_2
if _coconut_match_set_name_kwargs is not _coconut_sentinel:
kwargs = _coconut_match_kwargs
if not _coconut_match_check_1:
raise _coconut_FunctionMatchError('addpattern def __init__(self, data_dir `isinstance` Str, data_name `isinstance` Str, **kwargs):', _coconut_match_args)
self.__init__(os.path.join(data_dir, data_name), **kwargs)
def init_backend(*_coconut_match_to_args, **_coconut_match_to_kwargs):
"""Create a backend object of the given name with the given data."""
_coconut_match_check = False
_coconut_FunctionMatchError = _coconut_get_function_match_error()
if (_coconut.sum((_coconut.len(_coconut_match_to_args) > 0, "name" in _coconut_match_to_kwargs)) == 1) and (_coconut.sum((_coconut.len(_coconut_match_to_args) > 1, "examples" in _coconut_match_to_kwargs)) == 1) and (_coconut.sum((_coconut.len(_coconut_match_to_args) > 2, "params" in _coconut_match_to_kwargs)) == 1):
_coconut_match_temp_0 = _coconut_match_to_args[0] if _coconut.len(_coconut_match_to_args) > 0 else _coconut_match_to_kwargs.pop("name")
_coconut_match_temp_1 = _coconut_match_to_args[1] if _coconut.len(_coconut_match_to_args) > 1 else _coconut_match_to_kwargs.pop("examples")
_coconut_match_temp_2 = _coconut_match_to_args[2] if _coconut.len(_coconut_match_to_args) > 2 else _coconut_match_to_kwargs.pop("params")
args = _coconut_match_to_args[3:]
_coconut_match_temp_3 = _coconut_match_to_kwargs.pop("attempt_to_update_backend") if "attempt_to_update_backend" in _coconut_match_to_kwargs else None
name = _coconut_match_temp_0
examples = _coconut_match_temp_1
params = _coconut_match_temp_2
attempt_to_update_backend = _coconut_match_temp_3
options = _coconut_match_to_kwargs
_coconut_match_check = True
if not _coconut_match_check:
raise _coconut_FunctionMatchError('match def init_backend(name, examples, params, *args, attempt_to_update_backend=None, **options):', _coconut_match_to_args)
backend_cls = backend_registry[name]
if attempt_to_update_backend is not None and isinstance(attempt_to_update_backend, backend_cls):
updated_backend = attempt_to_update_backend.attempt_update(examples, params, *args, **options)
if updated_backend is True:
return attempt_to_update_backend
elif isinstance(updated_backend, backend_cls):
return updated_backend
else:
assert updated_backend is False, "invalid backend.attempt_update return value {_coconut_format_0} from {_coconut_format_1}".format(_coconut_format_0=(updated_backend), _coconut_format_1=(backend_cls))
return backend_cls(examples, params, *args, **options)
def __init__(*_coconut_match_to_args, **_coconut_match_to_kwargs):
"""Construct a new BlackBoxOptimizer. It is recommended to pass file=__file__."""
_coconut_match_check = False
_coconut_FunctionMatchError = _coconut_get_function_match_error()
if (_coconut.len(_coconut_match_to_args) <= 2) and (_coconut.sum((_coconut.len(_coconut_match_to_args) > 0, "self" in _coconut_match_to_kwargs)) == 1) and (_coconut.sum((_coconut.len(_coconut_match_to_args) > 1, "file" in _coconut_match_to_kwargs)) == 1):
_coconut_match_temp_0 = _coconut_match_to_args[0] if _coconut.len(_coconut_match_to_args) > 0 else _coconut_match_to_kwargs.pop("self")
_coconut_match_temp_1 = _coconut_match_to_args[1] if _coconut.len(_coconut_match_to_args) > 1 else _coconut_match_to_kwargs.pop("file")
_coconut_match_temp_2 = _coconut_match_to_kwargs.pop("tag") if "tag" in _coconut_match_to_kwargs else None
_coconut_match_temp_3 = _coconut_match_to_kwargs.pop("protocol") if "protocol" in _coconut_match_to_kwargs else None
if not _coconut_match_to_kwargs:
self = _coconut_match_temp_0
file = _coconut_match_temp_1
tag = _coconut_match_temp_2
protocol = _coconut_match_temp_3
_coconut_match_check = True
if not _coconut_match_check:
raise _coconut_FunctionMatchError('match def __init__(self, file, *, tag=None, protocol=None):', _coconut_match_to_args)
if not isinstance(file, Str):
raise TypeError("file must be a string")
self._file = norm_path(file)
self._tag = tag
if protocol is None:
# auto-detect protocol
self._protocol = "json"
if not os.path.exists(self.data_file):
self._protocol = default_protocol
else:
self._protocol = protocol
self.reload()
def sieve(*_coconut_match_to_args, **_coconut_match_to_kwargs):
_coconut_match_check = False
if (_coconut.len(_coconut_match_to_args)
== 1) and (_coconut.isinstance(_coconut_match_to_args[0],
_coconut.abc.Iterable)):
xs = _coconut.iter(_coconut_match_to_args[0])
_coconut_match_temp_0 = _coconut.tuple(
_coconut_igetitem(xs, _coconut.slice(None, 1)))
if (_coconut.len(_coconut_match_temp_0)
== 1) and (not _coconut_match_to_kwargs):
x = _coconut_match_temp_0[0]
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_err = _coconut_MatchError(
"pattern-matching failed for "
"'def sieve([x] :: xs) = [x] :: sieve(n for n in xs if n % x)'"
" in " + _coconut.repr(_coconut.repr(_coconut_match_to_args)))
_coconut_match_err.pattern = 'def sieve([x] :: xs) = [x] :: sieve(n for n in xs if n % x)'
_coconut_match_err.value = _coconut_match_to_args
raise _coconut_match_err
return _coconut_tail_call(
_coconut.itertools.chain.from_iterable,
(f()
for f in (lambda: [x], lambda: sieve((n for n in xs if n % x)))))
def _coconut_lambda_0(*_coconut_match_args,
**_coconut_match_kwargs):
_coconut_match_check_0 = False
_coconut_match_set_name_val = _coconut_sentinel
_coconut_match_set_name_loss = _coconut_sentinel
_coconut_FunctionMatchError = _coconut_get_function_match_error(
)
if _coconut.len(_coconut_match_args) == 1:
if (_coconut.isinstance(
_coconut_match_args[0],
_coconut.abc.Sequence)) and (_coconut.len(
_coconut_match_args[0]) == 2):
_coconut_match_set_name_val = _coconut_match_args[0][0]
_coconut_match_set_name_loss = _coconut_match_args[0][
1]
if not _coconut_match_kwargs:
_coconut_match_check_0 = True
if _coconut_match_check_0:
if _coconut_match_set_name_val is not _coconut_sentinel:
val = _coconut_match_set_name_val
if _coconut_match_set_name_loss is not _coconut_sentinel:
loss = _coconut_match_set_name_loss
if not _coconut_match_check_0:
raise _coconut_FunctionMatchError(
'best_val, min_loss = min(marginals, key=def ((val, loss)) -> loss)',
_coconut_match_args)
return loss
def __init__(*_coconut_match_args, **_coconut_match_kwargs):
_coconut_match_check_0 = False
_coconut_match_set_name_self = _coconut_sentinel
_coconut_match_set_name_file = _coconut_sentinel
_coconut_match_set_name_tag = _coconut_sentinel
_coconut_match_set_name_protocol = _coconut_sentinel
_coconut_FunctionMatchError = _coconut_get_function_match_error()
if (_coconut.len(_coconut_match_args) <= 2) and (_coconut.sum(
(_coconut.len(_coconut_match_args) > 0, "self"
in _coconut_match_kwargs)) == 1) and (_coconut.sum(
(_coconut.len(_coconut_match_args) > 1, "file"
in _coconut_match_kwargs)) == 1):
_coconut_match_temp_2 = _coconut_match_kwargs.pop(
"tag") if "tag" in _coconut_match_kwargs else None
_coconut_match_temp_3 = _coconut_match_kwargs.pop(
"protocol") if "protocol" in _coconut_match_kwargs else None
_coconut_match_temp_0 = _coconut_match_args[0] if _coconut.len(
_coconut_match_args) > 0 else _coconut_match_kwargs.pop("self")
_coconut_match_temp_1 = _coconut_match_args[1] if _coconut.len(
_coconut_match_args) > 1 else _coconut_match_kwargs.pop("file")
_coconut_match_set_name_tag = _coconut_match_temp_2
_coconut_match_set_name_protocol = _coconut_match_temp_3
if (isinstance)(_coconut_match_temp_1, Str):
_coconut_match_set_name_self = _coconut_match_temp_0
_coconut_match_set_name_file = _coconut_match_temp_1
if not _coconut_match_kwargs:
_coconut_match_check_0 = True
if _coconut_match_check_0:
if _coconut_match_set_name_self is not _coconut_sentinel:
self = _coconut_match_set_name_self
if _coconut_match_set_name_file is not _coconut_sentinel:
file = _coconut_match_set_name_file
if _coconut_match_set_name_tag is not _coconut_sentinel:
tag = _coconut_match_set_name_tag
if _coconut_match_set_name_protocol is not _coconut_sentinel:
protocol = _coconut_match_set_name_protocol
if not _coconut_match_check_0:
raise _coconut_FunctionMatchError(
'match def __init__(self, file `isinstance` Str, *, tag=None, protocol=None):',
_coconut_match_args)
self._backend_creation_counts = defaultdict(int)
self._file = norm_path(file)
self._tag = tag
if protocol is None:
# auto-detect protocol
self.protocol = "json"
if not os.path.exists(self.data_file):
self.protocol = constants.default_protocol
else:
self.protocol = protocol
self.reload()
def forall_handle(*_coconut_match_args, **_coconut_match_kwargs):
_coconut_match_check_2 = False
_coconut_FunctionMatchError = _coconut_get_function_match_error()
if (_coconut.len(_coconut_match_args) <= 2) and (_coconut.sum((_coconut.len(_coconut_match_args) > 0, "const" in _coconut_match_kwargs)) == 1) and (_coconut.sum((_coconut.len(_coconut_match_args) > 1, "expr" in _coconut_match_kwargs)) == 1):
_coconut_match_temp_0 = _coconut_match_args[0] if _coconut.len(_coconut_match_args) > 0 else _coconut_match_kwargs.pop("const")
_coconut_match_temp_1 = _coconut_match_args[1] if _coconut.len(_coconut_match_args) > 1 else _coconut_match_kwargs.pop("expr")
if not _coconut_match_kwargs:
const = _coconut_match_temp_0
expr = _coconut_match_temp_1
_coconut_match_check_2 = True
if not _coconut_match_check_2:
raise _coconut_FunctionMatchError('match def forall_handle(const, expr) = ForAll(const, expr)', _coconut_match_args)
return _coconut_tail_call(ForAll, const, expr)
def forall_handle(*_coconut_match_args, **_coconut_match_kwargs):
_coconut_match_check_3 = False
_coconut_FunctionMatchError = _coconut_get_function_match_error()
if (_coconut.len(_coconut_match_args) <= 3) and (_coconut.sum((_coconut.len(_coconut_match_args) > 0, "const" in _coconut_match_kwargs)) == 1) and (_coconut.sum((_coconut.len(_coconut_match_args) > 1, "prop" in _coconut_match_kwargs)) == 1) and (_coconut.sum((_coconut.len(_coconut_match_args) > 2, "expr" in _coconut_match_kwargs)) == 1):
_coconut_match_temp_0 = _coconut_match_args[0] if _coconut.len(_coconut_match_args) > 0 else _coconut_match_kwargs.pop("const")
_coconut_match_temp_1 = _coconut_match_args[1] if _coconut.len(_coconut_match_args) > 1 else _coconut_match_kwargs.pop("prop")
_coconut_match_temp_2 = _coconut_match_args[2] if _coconut.len(_coconut_match_args) > 2 else _coconut_match_kwargs.pop("expr")
if not _coconut_match_kwargs:
const = _coconut_match_temp_0
prop = _coconut_match_temp_1
expr = _coconut_match_temp_2
_coconut_match_check_3 = True
if not _coconut_match_check_3:
raise _coconut_FunctionMatchError('match def forall_handle(const, prop, expr) =', _coconut_match_args)
return _coconut_tail_call(ForAll, const, prop(const) >> expr)
def test_match_error_addpattern(*_coconut_match_to_args, **_coconut_match_to_kwargs):
_coconut_match_check = False
_coconut_FunctionMatchError = _coconut_get_function_match_error()
if (_coconut.len(_coconut_match_to_args) <= 1) and (_coconut.sum((_coconut.len(_coconut_match_to_args) > 0, "x" in _coconut_match_to_kwargs)) == 1):
_coconut_match_temp_0 = _coconut_match_to_args[0] if _coconut.len(_coconut_match_to_args) > 0 else _coconut_match_to_kwargs.pop("x")
if (_coconut.isinstance(_coconut_match_temp_0, int)) and (not _coconut_match_to_kwargs):
x = _coconut_match_temp_0
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_val_repr = _coconut.repr(_coconut_match_to_args)
_coconut_match_err = _coconut_FunctionMatchError("pattern-matching failed for " "'def test_match_error_addpattern(x is int): raise MatchError()'" " in " + (_coconut_match_val_repr if _coconut.len(_coconut_match_val_repr) <= 500 else _coconut_match_val_repr[:500] + "..."))
_coconut_match_err.pattern = 'def test_match_error_addpattern(x is int): raise MatchError()'
_coconut_match_err.value = _coconut_match_to_args
raise _coconut_match_err
raise MatchError()
def angle(*_coconut_match_to_args, **_coconut_match_to_kwargs):
_coconut_match_check = False
_coconut_FunctionMatchError = _coconut_get_function_match_error()
if (_coconut.len(_coconut_match_to_args) <= 2) and (_coconut.sum((_coconut.len(_coconut_match_to_args) > 0, "self" in _coconut_match_to_kwargs)) == 1) and (_coconut.sum((_coconut.len(_coconut_match_to_args) > 1, "other" in _coconut_match_to_kwargs)) == 1):
_coconut_match_temp_0 = _coconut_match_to_args[0] if _coconut.len(_coconut_match_to_args) > 0 else _coconut_match_to_kwargs.pop("self")
_coconut_match_temp_1 = _coconut_match_to_args[1] if _coconut.len(_coconut_match_to_args) > 1 else _coconut_match_to_kwargs.pop("other")
if (_coconut.isinstance(_coconut_match_temp_1, vector)) and (not _coconut_match_to_kwargs):
self = _coconut_match_temp_0
other = _coconut_match_temp_1
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_val_repr = _coconut.repr(_coconut_match_to_args)
_coconut_match_err = _coconut_FunctionMatchError("pattern-matching failed for " "'def angle(self, other is vector) = math.acos(self.unit() * other.unit())'" " in " + (_coconut_match_val_repr if _coconut.len(_coconut_match_val_repr) <= 500 else _coconut_match_val_repr[:500] + "..."))
_coconut_match_err.pattern = 'def angle(self, other is vector) = math.acos(self.unit() * other.unit())'
_coconut_match_err.value = _coconut_match_to_args
raise _coconut_match_err
return _coconut_tail_call(math.acos, self.unit() * other.unit())
def factorial(*_coconut_match_to_args, **_coconut_match_to_kwargs):
"""Compute n! where n is an integer >= 0."""
_coconut_match_check = False
_coconut_FunctionMatchError = _coconut_get_function_match_error()
if (_coconut.len(_coconut_match_to_args) <= 1) and (_coconut.sum((_coconut.len(_coconut_match_to_args) > 0, "n" in _coconut_match_to_kwargs)) == 1):
_coconut_match_temp_0 = _coconut_match_to_args[0] if _coconut.len(_coconut_match_to_args) > 0 else _coconut_match_to_kwargs.pop("n")
if (_coconut.isinstance(_coconut_match_temp_0, int)) and (not _coconut_match_to_kwargs):
n = _coconut_match_temp_0
_coconut_match_check = True
if _coconut_match_check and not (n > 0):
_coconut_match_check = False
if not _coconut_match_check:
_coconut_match_val_repr = _coconut.repr(_coconut_match_to_args)
_coconut_match_err = _coconut_FunctionMatchError("pattern-matching failed for " "'def factorial(n is int if n > 0) ='" " in " + (_coconut_match_val_repr if _coconut.len(_coconut_match_val_repr) <= 500 else _coconut_match_val_repr[:500] + "..."))
_coconut_match_err.pattern = 'def factorial(n is int if n > 0) ='
_coconut_match_err.value = _coconut_match_to_args
raise _coconut_match_err
return n * factorial(n - 1)
def __eq__(self, other):
"""Compare whether two vectors are equal."""
_coconut_match_check = False
_coconut_match_to = other
if (_coconut.isinstance(_coconut_match_to, vector)) and (_coconut.len(_coconut_match_to) == 1) and (_coconut_match_to[0] == self.pts):
_coconut_match_check = True
if _coconut_match_check:
return True
else:
return False
def __iter__(self):
_coconut_yield_from_1 = _coconut.iter(self.new_list)
while True:
try:
yield _coconut.next(_coconut_yield_from_1)
except _coconut.StopIteration as _coconut_yield_err_0:
_coconut_yield_from_0 = _coconut_yield_err_0.args[0] if _coconut.len(_coconut_yield_err_0.args) > 0 else None
break
_coconut_yield_from_0
def __iter__(self):
_coconut_yield_from_3 = _coconut.iter(self.new_dict)
while True:
try:
yield _coconut.next(_coconut_yield_from_3)
except _coconut.StopIteration as _coconut_yield_err_1:
_coconut_yield_from_2 = _coconut_yield_err_1.args[0] if _coconut.len(_coconut_yield_err_1.args) > 0 else None
break
_coconut_yield_from_2
def __new__(cls, *pts):
"""Create a new vector from the given pts."""
_coconut_match_to = pts
_coconut_match_check = False
if (_coconut.isinstance(_coconut_match_to, _coconut.abc.Sequence)) and (_coconut.len(_coconut_match_to) == 1) and (_coconut.isinstance(_coconut_match_to[0], vector)):
v = _coconut_match_to[0]
_coconut_match_check = True
if _coconut_match_check:
return v # vector(v) where v is a vector should return v
else:
return _coconut_tail_call(makedata, cls, *pts) # accesses base constructor
def mean(*_coconut_match_args, **_coconut_match_kwargs):
_coconut_match_check_0 = False
_coconut_FunctionMatchError = _coconut_get_function_match_error()
if (_coconut.len(_coconut_match_args) == 1) and (_coconut.isinstance(_coconut_match_args[0], _coconut.abc.Sequence)) and (_coconut.len(_coconut_match_args[0]) >= 0):
xs = _coconut.list(_coconut_match_args[0])
if not _coconut_match_kwargs:
_coconut_match_check_0 = True
if not _coconut_match_check_0:
raise _coconut_FunctionMatchError('match def mean([] + xs) =', _coconut_match_args)
return sum(xs) / len(xs)
def quick_sort(*_coconut_match_to):
_coconut_match_check = False
if (_coconut.len(_coconut_match_to) == 1) and (_coconut.isinstance(_coconut_match_to[0], _coconut.abc.Sequence)) and (_coconut.len(_coconut_match_to[0]) == 0):
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_err = _coconut_MatchError("pattern-matching failed for " "'def quick_sort([]) = []'" " in " + _coconut.repr(_coconut.repr(_coconut_match_to)))
_coconut_match_err.pattern = 'def quick_sort([]) = []'
_coconut_match_err.value = _coconut_match_to
raise _coconut_match_err
return []
def factorial(*_coconut_match_to):
_coconut_match_check = False
if (_coconut.len(_coconut_match_to) == 1) and (_coconut_match_to[0] == 0):
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_err = _coconut_MatchError("pattern-matching failed for " "'def factorial(0) = 1'" " in " + _coconut.repr(_coconut.repr(_coconut_match_to)))
_coconut_match_err.pattern = 'def factorial(0) = 1'
_coconut_match_err.value = _coconut_match_to
raise _coconut_match_err
return 1
def __sub__(*_coconut_match_to_args, **_coconut_match_to_kwargs):
"""Subtract one vector from another."""
_coconut_match_check = False
_coconut_FunctionMatchError = _coconut_get_function_match_error()
if (_coconut.len(_coconut_match_to_args) == 2) and ("self" not in _coconut_match_to_kwargs) and (_coconut.isinstance(_coconut_match_to_args[1], vector)):
_coconut_match_temp_0 = _coconut_match_to_args[0] if _coconut.len(_coconut_match_to_args) > 0 else _coconut_match_to_kwargs.pop("self")
other_pts = _coconut_match_to_args[1][0:]
if not _coconut_match_to_kwargs:
self = _coconut_match_temp_0
_coconut_match_check = True
if _coconut_match_check and not (len(other_pts) == len(self.pts)):
_coconut_match_check = False
if not _coconut_match_check:
_coconut_match_val_repr = _coconut.repr(_coconut_match_to_args)
_coconut_match_err = _coconut_FunctionMatchError("pattern-matching failed for " "'def __sub__(self, vector(*other_pts) if len(other_pts) == len(self.pts)) ='" " in " + (_coconut_match_val_repr if _coconut.len(_coconut_match_val_repr) <= 500 else _coconut_match_val_repr[:500] + "..."))
_coconut_match_err.pattern = 'def __sub__(self, vector(*other_pts) if len(other_pts) == len(self.pts)) ='
_coconut_match_err.value = _coconut_match_to_args
raise _coconut_match_err
return _coconut_tail_call((vector), *map(_coconut_minus, self.pts, other_pts))
def __mul__(self, other):
"""Scalar multiplication and dot product."""
_coconut_match_check = False
_coconut_match_to = other
if (_coconut.isinstance(_coconut_match_to, vector)) and (_coconut.len(_coconut_match_to) == 1):
other_pts = _coconut_match_to[0]
_coconut_match_check = True
if _coconut_match_check:
assert len(other_pts) == len(self.pts)
raise _coconut_tail_call((sum), map(_coconut.operator.mul, self.pts, other_pts)) # dot product
else:
raise _coconut_tail_call((vector), *map(_coconut.functools.partial(_coconut.operator.mul, other), self.pts)) # scalar multiplication
def mean(*_coconut_match_args, **_coconut_match_kwargs):
"""Compute the arithmetic mean of the given sequence."""
_coconut_match_check_1 = False
_coconut_FunctionMatchError = _coconut_get_function_match_error()
if (_coconut.len(_coconut_match_args) == 1) and (_coconut.isinstance(_coconut_match_args[0], _coconut.abc.Iterable)):
xs = _coconut_match_args[0]
if not _coconut_match_kwargs:
_coconut_match_check_1 = True
if not _coconut_match_check_1:
raise _coconut_FunctionMatchError('addpattern def mean(() :: xs) =', _coconut_match_args)
return (mean)((tuple)(xs))
def items(self):
"""Get all items in the registry as (name, value) pairs."""
self.run_all_gens()
_coconut_yield_from = _coconut.iter(self.registered.items())
while True:
try:
yield _coconut.next(_coconut_yield_from)
except _coconut.StopIteration as _coconut_yield_err:
_coconut_yield_from_3 = _coconut_yield_err.args[0] if _coconut.len(_coconut_yield_err.args) > 0 else None
break
_coconut_yield_from_3
def _coconut_lambda_18(*_coconut_match_to):
_coconut_match_check = False
if (_coconut.len(_coconut_match_to) == 1) and (_coconut.isinstance(_coconut_match_to[0], _coconut.abc.Sequence)) and (_coconut.len(_coconut_match_to[0]) >= 1):
xs = _coconut.list(_coconut_match_to[0][1:])
x = _coconut_match_to[0][0]
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_err = _coconut_MatchError("pattern-matching failed for " "'assert (def ([x] + xs) -> x, xs) <| range(5) == (0, [1,2,3,4])'" " in " + _coconut.repr(_coconut.repr(_coconut_match_to)))
_coconut_match_err.pattern = 'assert (def ([x] + xs) -> x, xs) <| range(5) == (0, [1,2,3,4])'
_coconut_match_err.value = _coconut_match_to
raise _coconut_match_err
return x, xs
def forall_handle(*_coconut_match_to_args, **_coconut_match_to_kwargs):
_coconut_match_check = False
_coconut_FunctionMatchError = _coconut_get_function_match_error()
if (_coconut.len(_coconut_match_to_args) <= 2) and (_coconut.sum(
(_coconut.len(_coconut_match_to_args) > 0, "const"
in _coconut_match_to_kwargs)) == 1) and (_coconut.sum(
(_coconut.len(_coconut_match_to_args) > 1, "expr"
in _coconut_match_to_kwargs)) == 1):
_coconut_match_temp_0 = _coconut_match_to_args[0] if _coconut.len(
_coconut_match_to_args) > 0 else _coconut_match_to_kwargs.pop(
"const")
_coconut_match_temp_1 = _coconut_match_to_args[1] if _coconut.len(
_coconut_match_to_args) > 1 else _coconut_match_to_kwargs.pop(
"expr")
if not _coconut_match_to_kwargs:
const = _coconut_match_temp_0
expr = _coconut_match_temp_1
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_val_repr = _coconut.repr(_coconut_match_to_args)
_coconut_match_err = _coconut_FunctionMatchError(
"pattern-matching failed for "
"'match def forall_handle(const, expr) = ForAll(const, expr)'"
" in " +
(_coconut_match_val_repr if _coconut.len(_coconut_match_val_repr)
<= 500 else _coconut_match_val_repr[:500] + "..."))
_coconut_match_err.pattern = 'match def forall_handle(const, expr) = ForAll(const, expr)'
_coconut_match_err.value = _coconut_match_to_args
raise _coconut_match_err
return _coconut_tail_call(ForAll, const, expr)
def param(self, name, func, *args, **kwargs):
"""Create a black box parameter and return its value."""
if self._got_reward:
raise ValueError(
"all parameter definitions must come before maximize/minimize")
if not isinstance(name, Str):
raise TypeError(
"name must be a string, not {_coconut_format_0}".format(
_coconut_format_0=(name)))
if name in self._new_params:
raise ValueError(
"parameter of name {_coconut_format_0} already exists".format(
_coconut_format_0=(name)))
args = param_processor.standardize_args(func, args)
kwargs = param_processor.standardize_kwargs(kwargs)
_coconut_match_to_1 = self._old_params
_coconut_match_check_3 = False
_coconut_match_set_name_old_func = _coconut_sentinel
_coconut_match_set_name_old_args = _coconut_sentinel
_coconut_match_set_name_old_kwargs = _coconut_sentinel
if _coconut.isinstance(_coconut_match_to_1, _coconut.abc.Mapping):
_coconut_match_temp_9 = _coconut_match_to_1.get(
name, _coconut_sentinel)
if (_coconut_match_temp_9
is not _coconut_sentinel) and (_coconut.isinstance(
_coconut_match_temp_9, _coconut.abc.Sequence)) and (
_coconut.len(_coconut_match_temp_9) == 3):
_coconut_match_set_name_old_func = _coconut_match_temp_9[0]
_coconut_match_set_name_old_args = _coconut_match_temp_9[1]
_coconut_match_set_name_old_kwargs = _coconut_match_temp_9[2]
_coconut_match_check_3 = True
if _coconut_match_check_3:
if _coconut_match_set_name_old_func is not _coconut_sentinel:
old_func = _coconut_match_set_name_old_func
if _coconut_match_set_name_old_args is not _coconut_sentinel:
old_args = _coconut_match_set_name_old_args
if _coconut_match_set_name_old_kwargs is not _coconut_sentinel:
old_kwargs = _coconut_match_set_name_old_kwargs
if _coconut_match_check_3:
if (func, args) != (old_func, old_args):
printerr(
"BBopt Warning: detected change in parameter {_coconut_format_0} ({_coconut_format_1} != {_coconut_format_2}) (you may need to delete your old BBopt data)"
.format(_coconut_format_0=(name),
_coconut_format_1=((func, args)),
_coconut_format_2=((old_func, old_args))))
value = self.backend.param(name, func, *args, **kwargs)
self._new_params[name] = (func, args, kwargs)
self._current_example["values"][name] = value
return value
def run_sess_with_opt(sess, opt, outputs=[], feed_dict={}):
"""Run a session including the given optimizer but excluding its output."""
_coconut_match_to = sess.run([opt] + outputs, feed_dict=feed_dict)
_coconut_match_check = False
if (_coconut.isinstance(
_coconut_match_to,
_coconut.abc.Sequence)) and (_coconut.len(_coconut_match_to) >= 1):
results = _coconut.list(_coconut_match_to[1:])
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_val_repr = _coconut.repr(_coconut_match_to)
_coconut_match_err = _coconut_MatchError(
"pattern-matching failed for "
"'[_] + results = sess.run([opt] + outputs, feed_dict=feed_dict)'"
" in " +
(_coconut_match_val_repr if _coconut.len(_coconut_match_val_repr)
<= 500 else _coconut_match_val_repr[:500] + "..."))
_coconut_match_err.pattern = '[_] + results = sess.run([opt] + outputs, feed_dict=feed_dict)'
_coconut_match_err.value = _coconut_match_to
raise _coconut_match_err
return results
async def async_map_4(*_coconut_match_to):
_coconut_match_check = False
if (_coconut.len(_coconut_match_to) == 1) and (_coconut.isinstance(_coconut_match_to[0], _coconut.abc.Sequence)) and (_coconut.len(_coconut_match_to[0]) >= 1):
iters = _coconut.list(_coconut_match_to[0][1:])
func = _coconut_match_to[0][0]
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_err = _coconut_MatchError("pattern-matching failed for " "'match async def async_map_4([func] + iters) = parallel_map(func, *iters)'" " in " + _coconut.repr(_coconut.repr(_coconut_match_to)))
_coconut_match_err.pattern = 'match async def async_map_4([func] + iters) = parallel_map(func, *iters)'
_coconut_match_err.value = _coconut_match_to
raise _coconut_match_err
return parallel_map(func, *iters)
def repeat(iterable):
"""Infinitely repeat the given iterable."""
while True:
_coconut_yield_from_1 = _coconut.iter(iterable)
while True:
try:
yield _coconut.next(_coconut_yield_from_1)
except _coconut.StopIteration as _coconut_yield_err_0:
_coconut_yield_from_0 = _coconut_yield_err_0.args[
0] if _coconut.len(_coconut_yield_err_0.args) > 0 else None
break
_coconut_yield_from_0
def angle(*_coconut_match_to):
_coconut_match_check = False
if (_coconut.len(_coconut_match_to) == 2) and (_coconut.isinstance(_coconut_match_to[1], vector)):
self = _coconut_match_to[0]
other = _coconut_match_to[1]
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_err = _coconut_MatchError("pattern-matching failed for " "'def angle(self, other is vector) = math.acos(self.unit() * other.unit())'" " in " + _coconut.repr(_coconut.repr(_coconut_match_to)))
_coconut_match_err.pattern = 'def angle(self, other is vector) = math.acos(self.unit() * other.unit())'
_coconut_match_err.value = _coconut_match_to
raise _coconut_match_err
raise _coconut_tail_call(math.acos, self.unit() * other.unit())
def predict_tuple(*_coconut_match_to_args, **_coconut_match_to_kwargs):
_coconut_match_check = False
if (_coconut.len(_coconut_match_to_args) == 1) and (_coconut.isinstance(
_coconut_match_to_args[0], PlaceholderDefaults)) and (_coconut.len(
_coconut_match_to_args[0]) == 3):
tensor = _coconut_match_to_args[0][0]
predict = _coconut_match_to_args[0][1]
if (not _coconut_match_to_kwargs):
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_err = _coconut_MatchError(
"pattern-matching failed for "
"'def predict_tuple(PlaceholderDefaults(tensor, predict, _)):'"
" in " + _coconut.repr(_coconut.repr(_coconut_match_to_args)))
_coconut_match_err.pattern = 'def predict_tuple(PlaceholderDefaults(tensor, predict, _)):'
_coconut_match_err.value = _coconut_match_to_args
raise _coconut_match_err
if isinstance(predict, NoValue):
raise NoValueException("No predict value given for {}".format(tensor))
return tensor, predict
def quick_sort(*_coconut_match_to_args, **_coconut_match_to_kwargs):
_coconut_match_check = False
_coconut_FunctionMatchError = _coconut_get_function_match_error()
if (_coconut.len(_coconut_match_to_args) == 1) and (_coconut.isinstance(_coconut_match_to_args[0], _coconut.abc.Sequence)) and (_coconut.len(_coconut_match_to_args[0]) == 0):
if not _coconut_match_to_kwargs:
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_val_repr = _coconut.repr(_coconut_match_to_args)
_coconut_match_err = _coconut_FunctionMatchError("pattern-matching failed for " "'def quick_sort([]) = []'" " in " + (_coconut_match_val_repr if _coconut.len(_coconut_match_val_repr) <= 500 else _coconut_match_val_repr[:500] + "..."))
_coconut_match_err.pattern = 'def quick_sort([]) = []'
_coconut_match_err.value = _coconut_match_to_args
raise _coconut_match_err
return []
def factorial(*_coconut_match_to):
_coconut_match_check = False
if (_coconut.len(_coconut_match_to) == 1) and (_coconut.isinstance(_coconut_match_to[0], int)):
n = _coconut_match_to[0]
if (n > 0):
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_err = _coconut_MatchError("pattern-matching failed for " "'def factorial(n is int if n > 0) ='" " in " + _coconut.repr(_coconut.repr(_coconut_match_to)))
_coconut_match_err.pattern = 'def factorial(n is int if n > 0) ='
_coconut_match_err.value = _coconut_match_to
raise _coconut_match_err
"""Compute n! where n is an integer >= 0."""
return n * factorial(n - 1)
def _coconut_lambda_2(*_coconut_match_args, **_coconut_match_kwargs):
_coconut_match_check_2 = False
_coconut_match_set_name_val = _coconut_sentinel
_coconut_match_set_name_loss = _coconut_sentinel
_coconut_match_set_name_N = _coconut_sentinel
_coconut_FunctionMatchError = _coconut_get_function_match_error()
if (_coconut.len(_coconut_match_args) == 2) and ("val" not in _coconut_match_kwargs) and (_coconut.isinstance(_coconut_match_args[1], _coconut.abc.Sequence)) and (_coconut.len(_coconut_match_args[1]) == 2):
_coconut_match_temp_0 = _coconut_match_args[0] if _coconut.len(_coconut_match_args) > 0 else _coconut_match_kwargs.pop("val")
_coconut_match_set_name_loss = _coconut_match_args[1][0]
_coconut_match_set_name_N = _coconut_match_args[1][1]
if not _coconut_match_kwargs:
_coconut_match_set_name_val = _coconut_match_temp_0
_coconut_match_check_2 = True
if _coconut_match_check_2:
if _coconut_match_set_name_val is not _coconut_sentinel:
val = _coconut_match_temp_0
if _coconut_match_set_name_loss is not _coconut_sentinel:
loss = _coconut_match_args[1][0]
if _coconut_match_set_name_N is not _coconut_sentinel:
N = _coconut_match_args[1][1]
if not _coconut_match_check_2:
raise _coconut_FunctionMatchError('ns = marginals |> starmap$(def (val, (loss, N)) -> N) |> np.asarray', _coconut_match_args)
return N
def make_features(*args, **kwargs):
"""Same as get_names_and_features but just yields the features."""
_coconut_yield_from_1 = _coconut.iter(
(starmap)(lambda name, feature: feature,
get_names_and_features(*args, **kwargs)))
while True:
try:
yield _coconut.next(_coconut_yield_from_1)
except _coconut.StopIteration as _coconut_yield_err_0:
_coconut_yield_from_0 = _coconut_yield_err_0.args[
0] if _coconut.len(_coconut_yield_err_0.args) > 0 else None
break
_coconut_yield_from_0
def quick_sort(*_coconut_match_to):
_coconut_match_check = False
if (_coconut.len(_coconut_match_to) == 1) and (_coconut.isinstance(_coconut_match_to[0], _coconut.abc.Sequence)) and (_coconut.len(_coconut_match_to[0]) >= 1):
tail = _coconut.list(_coconut_match_to[0][1:])
head = _coconut_match_to[0][0]
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_err = _coconut_MatchError("pattern-matching failed for " "'def quick_sort([head] + tail) ='" " in " + _coconut.repr(_coconut.repr(_coconut_match_to)))
_coconut_match_err.pattern = 'def quick_sort([head] + tail) ='
_coconut_match_err.value = _coconut_match_to
raise _coconut_match_err
"""Sort the input sequence using the quick sort algorithm."""
return (quick_sort([x for x in tail if x < head]) + [head] + quick_sort([x for x in tail if x >= head]))
def factorial(*_coconut_match_to_args, **_coconut_match_to_kwargs):
_coconut_match_check = False
_coconut_FunctionMatchError = _coconut_get_function_match_error()
if (_coconut.len(_coconut_match_to_args) == 1) and (_coconut_match_to_args[0] == 0):
if not _coconut_match_to_kwargs:
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_val_repr = _coconut.repr(_coconut_match_to_args)
_coconut_match_err = _coconut_FunctionMatchError("pattern-matching failed for " "'def factorial(0) = 1'" " in " + (_coconut_match_val_repr if _coconut.len(_coconut_match_val_repr) <= 500 else _coconut_match_val_repr[:500] + "..."))
_coconut_match_err.pattern = 'def factorial(0) = 1'
_coconut_match_err.value = _coconut_match_to_args
raise _coconut_match_err
return 1
def quick_sort(l):
"""Sort the input iterator, using the quick sort algorithm, and without using any data until necessary."""
_coconut_match_check = False
_coconut_match_to = l
if (_coconut.isinstance(_coconut_match_to, _coconut.abc.Iterable)):
tail = _coconut.iter(_coconut_match_to)
_coconut_match_iter_0 = _coconut.tuple(_coconut_igetitem(tail, _coconut.slice(None, 1)))
if (_coconut.len(_coconut_match_iter_0) == 1):
head = _coconut_match_iter_0[0]
_coconut_match_check = True
if _coconut_match_check:
tail, tail_ = tee(tail)
_coconut_yield_from = (_coconut.itertools.chain.from_iterable((_coconut_lazy_item() for _coconut_lazy_item in (lambda: quick_sort((x for x in tail if x < head)), lambda: (head,), lambda: quick_sort((x for x in tail_ if x >= head))))))
for _coconut_yield_item in _coconut_yield_from:
yield _coconut_yield_item
async def async_map_4(*_coconut_match_to_args, **_coconut_match_to_kwargs):
_coconut_match_check = False
_coconut_FunctionMatchError = _coconut_get_function_match_error()
if (_coconut.len(_coconut_match_to_args)
== 1) and (_coconut.isinstance(
_coconut_match_to_args[0], _coconut.abc.Sequence)) and (
_coconut.len(_coconut_match_to_args[0]) >= 1):
iters = _coconut.list(_coconut_match_to_args[0][1:])
func = _coconut_match_to_args[0][0]
if not _coconut_match_to_kwargs:
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_val_repr = _coconut.repr(_coconut_match_to_args)
_coconut_match_err = _coconut_FunctionMatchError(
"pattern-matching failed for "
"'match async def async_map_4([func] + iters) = parallel_map(func, *iters)'"
" in " + (_coconut_match_val_repr
if _coconut.len(_coconut_match_val_repr) <= 500 else
_coconut_match_val_repr[:500] + "..."))
_coconut_match_err.pattern = 'match async def async_map_4([func] + iters) = parallel_map(func, *iters)'
_coconut_match_err.value = _coconut_match_to_args
raise _coconut_match_err
return parallel_map(func, *iters)
def __sub__(self, other):
"""Subtract one vector from another."""
_coconut_match_check = False
_coconut_match_to = other
if (_coconut.isinstance(_coconut_match_to, vector)) and (_coconut.len(_coconut_match_to) == 1):
other_pts = _coconut_match_to[0]
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_err = _coconut_MatchError("pattern-matching failed for " "'vector(other_pts) = other'" " in " + _coconut.repr(_coconut.repr(_coconut_match_to)))
_coconut_match_err.pattern = 'vector(other_pts) = other'
_coconut_match_err.value = _coconut_match_to
raise _coconut_match_err
assert len(other_pts) == len(self.pts)
raise _coconut_tail_call((vector), *map(_coconut_minus, self.pts, other_pts))
def main_test():
"""Basic no-dependency tests."""
assert "\n" == ('''
''') == """
"""
assert _coconut
assert "_coconut" in globals()
assert "_coconut" not in locals()
x = 5
assert x == 5
x == 6
assert x == 5
assert r"hello, world" == "hello, world" == "hello," " " "world"
assert "\n " == """
"""
assert "\\" "\"" == "\\\""
assert """
""" == "\n\n"
assert {"a": 5}["a"] == 5
a, = [24]
assert a == 24
assert set((1, 2, 3)) == _coconut.set((1, 2, 3))
olist = [0, 1, 2]
olist[1] += 4
assert olist == [0, 5, 2]
assert +5e+5 == +5 * +10**+5
assert repr(3) == "3" == ascii(3)
assert _coconut.operator.mul(2, _coconut_minus(2, 5)) == -6
assert (list)(map(_coconut.functools.partial(pow, 2), (range)(0, 5))) == [1, 2, 4, 8, 16]
iter1 = range(0, 10)
iter1, iter2 = tee(iter1)
assert (list)(_coconut_igetitem(iter1, _coconut.slice(2, 8))) == (list)(_coconut_igetitem(iter2, _coconut.slice(2, 8)))
data = 5
assert data == 5
data = 3
assert data == 3
def backslash_test():
return lambda x: x
assert 1 == 1 == backslash_test()(1)
assert (
"hello"
== "hello" ==
'hello'
)
def multiline_backslash_test(
x,
y):
return x + y
assert multiline_backslash_test(1, 2) == 3
assert True
class one_line_class(_coconut.object):
pass
assert isinstance(one_line_class(), one_line_class)
assert ((_coconut.operator.attrgetter("join"))(""))(["1", "2", "3"]) == "123" == ((_coconut.functools.partial(_coconut.getattr, ""))("join"))(["1", "2", "3"])
assert (_coconut.functools.partial(_coconut.operator.getitem, [1, 2, 3]))(1) == 2 == (_coconut.functools.partial(_coconut_igetitem, [1, 2, 3]))(1)
assert (_coconut.functools.partial(_coconut.operator.getitem, "123"))(1) == "2" == (_coconut.functools.partial(_coconut_igetitem, "123"))(1)
assert (list)(_coconut.itertools.chain.from_iterable((_coconut_lazy_item() for _coconut_lazy_item in (lambda: (_coconut_lazy_item() for _coconut_lazy_item in (lambda: -1, lambda: 0)), lambda: range(1, 5))))) == [-1, 0, 1, 2, 3, 4]
assert (list)(_coconut.itertools.chain.from_iterable((_coconut_lazy_item() for _coconut_lazy_item in (lambda: (_coconut_lazy_item() for _coconut_lazy_item in (lambda: 1,)), lambda: (_coconut_lazy_item() for _coconut_lazy_item in (lambda: 2,)))))) == [1, 2]
assert not isinstance(map(_coconut.functools.partial(_coconut.operator.add, 2), [1, 2, 3]), list)
assert not isinstance(range(10), list)
assert isinstance(10**100, int)
assert chr(1000)
assert (abs)(3 + 4j) == 5
assert 3.14j == 3.14j
assert 10.j == 10.j
assert 10j == 10j
assert .001j == .001j
assert 1e100j == 1e100j
assert 3.14e-10j == 3.14e-10j
_coconut_match_check = False
_coconut_match_to = {"text": "abc", "tags": [1, 2, 3]}
if (_coconut.isinstance(_coconut_match_to, _coconut.abc.Mapping)) and (_coconut.len(_coconut_match_to) == 2) and ("text" in _coconut_match_to) and ("tags" in _coconut_match_to) and (_coconut.isinstance(_coconut_match_to["tags"], _coconut.abc.Sequence)) and (_coconut.len(_coconut_match_to["tags"]) >= 1):
text = _coconut_match_to["text"]
rest = _coconut.list(_coconut_match_to["tags"][1:])
first = _coconut_match_to["tags"][0]
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_err = _coconut_MatchError("pattern-matching failed for " '\'{"text": text, "tags": [first] + rest} = {"text": "abc", "tags": [1, 2, 3]}\'' " in " + _coconut.repr(_coconut.repr(_coconut_match_to)))
_coconut_match_err.pattern = '{"text": text, "tags": [first] + rest} = {"text": "abc", "tags": [1, 2, 3]}'
_coconut_match_err.value = _coconut_match_to
raise _coconut_match_err
assert text == "abc"
assert first == 1
assert rest == [2, 3]
assert isinstance("a", str)
assert isinstance(b"a", bytes)
global glob_a, glob_b
glob_a, glob_b = 0, 0
assert glob_a == 0 == glob_b
def set_globs(x):
global glob_a, glob_b
glob_a, glob_b = x, x
set_globs(2)
assert glob_a == 2 == glob_b
def set_globs_again(x):
global glob_a, glob_b
glob_a, glob_b = (x, x)
set_globs_again(10)
assert glob_a == 10 == glob_b
assert _coconut_minus(1) == -1 == _coconut.functools.partial(_coconut_minus, 1)(2)
assert (_coconut.operator.le)(3, 3)
assert (list)((consume)(range(10))) == []
assert (list)(consume(range(10), keep_last=2)) == [8, 9]
i = int()
try:
i.x = 12
except AttributeError as err:
assert err
else:
assert False
r = range(10)
try:
r.x = 12
except AttributeError as err:
assert err
else:
assert False
if _coconut_sys.version_info < (3,):
import Queue as q
else:
import queue as q
if _coconut_sys.version_info < (3,):
import __builtin__ as builtins
else:
import builtins
if _coconut_sys.version_info < (3,):
import email.MIMEBase as _coconut_import
try:
email
except:
email = _coconut.imp.new_module("email")
else:
if not _coconut.isinstance(email, _coconut.types.ModuleType):
email = _coconut.imp.new_module("email")
try:
email.mime
except:
email.mime = _coconut.imp.new_module("email.mime")
else:
if not _coconut.isinstance(email.mime, _coconut.types.ModuleType):
email.mime = _coconut.imp.new_module("email.mime")
email.mime.base = _coconut_import
else:
import email.mime.base
assert q.Queue
assert builtins.len([1, 1]) == 2
assert email.mime.base
if _coconut_sys.version_info < (3,):
import email.MIMEBase as mimebase
else:
from email.mime import base as mimebase
assert mimebase
from_err = TypeError()
try:
_coconut_raise_from = ValueError()
_coconut_raise_from.__cause__ = from_err
raise _coconut_raise_from
except ValueError as err:
assert err.__cause__ is from_err
else:
assert False
class doc(_coconut.collections.namedtuple("doc", "")):
"doc"
__slots__ = ()
class doc_(_coconut.collections.namedtuple("doc_", "")):
"""doc"""
__slots__ = ()
assert doc.__doc__ == "doc" == doc_.__doc__
assert 10000000.0 == 10000000.0
assert (tuple)(_coconut.iter(())) == ()
import collections
if _coconut_sys.version_info < (3, 3):
import collections as _coconut_import
try:
collections
except:
collections = _coconut.imp.new_module("collections")
else:
if not _coconut.isinstance(collections, _coconut.types.ModuleType):
collections = _coconut.imp.new_module("collections")
collections.abc = _coconut_import
else:
import collections.abc
assert isinstance([], collections.abc.Sequence)
assert isinstance(range(1), collections.abc.Sequence)
assert collections.defaultdict(int)[5] == 0
assert len(range(10)) == 10
assert (tuple)((reversed)(range(4))) == (3, 2, 1, 0)
assert (tuple)(range(5)[1:]) == (1, 2, 3, 4) == (tuple)(_coconut_igetitem(range(5), _coconut.slice(1, None)))
assert (tuple)(range(10)[-3:-1]) == (7, 8) == (tuple)(_coconut_igetitem(range(10), _coconut.slice(-3, -1)))
assert (tuple)(_coconut_igetitem(map(abs, (1, -2, -5, 2)), _coconut.slice(None, None))) == (1, 2, 5, 2)
assert _coconut_igetitem((_coconut_lazy_item() for _coconut_lazy_item in (lambda: 1, lambda: 2)), -1) == 2
assert (tuple)(_coconut_igetitem((_coconut_lazy_item() for _coconut_lazy_item in (lambda: 0, lambda: 1, lambda: 2, lambda: 3)), _coconut.slice(-2, None))) == (2, 3)
assert (tuple)(_coconut_igetitem((_coconut_lazy_item() for _coconut_lazy_item in (lambda: 0, lambda: 1, lambda: 2, lambda: 3)), _coconut.slice(None, -2))) == (0, 1)
assert _coconut_igetitem(map(_coconut.operator.add, (_coconut_lazy_item() for _coconut_lazy_item in (lambda: 10, lambda: 20)), (_coconut_lazy_item() for _coconut_lazy_item in (lambda: 1, lambda: 2))), -1) == 22 == map(_coconut.operator.add, (_coconut_lazy_item() for _coconut_lazy_item in (lambda: 10, lambda: 20)), (_coconut_lazy_item() for _coconut_lazy_item in (lambda: 1, lambda: 2)))[-1]
assert _coconut_igetitem(map(lambda x: x + 1, range(10**9)), -1) == 10**9 == _coconut_igetitem(count(), 10**9)
assert (tuple)(_coconut_igetitem(count(), _coconut.slice(10, 15))) == (10, 11, 12, 13, 14) == (tuple)(count()[10:15])
assert (tuple)(zip((1, 2), (3, 4))) == ((1, 3), (2, 4)) == (tuple)(_coconut_igetitem(zip((1, 2), (3, 4)), _coconut.slice(None, None)))
assert (tuple)(_coconut_igetitem(zip((_coconut_lazy_item() for _coconut_lazy_item in (lambda: 10, lambda: 20)), (_coconut_lazy_item() for _coconut_lazy_item in (lambda: 1, lambda: 2))), -1)) == (20, 2) == (tuple)(zip((_coconut_lazy_item() for _coconut_lazy_item in (lambda: 10, lambda: 20)), (_coconut_lazy_item() for _coconut_lazy_item in (lambda: 1, lambda: 2)))[-1])
assert (tuple)(_coconut_igetitem(zip(count(), count()), 10**9)) == (10**9, 10**9) == (tuple)(zip(count(), count())[10**9])
assert _coconut_igetitem(count(1.5, 0.5), 0) == 1.5 == _coconut_igetitem((1.5, 2, 2.5, 3), 0)
assert (tuple)(_coconut_igetitem(count(1.5, 0.5), _coconut.slice(1, 3))) == (2, 2.5) == (tuple)(_coconut_igetitem((1.5, 2, 2.5, 3), _coconut.slice(1, 3)))
assert (tuple)(_coconut_igetitem(iter((0, 1, 2, 3, 4)), _coconut.slice(None, None, 2))) == (0, 2, 4)
assert (tuple)(_coconut_igetitem(iter((0, 1, 2, 3, 4)), _coconut.slice(None, None, -1))) == (4, 3, 2, 1, 0)
assert dict(((x), (x)) for x in range(5)) == {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}
_coconut_match_check = False
_coconut_match_to = 12
x = _coconut_match_to
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_err = _coconut_MatchError("pattern-matching failed for " "'match x = 12'" " in " + _coconut.repr(_coconut.repr(_coconut_match_to)))
_coconut_match_err.pattern = 'match x = 12'
_coconut_match_err.value = _coconut_match_to
raise _coconut_match_err
assert x == 12
get_int = lambda: int
_coconut_match_check = False
_coconut_match_to = 5
if (_coconut.isinstance(_coconut_match_to, get_int())):
x = _coconut_match_to
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_err = _coconut_MatchError("pattern-matching failed for " "'x is get_int() = 5'" " in " + _coconut.repr(_coconut.repr(_coconut_match_to)))
_coconut_match_err.pattern = 'x is get_int() = 5'
_coconut_match_err.value = _coconut_match_to
raise _coconut_match_err
assert x == 5
class a(get_int()):
pass
assert isinstance(a(), int)
assert (len)(map(_coconut.operator.add, range(5), range(6))) == 5 == (len)(zip(range(5), range(6)))
assert map(_coconut_minus, range(5))._func(3) == -3
assert (tuple)(map(_coconut_minus, range(5))._iters[0]) == (tuple)(range(5)) == (tuple)(zip(range(5), range(6))._iters[0])
assert repr(zip((0, 1), (1, 2))) == "zip((0, 1), (1, 2))"
assert repr(map(_coconut_minus, range(5))).startswith("map(")
assert repr(parallel_map(_coconut_minus, range(5))).startswith("parallel_map(")
assert (tuple)(parallel_map(_coconut_minus, range(5))) == (0, -1, -2, -3, -4) == (tuple)(_coconut_igetitem(parallel_map(_coconut.functools.partial(map, _coconut_minus), (range(5),)), 0))
assert (tuple)(map(tuple, parallel_map(zip, (range(2),), (range(2),)))) == (((0, 0), (1, 1)),)
assert (tuple)(map(_coconut.operator.add, *(range(0, 5), range(5, 10)))) == (5, 7, 9, 11, 13)
assert (tuple)(parallel_map(_coconut_compose(_coconut.functools.partial(_coconut.operator.mul, 2), _coconut.functools.partial(_coconut.operator.add, 1)), range(5))) == (2, 4, 6, 8, 10)
assert repr(concurrent_map(_coconut_minus, range(5))).startswith("concurrent_map(")
assert (tuple)(concurrent_map(_coconut_minus, range(5))) == (0, -1, -2, -3, -4) == (tuple)(_coconut_igetitem(concurrent_map(_coconut.functools.partial(map, _coconut_minus), (range(5),)), 0))
assert (tuple)(map(tuple, concurrent_map(zip, (range(2),), (range(2),)))) == (((0, 0), (1, 1)),)
assert (tuple)(map(_coconut.operator.add, *(range(0, 5), range(5, 10)))) == (5, 7, 9, 11, 13)
assert (tuple)(concurrent_map(_coconut_compose(_coconut.functools.partial(_coconut.operator.mul, 2), _coconut.functools.partial(_coconut.operator.add, 1)), range(5))) == (2, 4, 6, 8, 10)
assert 0 in range(1)
assert range(1).count(0) == 1
assert 2 in range(5)
assert range(5).count(2) == 1
assert 10 not in range(3)
assert range(3).count(10) == 0
assert 1 in range(1, 2, 3)
assert range(1, 2, 3).count(1) == 1
assert range(1, 2, 3).index(1) == 0
assert range(1, 2, 3)[0] == 1
assert range(1, 5, 3).index(4) == 1
assert range(1, 5, 3)[1] == 4
try:
range(1, 2, 3).index(2)
except ValueError as err:
assert err
else:
assert False
assert 0 in count()
assert count().count(0) == 1
assert -1 not in count()
assert count().count(-1) == 0
assert 1 not in count(5)
assert count(5).count(1) == 0
assert 2 not in count(1, 2)
assert count(1, 2).count(2) == 0
try:
count(1, 2).index(2)
except ValueError as err:
assert err
else:
assert False
assert count(1, 3).index(1) == 0
assert count(1, 3)[0] == 1
assert count(1, 3).index(4) == 1
assert count(1, 3)[1] == 4
assert (len)(map(lambda x: x, [1, 2])) == 2
assert repr("hello") == "'hello'" == ascii("hello")
assert (_coconut.operator.methodcaller("index", 1))(count(1, 3)) == 0
assert _coconut_igetitem(count(1).__copy__(), 0) == 1
assert _coconut_igetitem(map(_coconut.operator.add, count(1), count(1)).__copy__(), 0) == 2
assert (tuple)(_coconut_igetitem(zip(count(1), count(1)).__copy__(), 0)) == (1, 1)
assert (all)(map(lambda t: isinstance(t, count), tee(count())))
assert (all)(map(lambda t: isinstance(t, range), tee(range(10))))
assert (all)(map(lambda t: isinstance(t, list), tee([1, 2, 3])))
assert (lambda _=None: 5)() == 5
assert (lambda _=None: _[0])([1, 2, 3]) == 1
assert (list)(_coconut_igetitem(iter(range(10)), _coconut.slice(-5, -8))) == [5, 6]
assert (list)(_coconut_igetitem(iter(range(10)), _coconut.slice(-2, None))) == [8, 9]
assert (_coconut.operator.itemgetter(1))(range(1, 5)) == 2 == (_coconut.functools.partial(_coconut_igetitem, index=1))(range(1, 5))
assert (list)((_coconut.operator.itemgetter(_coconut.slice(None, 5)))(range(10))) == [0, 1, 2, 3, 4] == (list)((_coconut.functools.partial(_coconut_igetitem, index=_coconut.slice(None, 5)))(range(10)))
def _coconut_lambda_0(x):
y = x
assert (list)(map(_coconut_lambda_0, range(10))) == [None] * 10
def _coconut_lambda_1(x):
yield x
assert (list)(map(list, map(_coconut_lambda_1, range(5)))) == [[0], [1], [2], [3], [4]]
def do_stuff(x):
return True
def _coconut_lambda_2(x=3):
return do_stuff(x)
assert (_coconut_lambda_2)() is True
def _coconut_lambda_3(x=4):
do_stuff(x)
return x
assert (_coconut_lambda_3)() == 4
def _coconut_lambda_4(x=5):
do_stuff(x)
assert (_coconut_lambda_4)() is None
def _coconut_lambda_5(x=6):
do_stuff(x)
assert x
(_coconut_lambda_5)()
def _coconut_lambda_6(x=7):
do_stuff(x)
assert x
yield x
assert (list)((_coconut_lambda_6)()) == [7]
def _coconut_lambda_7(_=None):
do_stuff(_)
assert _
return _
assert (_coconut_lambda_7)(8) == 8
def _coconut_lambda_8(x=9):
return x
assert (_coconut_lambda_8)() == 9
def _coconut_lambda_9(x=10):
do_stuff(x)
return x
assert (_coconut_lambda_9)() == 10
def _coconut_lambda_12(_=None):
def _coconut_lambda_11(_=None):
return 11
return _coconut_lambda_11
assert (_coconut_lambda_12)()() == 11
def _coconut_lambda_13(_=None):
return 12
def _coconut_lambda_14(_=None):
return 12
assert (_coconut_lambda_13)() == 12 == (_coconut_lambda_14)()
def _coconut_lambda_15(x):
return lambda _=None: x
assert (list)(map(lambda _=None: _(), ((_coconut_lambda_15)(x) for x in range(5)))) == [0, 1, 2, 3, 4]
herpaderp = 5
def derp():
herp = 10
def _coconut_lambda_16(_=None):
return herpaderp + herp
return (_coconut_lambda_16)
assert derp()() == 15
class abc(_coconut.collections.namedtuple("abc", "xyz")):
__slots__ = ()
assert abc(10).xyz == 10
class aclass(_coconut.object): pass
assert isinstance(aclass, object)
assert (_coconut.operator.is_)(*tee((1, 2)))
assert (_coconut.operator.is_)(*tee(_coconut.frozenset((1, 2))))
assert (lambda x: 2 / x)(4) == 1 / 2
_coconut_match_check = False
_coconut_match_to = range(10)
if (_coconut.isinstance(_coconut_match_to, _coconut.abc.Iterable)):
_coconut_match_iter_0 = _coconut.list(_coconut_match_to)
if (_coconut.len(_coconut_match_iter_0) >= 2):
b = _coconut_match_iter_0[1:-1]
a = _coconut_match_iter_0[0]
c = _coconut_match_iter_0[-1]
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_err = _coconut_MatchError("pattern-matching failed for " "'match [a, *b, c] = range(10)'" " in " + _coconut.repr(_coconut.repr(_coconut_match_to)))
_coconut_match_err.pattern = 'match [a, *b, c] = range(10)'
_coconut_match_err.value = _coconut_match_to
raise _coconut_match_err
assert a == 0
assert b == [1, 2, 3, 4, 5, 6, 7, 8]
assert c == 9
_coconut_match_check = False
_coconut_match_to = range(10)
if (_coconut.isinstance(_coconut_match_to, _coconut.abc.Iterable)):
_coconut_match_iter_0 = _coconut.list(_coconut_match_to)
if (_coconut.len(_coconut_match_iter_0) >= 2) and (_coconut_match_iter_0[0] == _coconut_match_iter_0[-1]):
b = _coconut_match_iter_0[1:-1]
a = _coconut_match_iter_0[0]
_coconut_match_check = True
if _coconut_match_check:
assert False
else:
assert True
a = 1
b = 1
assert a == 1 == b
assert count(5) == count(5)
assert count(5) != count(3)
assert {count(5): True}[count(5)]
def _coconut_lambda_17(x):
return x
assert (_coconut_lambda_17)(1) == 1
def _coconut_lambda_18(*_coconut_match_to):
_coconut_match_check = False
if (_coconut.len(_coconut_match_to) == 1) and (_coconut.isinstance(_coconut_match_to[0], _coconut.abc.Sequence)) and (_coconut.len(_coconut_match_to[0]) >= 1):
xs = _coconut.list(_coconut_match_to[0][1:])
x = _coconut_match_to[0][0]
_coconut_match_check = True
if not _coconut_match_check:
_coconut_match_err = _coconut_MatchError("pattern-matching failed for " "'assert (def ([x] + xs) -> x, xs) <| range(5) == (0, [1,2,3,4])'" " in " + _coconut.repr(_coconut.repr(_coconut_match_to)))
_coconut_match_err.pattern = 'assert (def ([x] + xs) -> x, xs) <| range(5) == (0, [1,2,3,4])'
_coconut_match_err.value = _coconut_match_to
raise _coconut_match_err
return x, xs
assert ((_coconut_lambda_18))(range(5)) == (0, [1, 2, 3, 4])
s = "hello" # type: str
assert s == "hello"
return True
