Beispiel #1
0
 def list_views(self, request):
     available = []
     mf = MakeFiguresNDP(None)
     for x in sorted(mf.available()): 
         data_formats = mf.available_formats(x)
         available.append((x, data_formats))
     return {
         'available': available,
          'navigation': self.get_navigation_links(request),
         }
Beispiel #2
0
 def go():
     l = self.get_library(request)
     id_ndp = self.get_model_name(request)
     context = l._generate_context_with_hooks()
     ndp = l.load_ndp(id_ndp, context)
     mf = MakeFiguresNDP(ndp=ndp, library=l, yourname=id_ndp)
     data_format = str(request.matchdict['format'])
     data = mf.get_figure('ndp_graph_templatized', data_format)
     mime = get_mime_for_format(data_format)
     return response_data(request=request, data=data, content_type=mime)
Beispiel #3
0
 def __call__(self, data):
     ndp = get_ndp(data)
     library = data['library']
     mf = MakeFiguresNDP(ndp=ndp, library=library, yourname=None)
      
     formats = mf.available_formats(self.name)
     res = mf.get_figure(self.name, formats)
     
     results = [(_, self.name, res[_]) for _ in formats]
     return results
Beispiel #4
0
 def callback(tag0):
     source_code = tag0.string.encode('utf-8')
     context = Context()
     ndp = library.parse_ndp(source_code, realpath=realpath, context=context)
     mf = MakeFiguresNDP(ndp=ndp, library=library, yourname=None) # XXX
     formats = ['svg']
     if generate_pdf: 
         formats.append('pdf')
     data = mf.get_figure(which,formats)
     tag = make_tag(tag0, which, data, ndp=ndp, template=None)
     return tag
Beispiel #5
0
def allformats(context, id_ndp, ndp, libname):
    mf = MakeFiguresNDP(ndp=ndp, library=None, yourname=None)
    for name in mf.available():
        
        do_it = libname in ['basic', 'libtemplates', 'solver'] or \
            toss_coin(id_ndp, MCDPConstants.test_fraction_of_allreports) 
        
        if do_it:
            r = context.comp(allformats_report, id_ndp, ndp, libname, name,
                             job_id=name)
            context.add_report(r, 'allformats', id_ndp=id_ndp, which=name)
Beispiel #6
0
def figint01():
    ndp = parse_ndp("""
        mcdp {
        
        }
    """)
    mf = MakeFiguresNDP(ndp=ndp, library=None, yourname=None)

    for name in mf.available():
        formats = mf.available_formats(name)
        res = mf.get_figure(name, formats)
        print('%s -> %s %s ' % (name, formats, map(len, [res[f] for f in formats])))
Beispiel #7
0
def allformats_report(id_ndp, ndp, libname, which):
    from mcdp_web.images.images import get_mime_for_format
    r = Report(id_ndp + '-' + which)
    from mcdp_library_tests.tests import get_test_library
    library = get_test_library(libname)
    mf = MakeFiguresNDP(ndp=ndp, library=library, yourname=id_ndp)
    formats = mf.available_formats(which)
    try:
        res = mf.get_figure(which, formats)
    except DPSemanticError as e:
        if 'Cannot abstract' in str(e):
            r.text('warning', 'Not connected. \n\n %s' % e)
            return r
    print('%s -> %s %s ' % (which, formats, map(len, [res[f] for f in formats])))
    fig = r.figure()
    for f in formats:
        data = res[f]
        mime = get_mime_for_format(f)
        dn = DataNode(f, data=data, mime=mime)
        fig.add_child(dn)
    return r    
Beispiel #8
0
    def config(self, config):
        config.add_route('solver_image',
                         '/libraries/{library}/models/{model_name}/views/solver/compact_graph.{format}')
        config.add_view(self.view_ndp_graph_templatized, route_name='solver_image')
        config.add_route('solver_image2',
                         '/libraries/{library}/models/{model_name}/views/solver/{fun_axes}/{res_axes}/compact_graph.{format}')
        config.add_view(self.view_ndp_graph_templatized, route_name='solver_image2')

        config.add_route('solver2_image',
                         '/libraries/{library}/models/{model_name}/views/solver2/compact_graph.{format}')
        config.add_view(self.view_ndp_graph_templatized, route_name='solver2_image')
 
        mf = MakeFiguresNDP(None)
        for x in mf.available(): 
            route_name = 'make_figures_%s' % x
            url = self.get_lmv_url('{library}', '{model_name}', 'images') + '{which}.{format}'
            config.add_route(route_name, url)
            config.add_view(self.make_figures, route_name=route_name)
        
        route_name = 'list_views'
        url = self.get_lmv_url('{library}', '{model_name}', 'images')
        config.add_route(route_name, url)
        config.add_view(self.list_views, route_name=route_name, renderer='images/list_views.jinja2')
Beispiel #9
0
class MFCall():
    def __init__(self, name):
        self.name = name
        
    def __call__(self, data):
        ndp = get_ndp(data)
        library = data['library']
        mf = MakeFiguresNDP(ndp=ndp, library=library, yourname=None)
         
        formats = mf.available_formats(self.name)
        res = mf.get_figure(self.name, formats)
        
        results = [(_, self.name, res[_]) for _ in formats]
        return results
        
