def eval_lfunction_invmult_ops(fs, context):
if len(fs) == 1:
return fs[0]
elif len(fs) > 2:
mcdp_dev_warning('Maybe this should be smarter?')
rest = eval_lfunction_invmult_ops(fs[1:], context)
return eval_lfunction_invmult_ops([fs[0], rest], context)
else:
assert len(fs) == 2
Fs = tuple(map(context.get_ftype, fs))
if isinstance(Fs[0], Nat) and isinstance(Fs[1], Nat):
dp = InvMult2Nat(Nat(), Fs)
else:
if isinstance(Fs[0], RcompUnits) and \
isinstance(Fs[1], RcompUnits):
R = mult_table(Fs[0], Fs[1])
dp = InvMult2(R, Fs)
elif isinstance(Fs[0], Rcomp) and isinstance(Fs[1], Rcomp):
R = Rcomp()
dp = InvMult2(R, Fs)
else:
msg = 'Could not create invmult for types {}.'.format(Fs)
raise_desc(DPNotImplementedError, msg, Fs0=Fs[0], Fs1=Fs[1])
return create_operation_lf(context,
dp=dp,
functions=fs,
name_prefix='_invmult',
op_prefix='_ops',
res_prefix='_result')
def plot(self, pylab, axis, space, value, params={}):
params0 = dict(color_shadow=[1.0, 0.8, 0.8],
markers='k.',
markers_params={})
params0.update(params)
color_shadow = params0.pop('color_shadow')
markers = params0.pop('markers')
markers_params = params0.pop('markers_params')
if params0:
raise ValueError(params0)
self.axis = axis
self.check_plot_space(space)
minimals = [self._get_screen_coords(_, axis) for _ in value.minimals]
print 'minimals', minimals
R2 = PosetProduct((Rcomp(), Rcomp()))
v = R2.Us(minimals)
from mcdp_report.generic_report_utils import extra_space_finite
mcdp_dev_warning('incomplete PlotterUR')
logger.error('todo: change this to plot a line')
plot_upset_R2(pylab,
v,
axis,
extra_space_shadow=extra_space_finite,
color_shadow=color_shadow,
markers=markers,
marker_params=markers_params)
def go_loop2(dp, imp):
if do_imp:
m0, _f2, _r2 = dp._unpack_m(imp)
else:
m0 = _f2 = _r2 = None
(n1i, n1o) = go(dp.dp1, m0)
i = gg.newItem('|')
gg.propertyAppend(i, "shape", "plaintext")
o = gg.newItem('|')
gg.propertyAppend(o, "shape", "plaintext")
l0 = gg.newLink(i, n1i, label=str(dp.dp1.get_fun_space()))
l1 = gg.newLink(n1o, o, label=str(dp.dp1.get_res_space()))
gg.propertyAppend(l0, 'arrowhead', 'none')
gg.propertyAppend(l1, 'arrowhead', 'none')
loop_label = str(dp.F2)
mcdp_dev_warning('add option')
# if False:
# M = dp.get_imp_space_mod_res()
# M0 = dp.dp1.get_imp_space_mod_res()
# loop_label += ' M0: %s' % M0
# loop_label += ' M: %s' % M
l = gg.newLink(o, i, label=loop_label)
gg.propertyAppend(l, "color", "red")
gg.propertyAppend(l, "headport", "sw")
gg.propertyAppend(l, "tailport", "s")
gg.propertyAppend(l, 'arrowhead', 'none')
return (i, o)
def gg_deepcopy(ggraph):
try:
return deepcopy(ggraph)
except Exception as e:
logger.error(traceback.format_exc(e))
mcdp_dev_warning('Deep copy of gvgen graph failed: happens when in IPython.')
return ggraph
def __init__(self, nu):
R = Rcomp()
Fs = (R, R)
self.nl = nu
mcdp_dev_warning('This is not even true - it is the complicated function')
amap = ProductNMap(Fs, R)
WrapAMap.__init__(self, amap, None)
def do_plots_ndp(model_name, library, plots, extra_params):
possible = [p for p, _ in allplots]
plots = expand_string(plots, list(possible))
filename = model_name + '.mcdp'
x = library._get_file_data(filename)
data = {}
data['model_name'] = model_name
data['s'] = x['data']
data['filename'] = x['realpath']
data['params'] = parse_params(extra_params)
data['library'] = library
d = dict(allplots)
results = []
for p in plots:
try:
if p in d:
res = d[p](data)
else:
msg = 'Unknown plot.'
raise_desc(ValueError, msg, plot=p, available=sorted(d.keys()))
return # XXX
except CmdException as e:
mcdp_dev_warning('Add better checks of error.')
logger.error(e)
continue
except Exception as e:
logger.error('While creating %r' % p)
raise
assert isinstance(res, list), res
results.extend(res)
return results
def __init__(self, fs):
fs = tuple(fs)
self.fs = fs
mcdp_dev_warning('add promotion to SpaceProduct')
dom = PosetProduct(tuple(fi.get_domain() for fi in fs))
cod = PosetProduct(tuple(fi.get_codomain() for fi in fs))
Map.__init__(self, dom=dom, cod=cod)
def __init__(self,
gg,
parent,
yourname,
level=0,
tmppath=None,
style='default',
image_source=None,
skip_initial=True):
self.gg = gg
self.parent = parent
self.yourname = yourname
self.level = level
# self.library = library
if tmppath is None:
d = get_mcdp_tmp_dir()
prefix = 'GraphDrawingContext_tmppath'
tmppath = mkdtemp(dir=d, prefix=prefix)
mcdp_dev_warning('need to share icons')
self.tmppath = tmppath
self.image_source = image_source
self.all_nodes = []
self.set_style(style)
self.skip_initial = skip_initial
def gg_figure(r, name, ggraph, do_png=True, do_pdf=True, do_svg=True,
do_dot=True):
""" Adds a figure to the Report r that displays this graph
and also its source. """
f = r.figure(name, cols=1)
# save file in dot file
with tmpfile(".dot") as filename_dot:
with open(filename_dot, 'w') as fo:
s = get_dot_string(ggraph)
fo.write(s)
# if False:
# ff = '%s.dot' % id(r)
# print('writing to %r' % ff)
# with open(ff, 'w') as f2:
# f2.write(s)
prog = 'dot'
try:
if do_png:
with f.data_file('graph', MIME_PNG) as filename:
graphviz_run(filename_dot, filename, prog=prog)
if do_pdf:
with f.data_file('graph_pdf', MIME_PDF) as filename:
graphviz_run(filename_dot, filename, prog=prog)
if do_svg:
with f.data_file('graph_svg', MIME_SVG) as filename:
graphviz_run(filename_dot, filename, prog=prog)
from mcdp_report.embedded_images import embed_svg_images
data = open(filename).read()
soup = bs(data)
embed_svg_images(soup)
# does not keep doctype: s = to_html_stripping_fragment(soup)
# this will keep the doctype
s = str(soup)
s = s.replace('<fragment>', '')
s = s.replace('</fragment>', '')
write_bytes_to_file_as_utf8(s, filename)
except CmdException:
if MCDPConstants.test_ignore_graphviz_errors:
mcdp_dev_warning('suppressing errors from graphviz')
logger.error('Graphivz failed, but I will ignore it '
'because of MCDPConstants.test_ignore_graphviz_errors.')
else:
raise
# MIME_GRAPHVIZ
if do_dot:
with f.data_file('dot', MIME_PLAIN) as filename:
with open(filename, 'w') as f:
f.write(s)
return f
def add_connection(self, c):
self.info('Adding connection %r' % str(c))
if not c.dp1 in self.names:
raise_desc(DPSemanticError,
'Invalid connection: %r not found.' % c.dp1,
names=self.names,
c=c)
if not c.dp2 in self.names:
raise_desc(DPSemanticError,
'Invalid connection: %r not found.' % c.dp2,
names=self.names,
c=c)
mcdp_dev_warning('redo this check')
if self.is_new_function(c.dp2):
msg = "Cannot add connection to new function %r." % c.dp2
raise_desc(DPSemanticError, msg, c=c)
if self.is_new_resource(c.dp1):
msg = "Cannot add connection to new resource %r." % c.dp1
raise_desc(DPSemanticError, msg, c=c)
# Find if there is already a connection to c.dp2,c.s2
# for c0 in self.connections:
# if c0.dp2 == c.dp2 and c0.s2 == c.s2:
# msg = 'There is already a connection to function %r of %r.' % (c.s2, c.dp2)
# raise_desc(DPSemanticError, msg)
ndp1 = self.names[c.dp1]
ndp2 = self.names[c.dp2]
rnames = ndp1.get_rnames()
if not c.s1 in rnames:
msg = "Resource %r does not exist (known: %s)" % (
c.s1, format_list(rnames))
raise_desc(DPSemanticError, msg, known=rnames)
fnames = ndp2.get_fnames()
if not c.s2 in fnames:
msg = "Function %r does not exist (known: %s)" % (
c.s2, format_list(fnames))
raise_desc(DPSemanticError, msg, known=fnames)
R1 = ndp1.get_rtype(c.s1)
F2 = ndp2.get_ftype(c.s2)
# print('connecting R1 %s to R2 %s' % (R1, F2))
if not (R1 == F2):
msg = 'Connection between different spaces.'
raise_desc(DPSemanticError,
msg,
c=c,
F2=F2,
R1=R1,
ndp1=ndp1,
ndp2=ndp2)
self.connections.append(c)
def make_parallel_n(dps):
if len(dps) == 2:
return make_parallel(dps[0], dps[1])
if len(dps) == 0:
mcdp_dev_warning('This works but should be a special case.')
return ParallelN(tuple(dps))
def solve_r(self, r): # @UnusedVariable
mcdp_dev_warning('Not sure about this')
algo = InvMult2.ALGO
options = invmultL_solve_options(F=self.R,
R=self.F,
f=r,
n=self.nl,
algo=algo)
return self.F.Ls(options)
def solve_r(self, r):
# we want this to be pessimistic
mcdp_dev_warning('Not sure about this: is it L or U?')
algo = InvMult2.ALGO
options = invmultL_solve_options(F=self.R,
R=self.F,
f=r,
n=self.nu,
algo=algo)
return self.F.Ls(options)
def enlarge(b, f):
w = b[1] - b[0]
h = b[3] - b[2]
# print b, f, w, h
dw = fix_underflow(f) * fix_underflow(w)
dh = fix_underflow(h) * fix_underflow(f)
a = (b[0] - dw, b[1] + dw, b[2] - dh, b[3] + dh)
return a
mcdp_dev_warning('this is not correct (axis might be negative)')
return tuple(map(fix_underflow, a))
def get_providers_for_type(self, R):
options = []
tu = get_types_universe()
for id_ndp in self.options:
ndp = self.load_ndp(id_ndp)
fnames = ndp.get_fnames()
ftypes = ndp.get_ftypes(fnames)
for fname, F in zip(fnames, ftypes):
if tu.leq(R, F):
options.append((id_ndp, fname))
mcdp_dev_warning("assume that it is symmetric")
break
return options
def define_tests_mcdp_web(context):
"""
Looks for directories called *.mcdplib in the root of the package.
It also looks for the files *.mcdp_tests.yaml inside.
"""
for libname in enumerate_test_libraries():
c2 = context.child(libname)
c2.comp_dynamic(define_tests_rendering, libname)
if False:
c2.comp(test_mcdpweb_server, libname)
else:
mcdp_dev_warning('test_mcdpweb_server() is not enabled')
def should_I_skip_leq(self, context, c):
from mcdp_report.gg_ndp import is_simple
if self.policy_skip == 'never':
return False
elif self.policy_skip == 'if_second_simple':
second_simple = is_simple(context.names[c.dp2])
# first_simple = is_simple(context.names[c.dp1])
# any_simple = second_simple or first_simple
# both_simple = second_simple and first_simple
mcdp_dev_warning('Add options here')
skip = second_simple
return skip
else:
assert False, self.policy_skip
def eval_ndp_approx_lower(r, context):
from mcdp_lang.eval_ndp_imp import eval_ndp
from mcdp_dp.dp_transformations import get_dp_bounds
nl = r.level
ndp = eval_ndp(r.ndp, context)
dp = ndp.get_dp()
mcdp_dev_warning('make it better')
dpl, _ = get_dp_bounds(dp, nl, 1)
fnames = ndp.get_fnames()
rnames = ndp.get_rnames()
rnames = rnames if len(rnames) > 1 else rnames[0]
fnames = fnames if len(fnames) > 1 else fnames[0]
ndp2 = SimpleWrap(dpl, fnames, rnames)
return ndp2
def gg_get_formats(gg, data_formats):
check_isinstance(data_formats, (list, tuple))
res = []
mcdp_dev_warning('TODO: optimize gg_get_formats')
for data_format in data_formats:
if not data_format in allowed_formats:
msg = 'Invalid data format.'
raise_desc(ValueError, msg, data_formats=data_formats)
if data_format == 'dot':
d = get_dot_string(gg)
else:
d = gg_get_format(gg, data_format)
res.append(d)
return tuple(res)
def get_conversion(A, B):
""" Returns None if there is no need for a Conversion Map.
Otherwise returns a Conversion (< WrapAMap). """
tu = get_types_universe()
if tu.equal(A, B):
conversion = None
else:
try:
A_to_B, B_to_A = tu.get_super_conversion(A, B)
mcdp_dev_warning('not really sure of the semantics of this')
conversion = Conversion(A_to_B, B_to_A)
except NotLeq:
raise
return conversion
def eval_lfunction_Uncertain(r, context):
from mcdp_dp import UncertainGateSym
from .eval_lfunction_imp import eval_lfunction
from .helpers import create_operation_lf
assert isinstance(r, CDP.UncertainFun)
fl = eval_lfunction(r.lower, context)
fu = eval_lfunction(r.upper, context)
F = context.get_ftype(fl)
# Fu = context.get_rtype(fu)
mcdp_dev_warning('Do explicit check of types.')
dp = UncertainGateSym(F)
return create_operation_lf(context, dp=dp, functions=[fl, fu])
def decorate_arrow_function(self, l1):
propertyAppend = self.gg.propertyAppend
if self.style == STYLE_GREENRED:
propertyAppend(l1, 'color', COLOR_DARKGREEN)
propertyAppend(l1, 'arrowhead', 'normal')
propertyAppend(l1, 'arrowtail', 'none')
propertyAppend(l1, 'dir', 'both')
if self.style == STYLE_GREENREDSYM:
propertyAppend(l1, 'color', 'darkgreen')
propertyAppend(l1, 'fontcolor', COLOR_DARKGREEN)
propertyAppend(l1, 'arrowhead', 'dot')
propertyAppend(l1, 'arrowtail', 'none')
propertyAppend(l1, 'dir', 'both')
mcdp_dev_warning('this above has no effect')
propertyAppend(l1, 'fontcolor', COLOR_DARKGREEN)
def ndp_template_graph_enclosed(library, template, style, yourname,
data_format, direction, enclosed,
image_source):
assert isinstance(template, TemplateForNamedDP)
mcdp_dev_warning('Wrong - need assume ndp const')
context = library._generate_context_with_hooks()
ndp = template.get_template_with_holes(context)
if enclosed:
setattr(ndp, '_hack_force_enclose', True)
gg = gvgen_from_ndp(ndp,
style=style,
direction=direction,
image_source=image_source,
yourname=yourname)
return gg_get_format(gg, data_format)
def format_unit(R):
if R == BottomCompletion(TopCompletion(Any())):
return '[*]'
mcdp_dev_warning('fix bug')
if isinstance(R, BottomCompletion):
return '[*]'
if R == R_dimensionless:
# TODO: make option
return ''
elif isinstance(R, RcompUnits):
return '[%s]' % format_pint_unit_short(R.units)
elif isinstance(R, Rcomp):
return '[]'
elif hasattr(R, MCDPConstants.ATTR_LOAD_NAME):
n = getattr(R, MCDPConstants.ATTR_LOAD_NAME)
return '[`%s]' % n
else:
return '[%s]' % str(R)
def decorate_arrow_resource(self, l2):
propertyAppend = self.gg.propertyAppend
mcdp_dev_warning('this above has no effect')
propertyAppend(l2, 'fontcolor', COLOR_DARKRED)
if self.style == STYLE_GREENRED:
propertyAppend(l2, 'color', COLOR_DARKRED)
propertyAppend(l2, 'fontcolor', COLOR_DARKRED)
propertyAppend(l2, 'arrowtail', 'inv')
propertyAppend(l2, 'arrowhead', 'none')
propertyAppend(l2, 'dir', 'both')
if self.style == STYLE_GREENREDSYM:
propertyAppend(l2, 'color', COLOR_DARKRED)
propertyAppend(l2, 'arrowtail', 'dot')
propertyAppend(l2, 'arrowhead', 'none')
propertyAppend(l2, 'dir', 'both')
propertyAppend(l2, 'style', 'dashed')
def __init__(self, maps):
"""
maps = [f, g, h]
=== h o g o f
They are in order of application.
"""
self.maps = tuple(maps)
from mcdp_posets.types_universe import get_types_universe
tu = get_types_universe()
for i in range(len(maps) - 1):
first = maps[i]
second = maps[i + 1]
cod1 = first.get_codomain()
dom2 = second.get_domain()
tu.check_equal(cod1, dom2)
mcdp_dev_warning('Check that the composition makes sense')
dom = self.maps[0].get_domain()
cod = self.maps[-1].get_codomain()
Map.__init__(self, dom=dom, cod=cod)
def check_compact(id_ndp, ndp):
try:
ndp.check_fully_connected()
except NotConnected:
print('Skipping check_compact because %r not connected.' % id_ndp)
return
mcdp_dev_warning("""
I'm not really sure why compact needs to abstract().
It should be replaced with one that creates a new NDP
[ A ]--[ B ]
[ A ]--[ B ]
( [ A ]-|__)__ (_|-[ ] )
( [ A ]-| ) ( |-[ B] )
""")
ndp2 = ndp.compact()
check_same_interface(ndp, ndp2)
def plot_upset_R2(pylab,
us,
axis,
color_shadow,
extra_space_shadow=0.05,
color_lines='none',
markers='r.',
marker_params={}):
points = us.minimals
xmin, xmax, ymin, ymax = axis
for p in points:
if xmin <= p[0] <= xmax and (ymin <= p[1] <= ymax):
mcdp_dev_warning('This should be smarter')
# draw a little of them
if p[0] == xmax:
axis = enlarge_x(axis, extra_space_shadow)
if p[1] == ymax:
axis = enlarge_y(axis, extra_space_shadow)
plot_cone(pylab,
p,
axis,
color_shadow=color_shadow,
color_lines=color_lines)
else:
logger.debug('Warning: point %s not in axis %s' % (p, axis))
# cuteness
if markers is not None:
for p in points:
# This is to avoid underflow
# when using "finfo.tiny"
eps = finfo.eps
p = np.maximum(p, eps)
#print('plot_upset_R2: marker params: %s ' % marker_params)
pylab.plot(p[0], p[1], markers, clip_on=False, **marker_params)
def eval_lfunction_invplus_ops(fs, context):
if len(fs) == 1:
raise DPInternalError(fs)
elif len(fs) > 2: # pragma: no cover
mcdp_dev_warning('Maybe this should be smarter?')
rest = eval_lfunction_invplus_ops(fs[1:], context)
return eval_lfunction_invplus_ops([fs[0], rest], context)
else:
Fs = map(context.get_ftype, fs)
R = Fs[0]
if all(isinstance(_, RcompUnits) for _ in Fs):
tu = get_types_universe()
if not tu.leq(Fs[1], Fs[0]):
msg = 'Inconsistent units %s and %s.' % (Fs[1], Fs[0])
raise_desc(DPSemanticError, msg, Fs0=Fs[0], Fs1=Fs[1])
if not tu.equal(Fs[1], Fs[0]):
msg = 'This case was not implemented yet. Differing units %s and %s.' % (
Fs[1], Fs[0])
raise_desc(DPNotImplementedError, msg, Fs0=Fs[0], Fs1=Fs[1])
dp = InvPlus2(R, tuple(Fs))
elif all(isinstance(_, Rcomp) for _ in Fs):
dp = InvPlus2(R, tuple(Fs))
elif all(isinstance(_, Nat) for _ in Fs):
dp = InvPlus2Nat(R, tuple(Fs))
else: # pragma: no cover
msg = 'Cannot find operator for these types.'
raise_desc(DPInternalError, msg, Fs=Fs)
return create_operation_lf(context,
dp=dp,
functions=fs,
name_prefix='_invplus',
op_prefix='_',
res_prefix='_result')
def collect(I, imp):
I.belongs(imp)
res = {}
if isinstance(I, SpaceProduct):
for j, sub in enumerate(I.subs):
res.update(**collect(sub, imp[j]))
elif isinstance(I, Coproduct1Labels):
i, xi = I.unpack(imp)
Ii = I.spaces[i]
res.update(**collect(Ii, xi))
else:
pass
mcdp_dev_warning('a little more thought')
att = MCDPConstants.ATTRIBUTE_NDP_RECURSIVE_NAME
if not res and hasattr(I, att):
name = getattr(I, att)
return {name: imp}
return res
