def collect_info(game, num):
arr = game.ix[num, 0].split(' ')
length = len(arr)
if length == 3:
team = arr[1]
rank = arr[0]
record = arr[2]
elif length == 2:
if bool(re.search('\d', arr[0])) == True:
team = arr[1]
rank = arr[0]
record = "0-0"
else:
team = arr[0]
rank = "Unranked"
record = arr[1]
elif length == 1:
team = arr[0]
rank = "Unranked"
record = "0-0"
wins = record.split('-')[0]
losses = record.split('-')[1]
final_margin = game.ix[num, 5] - game.ix[(num + 1) % 2, 5]
team = team_map(team)
return str(team), str(rank), str(wins), str(losses), int(
final_margin)
def set(self, value):
try:
if value is not None:
self.value = builtins.bool(value)
else:
self.value = None
except ValueError as e:
raise BadParameterType("bool", value)
def forgive(arg, level):
if level == 1:
if arg in ['True', 'true']:
return True
if arg in ['False', 'false']:
return False
if level == 2:
return builtins.bool(arg)
def assert_false(x, msg=None):
'''Assert that ``x`` is evaluated to ``False``.
:returns: ``True`` on success.
:raises reframe.core.exceptions.SanityError: if assertion fails.
'''
if builtins.bool(x) is not False:
error_msg = msg or '{0} is not False'
raise SanityError(_format(error_msg, x))
return True
def test_routes_logs(worker, api):
task_path = "tests.tasks.general.RaiseException"
worker.send_task(task_path, {
"message": "xyz"}, block=True, accept_statuses=["failed"])
job = worker.mongodb_jobs.mrq_jobs.find_one()
assert job
data, _ = api.GET("/api/logs?job=%s" % job["_id"])
assert bool(data["last_log_id"])
def assert_false(x, msg=None):
'''Assert that ``x`` is evaluated to ``False``.
:arg msg: The error message to use if the assertion fails. You may use
``{0}`` ... ``{N}`` as placeholders for the function arguments.
:returns: ``True`` on success.
:raises reframe.core.exceptions.SanityError: if assertion fails.
'''
if builtins.bool(x) is not False:
error_msg = msg or '{0} is not False'
raise SanityError(_format(error_msg, x))
return True
def test_routes_jobaction(worker, api):
worker.send_task("tests.tasks.general.ReturnParams", {"message": "xyz"},
block=False,
queue="tmp")
job = worker.mongodb_jobs.mrq_jobs.find_one()
assert job
params = {"action": "cancel", "id": str(job["_id"])}
data, _ = api.POST("/api/jobaction", data=json.dumps(params))
assert "job_id" in data
assert bool(data["job_id"])
def is_empty(self):
return bool(self._items)
def bool(x=None):
if x is None:
return bpipe(bool)
else:
return builtins.bool(x)
_core.set_global_default_context(_global_context)
# Implements ndarray methods in Python
from chainerx import _ndarray
_ndarray.populate()
# Temporary workaround implementations that fall back to NumPy/CuPy's
# respective functions.
from chainerx import _fallback_workarounds
_fallback_workarounds.populate()
# Dynamically inject docstrings
from chainerx import _docs
_docs.set_docs()
from chainerx import _cuda
# Share memory pool with CuPy.
if bool(int(os.getenv('CHAINERX_CUDA_CUPY_SHARE_ALLOCATOR', '0'))):
_cuda.cupy_share_allocator()
else:
class ndarray(object):
"""Dummy class for type testing."""
def __init__(self, *args, **kwargs):
raise RuntimeError('chainerx is not available.')
def is_available():
return _available
def __init__(self,
dtype_or_func=None,
default=None,
missing_values=None,
locked=False):
# Convert unicode (for Py3)
if isinstance(missing_values, str):
missing_values = asbytes(missing_values)
elif isinstance(missing_values, (list, tuple)):
missing_values = asbytes_nested(missing_values)
# Defines a lock for upgrade
self._locked = bool(locked)
# No input dtype: minimal initialization
if dtype_or_func is None:
self.func = str2bool
self._status = 0
self.default = default or False
dtype = np.dtype('bool')
else:
# Is the input a np.dtype ?
try:
self.func = None
dtype = np.dtype(dtype_or_func)
except TypeError:
# dtype_or_func must be a function, then
if not hasattr(dtype_or_func, '__call__'):
errmsg = "The input argument `dtype` is neither a function"\
" or a dtype (got '%s' instead)"
raise TypeError(errmsg % type(dtype_or_func))
# Set the function
self.func = dtype_or_func
# If we don't have a default, try to guess it or set it to None
if default is None:
try:
default = self.func(asbytes('0'))
except ValueError:
default = None
dtype = self._getdtype(default)
# Set the status according to the dtype
_status = -1
for (i, (deftype, func, default_def)) in enumerate(self._mapper):
if np.issubdtype(dtype.type, deftype):
_status = i
if default is None:
self.default = default_def
else:
self.default = default
break
if _status == -1:
# We never found a match in the _mapper...
_status = 0
self.default = default
self._status = _status
# If the input was a dtype, set the function to the last we saw
if self.func is None:
self.func = func
# If the status is 1 (int), change the function to
# something more robust.
if self.func == self._mapper[1][1]:
if issubclass(dtype.type, np.uint64):
self.func = np.uint64
elif issubclass(dtype.type, np.int64):
self.func = np.int64
else:
self.func = lambda x: int(float(x))
# Store the list of strings corresponding to missing values.
if missing_values is None:
self.missing_values = set([asbytes('')])
else:
if isinstance(missing_values, bytes):
missing_values = missing_values.split(asbytes(","))
self.missing_values = set(list(missing_values) + [asbytes('')])
#
self._callingfunction = self._strict_call
self.type = self._dtypeortype(dtype)
self._checked = False
self._initial_default = default
def rroulette(f, g, p=1 / 6):
@wraps(f)
def inner(*args, **kwargs):
if random() < p:
return g(*args, **kwargs)
else:
return f(*args, **kwargs)
return inner
int = rroulette(_.int, lambda v: _.int(v) - 1)
float = rroulette(_.float, lambda v: _.float(v) + 0.001)
str = rroulette(_.str, lambda v: _.str(v)[::-1])
bool = rroulette(_.bool, lambda v: not (_.bool(v)))
len = rroulette(_.len, lambda v: _.len(v) - 1)
ord = rroulette(_.ord, lambda v: _.ord(v.lower()
if v.isupper() else v.upper()))
abs = rroulette(_.abs, lambda v: -_.abs(v))
pow = rroulette(_.pow, lambda v, p: _.pow(v, p + 1))
min = rroulette(_.min, lambda *v: _.max(*v))
max = rroulette(_.max, lambda *v: _.min(*v))
sum = rroulette(_.sum, lambda v: reduce(op.__sub__, v))
hasattr = rroulette(_.hasattr, lambda o, n: not (_.hasattr(o, n)))
sorted = rroulette(_.sorted, lambda v: _.reversed(v))
reversed = rroulette(_.reversed, lambda v: _.sorted(v))
enumerate = rroulette(_.enumerate, lambda v:
def bool(*args):
return builtins.bool(*args)
def bool(text):
try:
return builtins.bool(input(text))
except ValueError:
return bool(text)
def __bool__(self):
'''The truthy value of a deferred expression.
This causes the immediate evaluation of the deferred expression.
'''
return builtins.bool(self.evaluate())
def __init__(self,
dtype_or_func=None,
default=None,
missing_values=None,
locked=False):
# Defines a lock for upgrade
self._locked = bool(locked)
# No input dtype: minimal initialization
if dtype_or_func is None:
self.func = str2bool
self._status = 0
self.default = default or False
dtype = np.dtype("bool")
else:
# Is the input a np.dtype ?
try:
self.func = None
dtype = np.dtype(dtype_or_func)
except TypeError:
# dtype_or_func must be a function, then
if not hasattr(dtype_or_func, "__call__"):
errmsg = ("The input argument `dtype` is neither a"
" function nor a dtype (got '%s' instead)")
raise TypeError(errmsg % type(dtype_or_func))
# Set the function
self.func = dtype_or_func
# If we don't have a default, try to guess it or set it to
# None
if default is None:
try:
default = self.func("0")
except ValueError:
default = None
dtype = self._getdtype(default)
# Set the status according to the dtype
_status = -1
for (i, (deftype, func, default_def)) in enumerate(self._mapper):
if np.issubdtype(dtype.type, deftype):
_status = i
if default is None:
self.default = default_def
else:
self.default = default
break
# if a converter for the specific dtype is available use that
last_func = func
for (i, (deftype, func, default_def)) in enumerate(self._mapper):
if dtype.type == deftype:
_status = i
last_func = func
if default is None:
self.default = default_def
else:
self.default = default
break
func = last_func
if _status == -1:
# We never found a match in the _mapper...
_status = 0
self.default = default
self._status = _status
# If the input was a dtype, set the function to the last we saw
if self.func is None:
self.func = func
# If the status is 1 (int), change the function to
# something more robust.
if self.func == self._mapper[1][1]:
if issubclass(dtype.type, np.uint64):
self.func = np.uint64
elif issubclass(dtype.type, np.int64):
self.func = np.int64
else:
self.func = lambda x: int(float(x))
# Store the list of strings corresponding to missing values.
if missing_values is None:
self.missing_values = {""}
else:
if isinstance(missing_values, basestring):
missing_values = missing_values.split(",")
self.missing_values = set(list(missing_values) + [""])
#
self._callingfunction = self._strict_call
self.type = self._dtypeortype(dtype)
self._checked = False
self._initial_default = default
def r(f, g, p=1 / 6):
@wraps(f)
def i(*a, **k):
if random() < p:
return g(*a, **k)
return f(*a, **k)
return i
int = r(_.int, lambda *a: _.int(*a) - 1)
float = r(_.float, lambda v: _.float(v) + 0.001)
str = r(_.str, lambda *a, **k: _.str(*a, **k)[::-1])
bool = r(_.bool, lambda v: not (_.bool(v)))
len = r(_.len, lambda v: _.len(v) - 1)
ord = r(_.ord, lambda v: _.ord(v.lower() if v.isupper() else v.upper()))
abs = r(_.abs, lambda v: -_.abs(v))
pow = r(_.pow, lambda v, p, *a: _.pow(v, p + 1, *a))
min = r(_.min, lambda *a: _.max(*a))
max = r(_.max, lambda *a: _.min(*a))
sum = r(_.sum, lambda v, *a: reduce(op.__sub__, v))
hasattr = r(_.hasattr, lambda o, n: not (_.hasattr(o, n)))
sorted = r(_.sorted, lambda *a, **k: list(_.reversed(*a, **k)))
reversed = r(_.reversed, lambda v: _.sorted(v))
enumerate = r(_.enumerate, lambda v, *a:
((i + 1, _v) for i, _v in _.enumerate(v, *a)))
lambda *args, **kwargs: wrap(builtins.all)(*args, **kwargs), builtins.all)
any = functools.update_wrapper(
lambda *args, **kwargs: builtins.any(*args, **kwargs), builtins.any)
any._ = functools.update_wrapper(
lambda *args, **kwargs: wrap(builtins.any)(*args, **kwargs), builtins.any)
ascii = functools.update_wrapper(
lambda *args, **kwargs: builtins.ascii(*args, **kwargs), builtins.ascii)
ascii._ = functools.update_wrapper(
lambda *args, **kwargs: wrap(builtins.ascii)(*args, **kwargs),
builtins.ascii)
bin = functools.update_wrapper(
lambda *args, **kwargs: builtins.bin(*args, **kwargs), builtins.bin)
bin._ = functools.update_wrapper(
lambda *args, **kwargs: wrap(builtins.bin)(*args, **kwargs), builtins.bin)
bool = functools.update_wrapper(
lambda *args, **kwargs: builtins.bool(*args, **kwargs), builtins.bool)
bool._ = functools.update_wrapper(
lambda *args, **kwargs: wrap(builtins.bool)(*args, **kwargs),
builtins.bool)
breakpoint = functools.update_wrapper(
lambda *args, **kwargs: builtins.breakpoint(*args, **kwargs),
builtins.breakpoint)
breakpoint._ = functools.update_wrapper(
lambda *args, **kwargs: wrap(builtins.breakpoint)(*args, **kwargs),
builtins.breakpoint)
bytearray = functools.update_wrapper(
lambda *args, **kwargs: builtins.bytearray(*args, **kwargs),
builtins.bytearray)
bytearray._ = functools.update_wrapper(
lambda *args, **kwargs: wrap(builtins.bytearray)(*args, **kwargs),
builtins.bytearray)
# Implements ndarray methods in Python
from chainerx import _ndarray
_ndarray.populate()
# Temporary workaround implementations that fall back to NumPy/CuPy's
# respective functions.
from chainerx import _fallback_workarounds
_fallback_workarounds.populate()
# Dynamically inject docstrings
from chainerx import _docs
_docs.set_docs()
from chainerx import _cuda
# Share memory pool with CuPy.
if bool(int(os.getenv('CHAINERX_CUDA_CUPY_SHARE_ALLOCATOR', '0'))):
_cuda.cupy_share_allocator()
else:
class ndarray(object):
"""Dummy class for type testing."""
def __init__(self, *args, **kwargs):
raise RuntimeError('chainerx is not available.')
def is_available():
return _available
if _available and _core._is_debug():
def bool(iterable):
return (builtins.bool(x) for x in iterable)
def __init__(self, dtype_or_func=None, default=None, missing_values=None,
locked=False):
# Convert unicode (for Py3)
if isinstance(missing_values, unicode):
missing_values = asbytes(missing_values)
elif isinstance(missing_values, (list, tuple)):
missing_values = asbytes_nested(missing_values)
# Defines a lock for upgrade
self._locked = bool(locked)
# No input dtype: minimal initialization
if dtype_or_func is None:
self.func = str2bool
self._status = 0
self.default = default or False
dtype = np.dtype('bool')
else:
# Is the input a np.dtype ?
try:
self.func = None
dtype = np.dtype(dtype_or_func)
except TypeError:
# dtype_or_func must be a function, then
if not hasattr(dtype_or_func, '__call__'):
errmsg = "The input argument `dtype` is neither a function"\
" or a dtype (got '%s' instead)"
raise TypeError(errmsg % type(dtype_or_func))
# Set the function
self.func = dtype_or_func
# If we don't have a default, try to guess it or set it to None
if default is None:
try:
default = self.func(asbytes('0'))
except ValueError:
default = None
dtype = self._getdtype(default)
# Set the status according to the dtype
_status = -1
for (i, (deftype, func, default_def)) in enumerate(self._mapper):
if np.issubdtype(dtype.type, deftype):
_status = i
if default is None:
self.default = default_def
else:
self.default = default
break
if _status == -1:
# We never found a match in the _mapper...
_status = 0
self.default = default
self._status = _status
# If the input was a dtype, set the function to the last we saw
if self.func is None:
self.func = func
# If the status is 1 (int), change the function to
# something more robust.
if self.func == self._mapper[1][1]:
if issubclass(dtype.type, np.uint64):
self.func = np.uint64
elif issubclass(dtype.type, np.int64):
self.func = np.int64
else:
self.func = lambda x : int(float(x))
# Store the list of strings corresponding to missing values.
if missing_values is None:
self.missing_values = set([asbytes('')])
else:
if isinstance(missing_values, bytes):
missing_values = missing_values.split(asbytes(","))
self.missing_values = set(list(missing_values) + [asbytes('')])
#
self._callingfunction = self._strict_call
self.type = self._dtypeortype(dtype)
self._checked = False
self._initial_default = default
def add_sign(literal):
if bool(random.getrandbits(1)):
return literal
return -literal