mf = MakeFiguresNDP(ndp=None)    
for name in mf.available():
    allplots.add((name, MFCall(name)))

# 
# class DP_MFCall():
#     def __init__(self, name):
#         self.name = name
#         
#     def __call__(self, data):
#         dp = get_dp(data)
# 
#         mf = MakeFiguresDP(dp=dp)
#         formats = mf.available_formats(self.name)
#         res = mf.get_figure(self.name, formats)
#         results = [(_, self.name, res[_]) for _ in formats]
def get_png_data_model(library, name, ndp, data_format): 
    mf = MakeFiguresNDP(ndp=ndp, library=library, yourname=name)
    f = 'fancy_editor' 
    res = mf.get_figure(f, data_format)
    return res
Beispiel #11
0
def make_figures(library, frag, raise_error_dp, raise_error_others, realpath, generate_pdf):
    """ Looks for codes like:

    <pre><code class="mcdp_ndp_graph_templatized">mcdp {
        # empty model
    }
    </code></pre>
    
        and creates a link to the image
    """

    soup = bs(frag)

    def go(selector, func):

        for tag in soup.select(selector):
            try:
                r = func(tag) 
                tag.replaceWith(r)
            except (DPSyntaxError, DPSemanticError) as e:
                if raise_error_dp:
                    raise
                print(e)
                t = soup.new_tag('pre', **{'class': 'error %s' % type(e).__name__})
                t.string = str(e)
                tag.insert_after(t)
            except Exception as e:
                if raise_error_others:
                    raise
                t = soup.new_tag('pre', **{'class': 'error %s' % type(e).__name__})
                t.string = traceback.format_exc(e)
                tag.insert_after(t)
     

    def make_tag(tag0, klass, data, ndp=None, template=None):
        
        if False:
            png = data['png']
            r = create_img_png_base64(soup, png, **{'class': klass})
            return r
        else:
            svg = data['svg']

            tag_svg = BeautifulSoup(svg, 'lxml', from_encoding='utf-8').svg
            tag_svg['class'] = klass

            if tag0.has_attr('style'):
                tag_svg['style'] = tag0['style']
            if tag0.has_attr('id'):
                tag_svg['id'] = tag0['id']

            if generate_pdf:
                pdf0 = data['pdf']
                pdf = crop_pdf(pdf0, margins=0)

                div = soup.new_tag('div')

                if tag0.has_attr('id'):
                    basename = tag0['id']
                elif ndp is not None and hasattr(ndp, ATTR_LOAD_NAME):
                    basename = getattr(ndp, ATTR_LOAD_NAME)
                elif template is not None and hasattr(template, ATTR_LOAD_NAME):
                    basename = getattr(template, ATTR_LOAD_NAME)
                else:
                    hashcode = hashlib.sha224(tag0.string).hexdigest()[-8:]
                    basename = 'code-%s' % (hashcode)

                docname = os.path.splitext(os.path.basename(realpath))[0]
                download = docname + "." + basename + "." + klass + '.pdf'
                a = create_a_to_data(soup, download=download, data_format='pdf', data=pdf)
                a['class'] = 'pdf_data'
                a.append(NavigableString(download))
                div.append(tag_svg)
                div.append(a)
                return div
            else:
                return tag_svg

    
    mf = MakeFiguresNDP(None,None,None)
    available = set(mf.available()) | set(mf.aliases)
    for which in available:
        selector = 'pre.%s' % which
        def callback(tag0):
            source_code = tag0.string.encode('utf-8')
            context = Context()
            ndp = library.parse_ndp(source_code, realpath=realpath, context=context)
            mf = MakeFiguresNDP(ndp=ndp, library=library, yourname=None) # XXX
            formats = ['svg']
            if generate_pdf: 
                formats.append('pdf')
            data = mf.get_figure(which,formats)
            tag = make_tag(tag0, which, data, ndp=ndp, template=None)
            return tag
        
        go(selector, callback)
    
    mf = MakeFiguresTemplate(None,None,None)
    available = set(mf.available()) | set(mf.aliases)
    for which in available:
        selector = 'pre.%s' % which
        def callback(tag0):
            source_code = tag0.string.encode('utf-8')
            context = Context()
            template = library.parse_template(source_code, realpath=realpath, context=context)

            mf = MakeFiguresTemplate(template=template, library=library, yourname=None) # XXX
            formats = ['svg']
            if generate_pdf: 
                formats.append('pdf')
            data = mf.get_figure(which,formats)
            tag = make_tag(tag0, which, data, ndp=None, template=template)
            return tag
        
        go(selector, callback)
        

#     go('pre.ndp_graph_normal', ndp_graph_normal_)
#     go('pre.ndp_graph_templatized', ndp_graph_templatized_)
#     go('pre.ndp_graph_templatized_labeled', ndp_graph_templatized_labeled_)
#     go('pre.ndp_graph_enclosed', ndp_graph_enclosed_)
#     go('pre.ndp_graph_expand', ndp_graph_expand_)
#     go('pre.template_graph_enclosed', template_graph_enclosed_)

    return str(soup)