def solve2(self, f):
if all_disabled():
return solve(self, f)
F = self.get_fun_space()
try:
F.belongs(f)
except NotBelongs as e:
msg = "Function passed to solve() is not in function space."
raise_wrapped(NotBelongs, e, msg,
F=F, f=f, dp=self.repr_long(), exc=sys.exc_info())
try:
res = solve(self, f)
return res
except NotBelongs as e:
raise_wrapped(NotBelongs, e,
'Solve failed.', self=self, f=f, exc=sys.exc_info())
except NotImplementedError as e:
raise_wrapped(NotImplementedError, e,
'Solve not implemented for class %s.' % name, exc=sys.exc_info())
except NotSolvableNeedsApprox:
raise
except WrongUseOfUncertain:
raise
except Exception as e:
raise_wrapped(Exception, e,
'Solve failed', f=f, self=self, exc=sys.exc_info())
def test_invalid_id_2(self):
valid = [
"cioa",
"cioa",
"cioa_",
"cioa-0.4",
"cioa-",
]
invalid = [
"cioa/",
"cioa:",
"cioa ",
"cioa <",
"$cioa",
" cioa",
"",
'"',
'""',
"'",
"a\\a",
]
for s in invalid:
print("TRying with %r" % s)
if not contracts.all_disabled():
self.assertRaises((ValueError, ContractNotRespected), Report,
s)
for s in valid:
Report(s)
def all_disabled():
"""
Wraps PyContracts `all_disabled()
<http://andreacensi.github.io/contracts/api/contracts.html#
module-contracts.enabling>`_ function. From the PyContracts documentation:
"Returns true if all contracts are disabled"
"""
return contracts.all_disabled()
def do_extra_checks():
""" True if we want to do extra paranoid checks for functions. """
res = not all_disabled()
# if _storage.first:
# # logger.info('do_extra_checks: %s' % res)
# pass
# _storage.first = False
return res
def do_extra_checks():
return False
res = not all_disabled()
# if _storage.first:
# # logger.info('do_extra_checks: %s' % res)
# pass
# _storage.first = False
return res
def parmake_job2_new_process(args):
""" Starts the job in a new compmake process. """
(job_id, context) = args
compmake_bin = which("compmake")
db = context.get_compmake_db()
storage = db.basepath # XXX:
where = os.path.join(storage, "parmake_job2_new_process")
if not os.path.exists(storage):
try:
os.makedirs(storage)
except:
pass
out_result = os.path.join(where, "%s.results.pickle" % job_id)
out_result = os.path.abspath(out_result)
cmd = [compmake_bin, storage]
if not all_disabled():
cmd += ["--contracts"]
cmd += [
"--status_line_enabled",
"0",
"--colorize",
"0",
"-c",
"make_single out_result=%s %s" % (out_result, job_id),
]
cwd = os.getcwd()
cmd_res = system_cmd_result(
cwd, cmd, display_stdout=False, display_stderr=False, raise_on_error=False, capture_keyboard_interrupt=False
)
ret = cmd_res.ret
if ret == CompmakeConstants.RET_CODE_JOB_FAILED: # XXX:
msg = "Job %r failed in external process" % job_id
msg += indent(cmd_res.stdout, "stdout| ")
msg += indent(cmd_res.stderr, "stderr| ")
res = safe_pickle_load(out_result)
os.unlink(out_result)
result_dict_check(res)
raise JobFailed.from_dict(res)
elif ret != 0:
msg = "Host failed while doing %r" % job_id
msg += "\n cmd: %s" % " ".join(cmd)
msg += "\n" + indent(cmd_res.stdout, "stdout| ")
msg += "\n" + indent(cmd_res.stderr, "stderr| ")
raise CompmakeBug(msg) # XXX:
res = safe_pickle_load(out_result)
os.unlink(out_result)
result_dict_check(res)
return res
def checkContract(self, argumentName, value):
# No contract to check.
if self._contract is None:
return
# Contracts are disabled.
if contracts.all_disabled():
return
self._contract._check_contract(value=value, context={argumentName: value}, silent=False)
def checkContract(self, argumentName, value):
# No contract to check.
if self._contract is None:
return
# Contracts are disabled.
if contracts.all_disabled():
return
self._contract._check_contract(value=value,
context={argumentName: value},
silent=False)
def get_implementations_f_r2(self, f, r):
if all_disabled():
return get_implementations_f_r(self, f, r)
F = self.get_fun_space()
R = self.get_fun_space()
try:
F.belongs(f)
except NotBelongs as e:
msg = "Function passed to get_implementations_f_r() is not in function space."
raise_wrapped(NotBelongs, e, msg,
F=F, f=f, dp=self.repr_long(), exc=sys.exc_info())
try:
R.belongs(r)
except NotBelongs as e:
msg = "Function passed to get_implementations_f_r() is not in R space."
raise_wrapped(NotBelongs, e, msg,
R=R, r=r, dp=self.repr_long(), exc=sys.exc_info())
try:
res = get_implementations_f_r(self, f, r)
except NotBelongs as e:
raise_wrapped(NotBelongs, e,
'Solve failed.', self=self, f=f, exc=sys.exc_info())
except NotImplementedError as e:
raise_wrapped(NotImplementedError, e,
'Solve not implemented for class %s.' % name)
except NotSolvableNeedsApprox:
raise
except WrongUseOfUncertain:
raise
except Exception as e:
raise_wrapped(Exception, e,
'Solve failed', f=f, self=self, exc=sys.exc_info())
M = self.get_imp_space()
try:
for m in res:
M.belongs(m)
except NotBelongs as e:
raise_wrapped(NotBelongs, e,
'Result of get_implementations_f_r not in M.',
self=self, m=m, M=M, exc=sys.exc_info())
return res
def solve2(self, f):
if all_disabled():
return solve(self, f)
F = self.get_fun_space()
try:
F.belongs(f)
except NotBelongs as e:
msg = "Function passed to solve() is not in function space."
raise_wrapped(NotBelongs,
e,
msg,
F=F,
f=f,
dp=self.repr_long(),
exc=sys.exc_info())
try:
res = solve(self, f)
return res
except NotBelongs as e:
raise_wrapped(NotBelongs,
e,
'Solve failed.',
self=self,
f=f,
exc=sys.exc_info())
except NotImplementedError as e:
raise_wrapped(NotImplementedError,
e,
'Solve not implemented for class %s.' %
name,
exc=sys.exc_info())
except NotSolvableNeedsApprox:
raise
except WrongUseOfUncertain:
raise
except Exception as e:
raise_wrapped(Exception,
e,
'Solve failed',
f=f,
self=self,
exc=sys.exc_info())
def get_implementations_f_r2(self, f, r):
if all_disabled():
return get_implementations_f_r(self, f, r)
F = self.get_fun_space()
R = self.get_fun_space()
try:
F.belongs(f)
except NotBelongs as e:
msg = "Function passed to get_implementations_f_r() is not in function space."
raise_wrapped(NotBelongs,
e,
msg,
F=F,
f=f,
dp=self.repr_long(),
exc=sys.exc_info())
try:
R.belongs(r)
except NotBelongs as e:
msg = "Function passed to get_implementations_f_r() is not in R space."
raise_wrapped(NotBelongs,
e,
msg,
R=R,
r=r,
dp=self.repr_long(),
exc=sys.exc_info())
try:
res = get_implementations_f_r(self, f, r)
except NotBelongs as e:
raise_wrapped(NotBelongs,
e,
'Solve failed.',
self=self,
f=f,
exc=sys.exc_info())
except NotImplementedError as e:
raise_wrapped(
NotImplementedError, e,
'Solve not implemented for class %s.' % name)
except NotSolvableNeedsApprox:
raise
except WrongUseOfUncertain:
raise
except Exception as e:
raise_wrapped(Exception,
e,
'Solve failed',
f=f,
self=self,
exc=sys.exc_info())
M = self.get_imp_space()
try:
for m in res:
M.belongs(m)
except NotBelongs as e:
raise_wrapped(
NotBelongs,
e,
'Result of get_implementations_f_r not in M.',
self=self,
m=m,
M=M,
exc=sys.exc_info())
return res
def execute(self, spool):
db = self.db
# Todo: check its this one
storage = os.path.abspath(db.basepath)
# create a new spool directory for each execution
# otherwise we get confused!
self.stderr = os.path.join(spool, '%s.stderr' % self.job_id)
self.stdout = os.path.join(spool, '%s.stdout' % self.job_id)
self.retcode = os.path.join(spool, '%s.retcode' % self.job_id)
self.out_results = os.path.join(spool,
'%s.results.pickle' % self.job_id)
if os.path.exists(self.stderr):
os.remove(self.stderr)
if os.path.exists(self.stdout):
os.remove(self.stdout)
if os.path.exists(self.retcode):
os.remove(self.retcode)
if os.path.exists(self.out_results):
os.remove(self.out_results)
options = []
cwd = os.path.abspath(os.getcwd())
variables = dict(SGE_O_WORKDIR=cwd,
PYTHONPATH=os.getenv('PYTHONPATH', '') + ':' + cwd)
# nice-looking name
self.sge_job_name = 'cm%s-%s' % (os.getpid(), self.job_id)
# Note that we get the official "id" later and we store it in
# self.sge_id
options.extend(
['-v', ",".join('%s=%s' % x for x in variables.items())])
# XXX: spaces
options.extend(['-e', self.stderr])
options.extend(['-o', self.stdout])
options.extend(['-N', self.sge_job_name])
options.extend(['-wd', cwd])
options.extend(['-V']) # pass all environment
options.extend(['-terse'])
compmake_bin = SGEJob.get_compmake_bin()
compmake_options = [
compmake_bin,
storage,
'--retcodefile',
self.retcode,
'--status_line_enabled',
'0',
'--colorize',
'0',
'-c',
'"make_single out_result=%s %s"' % (self.out_results, self.job_id),
]
if not all_disabled():
compmake_options += ['--contracts']
# XXX: spaces in variable out_result
write_stdin = ' '.join(compmake_options)
cmd = ['qsub'] + options
res = system_cmd_result(cwd,
cmd,
display_stdout=False,
display_stderr=True,
raise_on_error=True,
write_stdin=write_stdin,
capture_keyboard_interrupt=False)
self.sge_id = res.stdout.strip()
self.already_read = False
self.npolls = 0
self.told_you_ready = False
def testInvalidShapes(self):
for shape in Test.invalid_shapes:
v = np.zeros(shape=shape, dtype="uint8")
print("Trying with %s" % str(v.shape))
if not contracts.all_disabled():
self.assertRaises(Exception, Image_from_array, v)
def contract(*arg, **kwargs):
"""
Decorator for adding contracts to functions.
It is smart enough to support functions with variable number of
arguments and keyword arguments.
There are three ways to specify the contracts. In order of precedence:
- As arguments to this decorator. For example: ::
@contract(a='int,>0',b='list[N],N>0',returns='list[N]')
def my_function(a, b):
# ...
pass
- As annotations (supported only in Python 3): ::
@contract
def my_function(a:'int,>0', b:'list[N],N>0') -> 'list[N]':
# ...
pass
- Using ``:type:`` and ``:rtype:`` tags in the function's docstring: ::
@contract
def my_function(a, b):
"""
if not HAVE_CONTRACTS:
if isinstance(arg[0], types.FunctionType):
return arg[0]
else:
return lambda f: f
# this bit tags function as decorated
def tag_and_decorate(function, **kwargs):
@functools.wraps(function)
def __functools_wrap(function, **kwargs):
new_f = contracts.main.contracts_decorate(function, **kwargs)
cargs = copy.deepcopy(kwargs)
new_f.contract_kwargs = cargs or dict()
new_f.decorated = 'contract'
return new_f
return __functools_wrap(function, **kwargs)
# OK, this is black magic. You are not expected to understand this.
if arg:
if isinstance(arg[0], types.FunctionType):
# We were called without parameters
function = arg[0]
function.__doc__ = fixup_docstring(function.__doc__)
if contracts.all_disabled():
return function
try:
return tag_and_decorate(function, **kwargs)
except contracts.ContractSyntaxError as e:
# Erase the stack
raise contracts.ContractSyntaxError(e.error, e.where)
else:
msg = ('I expect that contracts() is called with '
'only keyword arguments (passed: %r)' % arg)
raise contracts.ContractException(msg)
else:
function.__doc__ = fixup_docstring(function.__doc__)
# We were called *with* parameters.
if contracts.all_disabled():
def tmp_wrap(function):
return function
else:
def tmp_wrap(function):
try:
return tag_and_decorate(function, **kwargs)
except contracts.ContractSyntaxError as e:
# Erase the stack
raise contracts.ContractSyntaxError(e.error, e.where)
return tmp_wrap
def contract(*arg, **kwargs):
"""
Decorator for adding contracts to functions.
It is smart enough to support functions with variable number of
arguments and keyword arguments.
There are three ways to specify the contracts. In order of precedence:
- As arguments to this decorator. For example: ::
@contract(a='int,>0',b='list[N],N>0',returns='list[N]')
def my_function(a, b):
# ...
pass
- As annotations (supported only in Python 3): ::
@contract
def my_function(a:'int,>0', b:'list[N],N>0') -> 'list[N]':
# ...
pass
- Using ``:type:`` and ``:rtype:`` tags in the function's docstring: ::
@contract
def my_function(a, b):
"""
if not HAVE_CONTRACTS:
if isinstance(arg[0], types.FunctionType):
return arg[0]
else:
return lambda f: f
# this bit tags function as decorated
def tag_and_decorate(function, **kwargs):
@functools.wraps(function)
def __functools_wrap(function, **kwargs):
new_f = contracts.main.contracts_decorate(function, **kwargs)
cargs = copy.deepcopy(kwargs)
new_f.contract_kwargs = cargs or dict()
new_f.decorated = 'contract'
return new_f
return __functools_wrap(function, **kwargs)
# OK, this is black magic. You are not expected to understand this.
if arg:
if isinstance(arg[0], types.FunctionType):
# We were called without parameters
function = arg[0]
function.__doc__ = fixup_docstring(function.__doc__)
if contracts.all_disabled():
return function
try:
return tag_and_decorate(function, **kwargs)
except contracts.ContractSyntaxError as e:
# Erase the stack
raise contracts.ContractSyntaxError(e.error, e.where)
else:
msg = ('I expect that contracts() is called with '
'only keyword arguments (passed: %r)' % arg)
raise contracts.ContractException(msg)
else:
function.__doc__ = fixup_docstring(function.__doc__)
# We were called *with* parameters.
if contracts.all_disabled():
def tmp_wrap(function):
return function
else:
def tmp_wrap(function):
try:
return tag_and_decorate(function, **kwargs)
except contracts.ContractSyntaxError as e:
# Erase the stack
raise contracts.ContractSyntaxError(e.error, e.where)
return tmp_wrap
def __init__(cls, name, bases, dct): # @NoSelf
ABCMeta.__init__(cls, name, bases, dct)
if all_disabled():
pass
else:
# print('Adding checks on Primitive %s: Switches.disable_all = %s' % (name, Switches.disable_all))
from mcdp_dp.primitive import NotSolvableNeedsApprox
from mcdp_dp.primitive import WrongUseOfUncertain
if 'solve' in cls.__dict__:
solve = cls.__dict__['solve']
def solve2(self, f):
if all_disabled():
return solve(self, f)
F = self.get_fun_space()
try:
F.belongs(f)
except NotBelongs as e:
msg = "Function passed to solve() is not in function space."
raise_wrapped(NotBelongs,
e,
msg,
F=F,
f=f,
dp=self.repr_long(),
exc=sys.exc_info())
try:
res = solve(self, f)
return res
except NotBelongs as e:
raise_wrapped(NotBelongs,
e,
'Solve failed.',
self=self,
f=f,
exc=sys.exc_info())
except NotImplementedError as e:
raise_wrapped(NotImplementedError,
e,
'Solve not implemented for class %s.' %
name,
exc=sys.exc_info())
except NotSolvableNeedsApprox:
raise
except WrongUseOfUncertain:
raise
except Exception as e:
raise_wrapped(Exception,
e,
'Solve failed',
f=f,
self=self,
exc=sys.exc_info())
setattr(cls, 'solve', solve2)
if 'get_implementations_f_m' in cls.__dict__:
get_implementations_f_r = cls.__dict__[
'get_implementations_f_r']
def get_implementations_f_r2(self, f, r):
if all_disabled():
return get_implementations_f_r(self, f, r)
F = self.get_fun_space()
R = self.get_fun_space()
try:
F.belongs(f)
except NotBelongs as e:
msg = "Function passed to get_implementations_f_r() is not in function space."
raise_wrapped(NotBelongs,
e,
msg,
F=F,
f=f,
dp=self.repr_long(),
exc=sys.exc_info())
try:
R.belongs(r)
except NotBelongs as e:
msg = "Function passed to get_implementations_f_r() is not in R space."
raise_wrapped(NotBelongs,
e,
msg,
R=R,
r=r,
dp=self.repr_long(),
exc=sys.exc_info())
try:
res = get_implementations_f_r(self, f, r)
except NotBelongs as e:
raise_wrapped(NotBelongs,
e,
'Solve failed.',
self=self,
f=f,
exc=sys.exc_info())
except NotImplementedError as e:
raise_wrapped(
NotImplementedError, e,
'Solve not implemented for class %s.' % name)
except NotSolvableNeedsApprox:
raise
except WrongUseOfUncertain:
raise
except Exception as e:
raise_wrapped(Exception,
e,
'Solve failed',
f=f,
self=self,
exc=sys.exc_info())
M = self.get_imp_space()
try:
for m in res:
M.belongs(m)
except NotBelongs as e:
raise_wrapped(
NotBelongs,
e,
'Result of get_implementations_f_r not in M.',
self=self,
m=m,
M=M,
exc=sys.exc_info())
return res
setattr(cls, 'get_implementations_f_r',
get_implementations_f_r2)
"all_disabled",
]
show_info = DuckietownConstants.debug_show_package_import_info
if on_duckiebot():
using_fake_contracts = True
if show_info:
logger.warning("Contracts are disabled becaused we are on Duckiebot.")
else:
try:
# use PyContracts if installed
# noinspection PyUnresolvedReferences
from contracts import contract, all_disabled
if all_disabled():
if show_info:
logger.warning(
"Using PyContracts, but it was disabled by the user.")
else:
if show_info:
logger.warning("Using PyContracts.")
using_fake_contracts = False
except ImportError:
if show_info:
logger.warning(
"Contracts are disabled becaused PyContracts not found.")
using_fake_contracts = True
if using_fake_contracts:
def contract(*arg, **kwargs):
'''
Decorator for adding contracts to functions.
It is smart enough to support functions with variable number of
arguments and keyword arguments.
There are three ways to specify the contracts. In order of precedence:
- As arguments to this decorator. For example: ::
@contract(a='int,>0',b='list[N],N>0',returns='list[N]')
def my_function(a, b):
# ...
pass
- As annotations (supported only in Python 3): ::
@contract
def my_function(a:'int,>0', b:'list[N],N>0') -> 'list[N]':
# ...
pass
- Using ``:type:`` and ``:rtype:`` tags in the function's docstring: ::
@contract
def my_function(a, b):
"""Function description.
:type a: int,>0
:type b: list[N],N>0
:rtype: list[N]
"""
pass
**Signature and docstrings**: The signature of the decorated
function is conserved. By default, the docstring is modified
by adding ``:type:`` and ``:rtype:`` definitions. To avoid that,
pass ``modify_docstring=False`` as a parameter.
**Contracts evaluation**: Note that all contracts for the arguments
and the return values
are evaluated in the same context. This make it possible to use
common variables in the contract expression. For example, in the
example above, the return value is constrained to be a list of the same
length (``N``) as the parameter ``b``.
**Using docstrings** Note that, by convention, those annotations must
be parseable as RestructuredText. This is relevant if you are using
Sphinx.
If the contract string has special RST characters in it, like ``*``,
you can include it in double ticks. `pycontracts` will remove
the double ticks before interpreting the string.
For example, the two annotations in this docstring are equivalent
for `pycontracts`, but the latter is better for Sphinx: ::
""" My function
:param a: First parameter
:type a: list(tuple(str,*))
:param b: First parameter
:type b: ``list(tuple(str,*))``
"""
:raise: ContractException, if arguments are not coherent
:raise: ContractSyntaxError
'''
# this bit tags function as decorated
def tag_and_decorate(function, **kwargs):
@functools.wraps(function)
def __functools_wrap(function, **kwargs):
new_f = contracts.main.contracts_decorate(function, **kwargs)
cargs = copy.deepcopy(kwargs)
new_f.contract_kwargs = cargs or dict()
new_f.decorated = 'contract'
return new_f
return __functools_wrap(function, **kwargs)
# OK, this is black magic. You are not expected to understand this.
if arg:
if isinstance(arg[0], types.FunctionType):
# We were called without parameters
function = arg[0]
function.__doc__ = fixup_docstring(function.__doc__)
if contracts.all_disabled():
return function
try:
return tag_and_decorate(function, **kwargs)
except contracts.ContractSyntaxError as e:
# Erase the stack
raise contracts.ContractSyntaxError(e.error, e.where)
else:
msg = ('I expect that contracts() is called with '
'only keyword arguments (passed: %r)' % arg)
raise contracts.ContractException(msg)
else:
function.__doc__ = fixup_docstring(function.__doc__)
# We were called *with* parameters.
if contracts.all_disabled():
def tmp_wrap(function):
return function
else:
def tmp_wrap(function):
try:
return tag_and_decorate(function, **kwargs)
except contracts.ContractSyntaxError as e:
# Erase the stack
raise contracts.ContractSyntaxError(e.error, e.where)
return tmp_wrap
def parmake_job2_new_process(args):
""" Starts the job in a new compmake process. """
(job_id, context) = args
compmake_bin = which('compmake')
db = context.get_compmake_db()
storage = db.basepath # XXX:
where = os.path.join(storage, 'parmake_job2_new_process')
if not os.path.exists(storage):
try:
os.makedirs(storage)
except:
pass
out_result = os.path.join(where, '%s.results.pickle' % job_id)
out_result = os.path.abspath(out_result)
cmd = [compmake_bin, storage]
if not all_disabled():
cmd += ['--contracts']
cmd += [
'--status_line_enabled',
'0',
'--colorize',
'0',
'-c',
'make_single out_result=%s %s' % (out_result, job_id),
]
cwd = os.getcwd()
cmd_res = system_cmd_result(cwd,
cmd,
display_stdout=False,
display_stderr=False,
raise_on_error=False,
capture_keyboard_interrupt=False)
ret = cmd_res.ret
if ret == CompmakeConstants.RET_CODE_JOB_FAILED: # XXX:
msg = 'Job %r failed in external process' % job_id
msg += indent(cmd_res.stdout, 'stdout| ')
msg += indent(cmd_res.stderr, 'stderr| ')
res = safe_pickle_load(out_result)
os.unlink(out_result)
result_dict_check(res)
raise JobFailed.from_dict(res)
elif ret != 0:
msg = 'Host failed while doing %r' % job_id
msg += '\n cmd: %s' % " ".join(cmd)
msg += '\n' + indent(cmd_res.stdout, 'stdout| ')
msg += '\n' + indent(cmd_res.stderr, 'stderr| ')
raise CompmakeBug(msg) # XXX:
res = safe_pickle_load(out_result)
os.unlink(out_result)
result_dict_check(res)
return res
def execute(self, spool):
db = self.db
# Todo: check its this one
storage = os.path.abspath(db.basepath)
# create a new spool directory for each execution
# otherwise we get confused!
self.stderr = os.path.join(spool, '%s.stderr' % self.job_id)
self.stdout = os.path.join(spool, '%s.stdout' % self.job_id)
self.retcode = os.path.join(spool, '%s.retcode' % self.job_id)
self.out_results = os.path.join(spool,
'%s.results.pickle' % self.job_id)
if os.path.exists(self.stderr):
os.remove(self.stderr)
if os.path.exists(self.stdout):
os.remove(self.stdout)
if os.path.exists(self.retcode):
os.remove(self.retcode)
if os.path.exists(self.out_results):
os.remove(self.out_results)
options = []
cwd = os.path.abspath(os.getcwd())
variables = dict(SGE_O_WORKDIR=cwd,
PYTHONPATH=os.getenv('PYTHONPATH', '') + ':' + cwd)
# nice-looking name
self.sge_job_name = 'cm%s-%s' % (os.getpid(), self.job_id)
# Note that we get the official "id" later and we store it in
# self.sge_id
options.extend(
['-v', ",".join('%s=%s' % x for x in variables.items())])
# XXX: spaces
options.extend(['-e', self.stderr])
options.extend(['-o', self.stdout])
options.extend(['-N', self.sge_job_name])
options.extend(['-wd', cwd])
options.extend(['-V']) # pass all environment
options.extend(['-terse'])
compmake_bin = SGEJob.get_compmake_bin()
compmake_options = [
compmake_bin, storage,
'--retcodefile', self.retcode,
'--status_line_enabled', '0',
'--colorize', '0',
'-c',
'"make_single out_result=%s %s"' % (self.out_results, self.job_id),
]
if not all_disabled():
compmake_options += ['--contracts']
# XXX: spaces in variable out_result
write_stdin = ' '.join(compmake_options)
cmd = ['qsub'] + options
res = system_cmd_result(cwd, cmd,
display_stdout=False,
display_stderr=True,
raise_on_error=True,
write_stdin=write_stdin,
capture_keyboard_interrupt=False)
self.sge_id = res.stdout.strip()
self.already_read = False
self.npolls = 0
self.told_you_ready = False
def __init__(cls, name, bases, dct): # @NoSelf
ABCMeta.__init__(cls, name, bases, dct)
if all_disabled():
pass
else:
# print('Adding checks on Primitive %s: Switches.disable_all = %s' % (name, Switches.disable_all))
from mcdp_dp.primitive import NotSolvableNeedsApprox
from mcdp_dp.primitive import WrongUseOfUncertain
if 'solve' in cls.__dict__:
solve = cls.__dict__['solve']
def solve2(self, f):
if all_disabled():
return solve(self, f)
F = self.get_fun_space()
try:
F.belongs(f)
except NotBelongs as e:
msg = "Function passed to solve() is not in function space."
raise_wrapped(NotBelongs, e, msg,
F=F, f=f, dp=self.repr_long(), exc=sys.exc_info())
try:
res = solve(self, f)
return res
except NotBelongs as e:
raise_wrapped(NotBelongs, e,
'Solve failed.', self=self, f=f, exc=sys.exc_info())
except NotImplementedError as e:
raise_wrapped(NotImplementedError, e,
'Solve not implemented for class %s.' % name, exc=sys.exc_info())
except NotSolvableNeedsApprox:
raise
except WrongUseOfUncertain:
raise
except Exception as e:
raise_wrapped(Exception, e,
'Solve failed', f=f, self=self, exc=sys.exc_info())
setattr(cls, 'solve', solve2)
if 'get_implementations_f_m' in cls.__dict__:
get_implementations_f_r = cls.__dict__['get_implementations_f_r']
def get_implementations_f_r2(self, f, r):
if all_disabled():
return get_implementations_f_r(self, f, r)
F = self.get_fun_space()
R = self.get_fun_space()
try:
F.belongs(f)
except NotBelongs as e:
msg = "Function passed to get_implementations_f_r() is not in function space."
raise_wrapped(NotBelongs, e, msg,
F=F, f=f, dp=self.repr_long(), exc=sys.exc_info())
try:
R.belongs(r)
except NotBelongs as e:
msg = "Function passed to get_implementations_f_r() is not in R space."
raise_wrapped(NotBelongs, e, msg,
R=R, r=r, dp=self.repr_long(), exc=sys.exc_info())
try:
res = get_implementations_f_r(self, f, r)
except NotBelongs as e:
raise_wrapped(NotBelongs, e,
'Solve failed.', self=self, f=f, exc=sys.exc_info())
except NotImplementedError as e:
raise_wrapped(NotImplementedError, e,
'Solve not implemented for class %s.' % name)
except NotSolvableNeedsApprox:
raise
except WrongUseOfUncertain:
raise
except Exception as e:
raise_wrapped(Exception, e,
'Solve failed', f=f, self=self, exc=sys.exc_info())
M = self.get_imp_space()
try:
for m in res:
M.belongs(m)
except NotBelongs as e:
raise_wrapped(NotBelongs, e,
'Result of get_implementations_f_r not in M.',
self=self, m=m, M=M, exc=sys.exc_info())
return res
setattr(cls, 'get_implementations_f_r', get_implementations_f_r2)
