Exemple #1
0
 def run(self,rr,elem,**kw):
   
     tplname = elem._meta.app_label + '/' + elem.__class__.__name__ + '/email.html'
     
     fn = find_config_file(tplname)
     logger.info("Using email template %s",fn)
     tpl = CheetahTemplate(file(fn).read())
     #~ tpl.self = elem # doesn't work because Cheetah adds itself a name 'self' 
     tpl.instance = elem
     html_content = unicode(tpl)
     
     from lino.modlib.mails.models import Mail
     m = Mail(sender=rr.get_user(),subject=elem.get_subject(),body=html_content)
     m.full_clean()
     m.save()
     #~ for t,n,a in elem.get_recipients():
         #~ m.recipient_set.create(type=t,address=a,name=n)
     for t,c in elem.get_mailable_recipients():
         r = Recipient(mail=m,type=t,partner=c)
         r.full_clean()
         r.save()
         #~ m.recipient_set.create(type=t,partner=c)
     a = Attachment(mail=m,owner=elem)
     a.save()
     kw.update(open_url=rr.ui.get_detail_url(m))
     return rr.ui.success(**kw)
 def tecodata(self,site='US-HA1',upload=None,model=None,callback=None,**kwargs):
     ''' usertasks returns celery tasks perform and the link to the task result page.
         task_name-  string optional
         pageNumber and nPerPage is optional
     ''' 
     #db=self.db[self.database][self.collection]
     if model:
         if upload:
             yrs=self.db[self.database]['uploaded_grass'].find({'Site':site,'user':upload}).distinct('year')
         else:
             yrs=self.db[self.database]['years'].find_one({'Site':site,'type':model})['years']
     else:
         if upload:
             yrs=self.db[self.database]['uploaded_data'].find({'Site':site,'user':upload}).distinct('Year')
         else:
         #yrs=self.db[self.database][self.collection].find({'Site':site}).distinct('Year')
             yrs=self.db[self.database]['years'].find_one({'Site':site,'type':'default'})['years']
     yrs.sort()
     nameSpace = dict(years=yrs,site=site,start=yrs[0],end=yrs[-1])
     if callback:
         cherrypy.response.headers['Content-Type'] = "application/json"
         t = Template(file = templatepath + '/tecodata_call.tmpl', searchList=[nameSpace])
         return str(callback) + "(" + json.dumps({'html':t.respond()}) + ")"
     else:
         cherrypy.response.headers['Content-Type'] = "text/html"
         t = Template(file = templatepath + '/tecodata.tmpl', searchList=[nameSpace])
         return t.respond()
Exemple #3
0
 def search( self, searchQuery="", where="" ):
     symbols = {}
     symbols["searchQuery"] = searchQuery
     symbols["where"]       = where
     symbols["title"]       = ""
     template = Template( file=os.path.join( const.DATA_ROOT, "assets/webui/search.html.tmpl" ), searchList=symbols )
     return template.respond()
Exemple #4
0
    def on_feed_output(self, feed):
        try:
            from Cheetah.Template import Template
        except:
            raise PluginError('make_html requires Cheetah template engine')

        config = feed.config['make_html']

        filename = os.path.expanduser(config['template'])
        output = os.path.expanduser(config['file'])

        import warnings
        warnings.simplefilter('ignore', UserWarning)

        # create the template
        template = Template(file=filename)

        # populate it
        template.accepted = feed.accepted
        template.rejected = feed.rejected
        template.entries = feed.entries

        f = open(output, 'w')
        f.write(template.respond().encode('utf-8'))
        f.close()
Exemple #5
0
 def usertasks(self,task_name=None,pageNumber=1,nPerPage=1500,callback=None,**kwargs):
     ''' usertasks returns celery tasks perform and the link to the task result page.
         task_name-  string optional
         pageNumber and nPerPage is optional
     ''' 
     db=self.db[self.database][self.collection]
     try:
         page=int(pageNumber)
         perPage=int(nPerPage)
     except:
         page=1
         perPage=100
     try:
         if cherrypy.request.login:
             user = cherrypy.request.login
         else:
             user = "******"
     except:
         pass 
     if not task_name:
         res=db.find({'user':user}).skip((page-1)* int(nPerPage)).limit(int(nPerPage)).sort([('timestamp',-1)]) 
         rows=db.find({'user':user}).count()
     else:
         res=db.find({'user':user,'task_name':task_name}).skip((page-1) * int(nPerPage)).limit(int(nPerPage)).sort([('timestamp',-1)])
         rows=db.find({'user':user,'task_name':task_name}).count()
     ePage= int(math.ceil(float(rows)/float(perPage)))
     nameSpace = dict(tasks=res,page=page,endPage=ePage)#tresult)
     #t = Template(file = templatepath + '/usertasks.tmpl', searchList=[nameSpace])
     if callback:
         t = Template(file = templatepath + '/usertasks_call.tmpl', searchList=[nameSpace])
         return str(callback) + "(" + json.dumps({'html':t.respond()}) + ")"
     else:
         t = Template(file = templatepath + '/usertasks.tmpl', searchList=[nameSpace])
         return t.respond()
Exemple #6
0
    def three(self, **kwargs):
        """ Accept webserver parms and show Indexers page """
        if kwargs:
            if 'access' in kwargs:
                cfg.cherryhost.set(kwargs['access'])
            cfg.enable_https.set(kwargs.get('enable_https',0))
            cfg.autobrowser.set(kwargs.get('autobrowser',0))
            cfg.username.set(kwargs.get('web_user', ''))
            cfg.password.set(kwargs.get('web_pass', ''))
            if not cfg.username() or not cfg.password():
                sabnzbd.interface.set_auth(cherrypy.config)

        # Create Indexers page
        info = self.info.copy()
        info['num'] = '» %s' % T('Step Three')
        info['number'] = 3
        info['newzbin_user'] = cfg.newzbin_username()
        info['newzbin_pass'] = cfg.newzbin_password.get_stars()
        info['newzbin_bookmarks'] = cfg.newzbin_bookmarks()
        info['newzbin_url'] = cfg.newzbin_url()
        info['matrix_user'] = cfg.matrix_username()
        info['matrix_apikey'] = cfg.matrix_apikey()
        info['T'] = Ttemplate
        template = Template(file=os.path.join(self.__web_dir, 'three.html'),
                            searchList=[info], compilerSettings=sabnzbd.interface.DIRECTIVES)
        return template.respond()
Exemple #7
0
    def four(self, **kwargs):
        """ Accept Indexers and show Restart screen """
        if kwargs:
            if 'newzbin_user' in kwargs and 'newzbin_pass' in kwargs:
                cfg.newzbin_username.set(kwargs.get('newzbin_user',''))
                cfg.newzbin_password.set(kwargs.get('newzbin_pass',''))
            cfg.newzbin_bookmarks.set(kwargs.get('newzbin_bookmarks', '0'))
            if 'matrix_user' in kwargs and 'matrix_apikey' in kwargs:
                cfg.matrix_username.set(kwargs.get('matrix_user',''))
                cfg.matrix_apikey.set(kwargs.get('matrix_apikey',''))

        config.save_config()

        # Show Restart screen
        info = self.info.copy()
        info['num'] = '» %s' % T('Step Four')
        info['number'] = 4
        info['helpuri'] = 'http://wiki.sabnzbd.org/'
        info['session'] = cfg.api_key()

        info['access_url'], info['urls'] = self.get_access_info()
        info['T'] = Ttemplate

        template = Template(file=os.path.join(self.__web_dir, 'four.html'),
                            searchList=[info], compilerSettings=sabnzbd.interface.DIRECTIVES)
        return template.respond()
Exemple #8
0
    def get(self,mode='gallery', pagenum=1):
        pagenum = int(pagenum)
        l_skel = Skel()
        l_skel.title = "Smashed.in :: OverHeards"
        items_per_page = 10
        offset = (pagenum - 1) * items_per_page

        #Head
        head_path = os.path.join (os.path.dirname(__file__), 'templates/oh-head.tmpl')
        l_skel.addtohead(str((Template.compile(file=head_path)(searchList={}))))

        #body
        path = os.path.join (os.path.dirname (__file__), 'templates/oh-body.tmpl')
        if mode == "gallery":
            meme_query = UserMemeDb.query(UserMemeDb.mode == 'gallery').order(-UserMemeDb.date)
        else:
            meme_query = UserMemeDb.query(UserMemeDb.userid == self.user_id).order(-UserMemeDb.date)
        total_items = meme_query.count()
        memes = meme_query.fetch (items_per_page, offset=offset)
            
        template_values = {
            "memes" : memes,
            "currentpage" : pagenum,
            "totalpagecount" : math.ceil(total_items / float(items_per_page)),
            "mode" : mode,
            'isLoggedIn': '%s' %self.logged_in
            }

        l_skel.addtobody (str((Template.compile(file=path)(searchList=template_values))))

        self.response.out.write(l_skel.gethtml())	   
Exemple #9
0
    def two(self, **kwargs):
        """ Accept server and show internal web server page """
        # Save server details
        if kwargs:
            kwargs['enable'] = 1
            sabnzbd.interface.handle_server(kwargs)

        # Create web server page
        info = self.info.copy()
        info['num'] = '» %s' % T('Step Two')
        info['number'] = 2
        info['T'] = Ttemplate

        host = cfg.cherryhost()
        info['host'] = host
        # Allow special operation if host is not one of the defaults
        if host not in ('localhost','0.0.0.0'):
            info['custom_host'] = True
        else:
            info['custom_host'] = False

        info['have_ssl'] = bool(sabnzbd.newswrapper.HAVE_SSL)
        info['enable_https'] = cfg.enable_https()
        info['autobrowser'] = cfg.autobrowser()
        info['web_user'] = cfg.username()
        info['web_pass'] = cfg.password()

        template = Template(file=os.path.join(self.__web_dir, 'two.html'),
                            searchList=[info], compilerSettings=sabnzbd.interface.DIRECTIVES)
        return template.respond()
Exemple #10
0
    def edit(self, id = 0):
        # we really want id as an integer. Since GET/POST parameters
        # are always passed as strings, let's convert it.
        id = int(id)

        if id > 0:
            # if an id is specified, we're editing an existing contact.
            contact = Contact.get(id)
            title = "Edit Contact"
        else:
            # if no id is specified, we're entering a new contact.
            contact = None
            title = "New Contact"


        # In the following template code, please note that we use
        # Cheetah's $getVar() construct for the form values. We have
        # to do this because contact may be set to None (see above).
        template = Template('''
            <h2>$title</h2>

            <form action="./store" method="POST">
                <input type="hidden" name="id" value="$id" />
                Last Name: <input name="lastName" value="$getVar('contact.lastName', '')" /><br/>
                First Name: <input name="firstName" value="$getVar('contact.firstName', '')" /><br/>
                Phone: <input name="phone" value="$getVar('contact.phone', '')" /><br/>
                Email: <input name="email" value="$getVar('contact.email', '')" /><br/>
                URL: <input name="url" value="$getVar('contact.url', '')" /><br/>
                <input type="submit" value="Store" />
            </form>
        ''', [locals(), globals()])

        return template.respond()
Exemple #11
0
    def get(self, resource):
        resid = resource 
	l_skel = Skel()
	l_skel.title = "Smashed.in :: OverHeards"

        meme_query = UserMemeDb.query(UserMemeDb.resid == resid)
        memes = meme_query.fetch(1)
        meme = memes[0]
        template_values = {
            'memeurl':   '/res/download/%s' % meme.blobid,
            'conturl':   '/oh/%s' % meme.resid,
            'localid':   '%s' % meme.resid,
            'mode'   :   '%s' %meme.mode,
            'shareid':   '%s' % meme.shareid,
            'currentid': '%s' % meme.resid,
            'commentid': '%s' % meme.commentid,
            'isLoggedIn': '%s' %self.logged_in,
            'tags'      : ','.join(meme.tags)
            
            }

	#Head
	head_path = os.path.join (os.path.dirname(__file__), 'templates/ohview-head.tmpl')
	l_skel.addtohead(str((Template.compile(file=head_path)(searchList=template_values))))

	#body
        path = os.path.join (os.path.dirname (__file__), 'templates/ohview-body.tmpl')
	l_skel.addtobody (str((Template.compile(file=path)(searchList=template_values))))

        self.response.out.write(l_skel.gethtml())
Exemple #12
0
    def infopage(self):
        t = Template(file=os.path.join(SCRIPTDIR, 'templates',
                                       'info_page.tmpl'),
                     filter=EncodeUnicode)
        t.admin = ''

        if config.get_server('tivo_mak') and config.get_server('togo_path'):
            t.togo = '<br>Pull from TiVos:<br>'
        else:
            t.togo = ''

        for section, settings in config.getShares():
            plugin_type = settings.get('type')
            if plugin_type == 'settings':
                t.admin += ('<a href="/TiVoConnect?Command=Settings&amp;' +
                            'Container=' + quote(section) +
                            '">Settings</a><br>')
            elif plugin_type == 'togo' and t.togo:
                for tsn in config.tivos:
                    if tsn and 'address' in config.tivos[tsn]:
                        t.togo += ('<a href="/TiVoConnect?' +
                            'Command=NPL&amp;Container=' + quote(section) +  
                            '&amp;TiVo=' + config.tivos[tsn]['address'] +
                            '">' + config.tivos[tsn]['name'] +
                            '</a><br>')

        self.send_html(str(t))
    def test_normalizePreprocessorArgVariants(self):
        src='%set foo = 12\n%%comment\n$(@foo*10)'

        class Settings1: tokens = '@ %' 
        Settings1 = Settings1()
            
        from Cheetah.Template import TemplatePreprocessor
        settings = Template._normalizePreprocessorSettings(Settings1)
        preprocObj = TemplatePreprocessor(settings)

        def preprocFunc(source, file):
            return '$(12*10)', None

        class TemplateSubclass(Template):
            pass

        compilerSettings = {'cheetahVarStartToken':'@',
                            'directiveStartToken':'%',
                            'commentStartToken':'%%',
                            }
        
        for arg in ['@ %',
                    {'tokens':'@ %'},
                    {'compilerSettings':compilerSettings},
                    {'compilerSettings':compilerSettings,
                     'templateInitArgs':{}},
                    {'tokens':'@ %',
                     'templateAPIClass':TemplateSubclass},
                    Settings1,
                    preprocObj,
                    preprocFunc,                    
                    ]:
            
            klass = Template.compile(src, preprocessors=arg)
            assert str(klass())=='120'
def makeConfiguredParamsHeader( templateName, variableList ):
        comments = []
        template = Template( file=templatesPath() + templateName + '.tmpl' )
        p = 0
        for var in variableList:
                p += 1
                if var.arrayInfo != None:
                        typ = 'Parameter_Text'
                        default = 'null, Null_Unbounded_String' #'"'+var.arrayInfo.sqlArrayDefaultDeclaration( var.getDefaultAdaValue() )+'"'
                elif( isIntegerTypeInPostgres( var )):
                        typ = 'Parameter_Integer'
                        default = '0'
                elif( isBigIntTypeInPostgres( var )):
                        typ = 'Parameter_Bigint'
                        default = '0'
                elif( var.isStringType() ):
                        typ = 'Parameter_Text'
                        default = 'null, Null_Unbounded_String';
                elif( var.isNumericType() ):
                        typ = 'Parameter_Float'
                        default = '0.0'
                elif ( var.isDateType() ):
                        typ = 'Parameter_Date'
                        default = 'Clock'
                s = '{:>4d} : {:<24} : {:<18} : {:<20} : {:>8} '.format( p, var.adaName, typ, var.adaType, default )
                comments.append( s )
        template.n = p 
        template.comments = comments;
        return str( template );
Exemple #15
0
 def output_result(self, methodname, template, result, action_metadata, outf,
                   return_template=False):
     """
     Renders a response body
     """
     from Cheetah.Template import Template
     # any result with custom serialization
     if action_metadata.get('return_type') == 'plain':
         outf.write(str(result))
     elif callable(result):
         outf.write(result())
     # JSON with simple serialization (dict -> string)
     elif action_metadata.get('return_type') == 'json':
         json.dump(result, outf)
     # Template
     elif type(result) is DictType:
         self.add_globals(result, methodname, action_metadata)
         if template.endswith('.tmpl'):
             template_class = self._get_template_class(template[:-5])
             tpl_ans = template_class(searchList=[result, self.args])
         else:
             tpl_ans = Template(template, searchList=[result, self.args])
         if return_template:
             return tpl_ans
         tpl_ans.respond(CheetahResponseFile(outf))
Exemple #16
0
def addSymbolToOrig(conf,inputs,outputs):
    import sys
    from Cheetah.Template import Template
    f=open(conf["main"]["dataPath"]+"/symbols.sym","r")
    newContent=""
    str=f.read()
    f.close()
    i=0
    b=str.split('SYMBOL\n')
    for a in b:
        if a!="" and a!='\n':
            if i+1 < len(b):
                if newContent!="":
                    newContent+='SYMBOL\n'+a
                else:
                    newContent+=a
            else:
                print >> sys.stderr,a[:len(a)-4]
                newContent+='SYMBOL\n'+a[:len(a)-5]
            i+=1
    t=Template(file=conf["main"]["templatesPath"]+"/Manager/Styler/Symbols.sym.tmpl",searchList={"conf": conf,"inputs": inputs,"outputs": outputs})
    newContent+=t.__str__().replace('SYMBOLSET\n',"")
    f=open(conf["main"]["dataPath"]+"/symbols.sym","w")
    f.write(newContent)
    f.close()
    outputs["Result"]["value"]=zoo._("Symbol added.")
    return 3
Exemple #17
0
def application(environ, start_response):

	connector = MySQLdb.connect(host="192.168.30.10",
                                    db="personal",
                                    user="******",
                                    passwd="vagrant",
                                    charset="utf8")
	cursor = connector.cursor()
	cursor.execute("SELECT * FROM info")
	result = cursor.fetchall()

	start_response('200 OK', [('Content-Type', 'text/html')])

	tpl = Template(file="/var/www/wsgi/test/tpl/result.tpl")
	tpl.data = []

	for row in result:
		if str(row[3]) == "M":
			tpl.data.append((str(row[0]), str(row[2]), "Man", str(row[4]), str(row[5])))
		else:
			tpl.data.append((str(row[0]), str(row[2]), "Woman", str(row[4]), str(row[5])))
			
	cursor.close()
	connector.close()

	return tpl.respond().encode('utf-8')
Exemple #18
0
 def test_int(self):
     from Cheetah.Template import Template
     t = Template('''
         #def intify(val)
             #return $int(val)
         #end def''', compilerSettings={'useStackFrames' : False})
     self.assertEquals(5, t.intify('5'))
 def ignore(self, pn, ver, *args, **kwargs):
     """Ignore particular version of pkg"""
     pkgs = Packages.select(AND(Packages.q.packageName == pn,
                           Packages.q.latestReleaseVersion == ver))
     print "PN", pn, "VER", ver
     if pkgs.count() == 0:
         yield self.error_form("Package not ignored.")
     pkg = pkgs[0]
     template = Template('''
         <form method="get" action="/ignore_action/">
         <div>
         <b>Ignore version $pkg.latestReleaseVersion of $pkg.packageName</b>
         <br>
         <br>This will ignore this particular freshmeat release version,
         <b>not</b> the entire pacakge.</b><br><br>
         Freshmeat Release Date: $pkg.latestReleaseDate<br><br>
         <a href="http://packages.gentoo.org/search/?sstring=$pkg.packageName">
         $pkg.portageCategory/$pkg.packageName-$pkg.portageVersion</a> [
         <a class="nav" href="http://freshmeat.net/projects/$pkg.packageName/"
         title="Freshmeat Latest Release">$pkg.latestReleaseVersion</a> ]
         </div><div><br />
         <input type="submit" value="Ignore" />
         <input type='hidden' name='pn' value='$pkg.packageName'>
         <input type='hidden' name='ver' value='$pkg.latestReleaseVersion'>
         </div>
         </form>
     ''', [locals(), globals()])
     content = template.respond()
     yield self.plain_page(content)
 def add_known(self, pn, *args, **kwargs):
     """Show form for editing known matches"""
     packages = KnownGood.select(KnownGood.q.fmName == pn )
     if packages.count():
         fullName = "%s/%s" % (packages[0].portageCategory,
                               packages[0].packageName)
     else:
         fullName = "No matches found!"
     template = Template('''
         <b>Edit Portage name for:</b> $pn
         <br><br>
         If a Freshmeat package name does not match,
         you can re-map it to a new Gentoo category and package name.
         <br><br>
         <table>
         <tr> <th>Existing match</th> 
         <th>New package category</th> <th>New package name</tr>
         <tr class="alt">
         <td>$fullName </td>
         <td>
         <form name='add_known' action="/known_submit" method=post>
         <input type='input' name='new_cat' value=""></td>
         <td><input type='input' name='new_pn' value=""></td>
         <input type='hidden' name='fmpn' value="$pn">
         </tr>
         </table>
         <center><input type='submit' value="Submit"></center>
         </form>''', [locals(), globals()])
     yield self.plain_page(template.respond())
Exemple #21
0
def generate_download_script(root, arch, tmpl):
    package_name_list = get_packages_name_list(get_file_list(root, arch))

    tmpl = Template(file=tmpl, searchList={'packages':package_name_list})

    with open('install_packages.sh', 'w') as f:
        f.write(tmpl.respond())
Exemple #22
0
    def edit(self, id=0):
        # we really want id as an integer. Since GET/POST parameters
        # are always passed as strings, let's convert it.
        id = int(id)

        if id > 0:
            # if an id is specified, we're editing an existing book.
            book = Book.get(id)
            title = "Edit Book"
        else:
            # if no id is specified, we're entering a new book.
            book = None
            title = "New Book"

        template = Template('''
            <h2>$title</h2>

            <form action="./store" method="POST">
                <input type="hidden" name="id" value="$id" />
                Title: <input name="title" value="$getVar('book.title', '')" /><br/>
                Author: <input name="author" value="$getVar('book.author', '')" /><br/>
                <input type="submit" value="Store" />
            </form>
        ''', [locals(), globals()])

        return template.respond()
def writeProjectFile( database ):
        outfile = file( paths.getPaths().etcDir + database.databaseName+'.gpr' , 'w' );
        template = Template( file=templatesPath() + 'project_file.tmpl' )
        template.date = datetime.datetime.now()
        template.projectName = adafyName(database.databaseName)
        outfile.write( str(template) )
        outfile.close()
Exemple #24
0
def do_replay_from_yaml (args):
    print "Replaying using %s" % args.yamlfile

    replay_file_name = "%s_replay.sh" % args.project
    replay_file = open (replay_file_name, "w")
    bpy = skel_bpy.skel_bpy (args.yamlfile)

    # Generate replay_yaml.sh shell script
    from Cheetah.Template import Template
    template_file = open (os.path.expanduser("~/.skel/templates/replay_yaml.tmpl"), 'r')
    t = Template(file=template_file)
    t.bpy = bpy

    # No, I don't like these either.
    t.yamlfile = args.yamlfile
    t.project = args.project
    t.force = args.force

    replay_file.write (str(t) )

    replay_file.close()

    # Adjust the permissions of the replay script to make it runnable by user
    os.chmod (replay_file_name, stat.S_IXUSR | stat.S_IWUSR | stat.S_IRUSR)

    # Run it
    subprocess.check_call ("./%s" % replay_file_name)
Exemple #25
0
 def get_data(self, entry, metadata):
     template = Template(self.data.decode(self.encoding),
                         compilerSettings=self.settings)
     template.metadata = metadata
     template.path = entry.get('realname', entry.get('name'))
     template.source_path = self.name
     return template.respond()
Exemple #26
0
    def infopage(self):
        self.send_response(200)
        self.send_header('Content-type', 'text/html')
        self.end_headers()
        t = Template(file=os.path.join(SCRIPTDIR, 'templates',
                                       'info_page.tmpl'))
        t.admin = ''
        for section, settings in config.getShares():
            if 'type' in settings and settings['type'] == 'admin':
                t.admin += '<a href="/TiVoConnect?Command=Admin&Container=' + section\
                           + '">pyTivo Web Configuration</a><br>'\
                           + '<a href="/TiVoConnect?Command=NPL&Container=' + section\
                           + '">pyTivo ToGo</a><br>'
        if t.admin == '':
            t.admin = '<br><b>No Admin plugin installed in pyTivo.conf</b><br> If you wish to use'\
                      + ' the admin plugin add the following lines to pyTivo.conf<br><br>'\
                      + '[Admin]<br>type=admin'

        t.shares = 'Video shares:<br/>'
        for section, settings in config.getShares():
            if settings.get('type') == 'video':
                t.shares += '<a href="TiVoConnect?Command=QueryContainer&Container=' + section\
                    + '">' +  section + '</a><br/>'
        
        self.wfile.write(t)
        self.end_headers()
Exemple #27
0
    def get_config_from_template(self, tmpl_path, vars_dict):
        logging.debug("template path is %s", tmpl_path)
        logging.debug("vars_dict is %s", vars_dict)

        if not os.path.exists(tmpl_path) or not vars_dict:
            logging.info("Template dir or vars_dict is None!")
            return {}

        searchList = []
        copy_vars_dict = deepcopy(vars_dict)
        for key, value in vars_dict.iteritems():
            if isinstance(value, dict):
                temp = copy_vars_dict[key]
                del copy_vars_dict[key]
                searchList.append(temp)
        searchList.append(copy_vars_dict)

        # Load base template first if it exists
        base_config = {}
        base_tmpl_path = os.path.join(os.path.dirname(tmpl_path), 'base.tmpl')
        if os.path.isfile(base_tmpl_path) and base_tmpl_path != tmpl_path:
            base_tmpl = Template(file=base_tmpl_path, searchList=searchList)
            base_config = json.loads(base_tmpl.respond(), encoding='utf-8')
            base_config = json.loads(json.dumps(base_config), encoding='utf-8')

        # Load specific template for current adapter
        tmpl = Template(file=open(tmpl_path, "r"), searchList=searchList)
        config = json.loads(tmpl.respond(), encoding='utf-8')
        config = json.loads(json.dumps(config), encoding='utf-8')

        # Merge the two outputs
        config = util.merge_dict(base_config, config)

        logging.debug("get_config_from_template resulting %s", config)
        return config
Exemple #28
0
def generate_makefile_from_yaml (args):

    bpy = skel_bpy.skel_bpy (args.yamlfile)

    template_file_name = "~/.skel/templates/Makefile.tmpl"
    outfilename = "Makefile"

    # Only proceed if outfilename does not already exist, or if -f was used
    if os.path.exists (outfilename) and not args.force:
        print "%s exists, aborting. Delete the file or use -f to overwrite." % outfilename
        return 999

    skel_file = open (outfilename, 'w')


    # Now for the Cheetah magic:
    from Cheetah.Template import Template
    template_file = open (os.path.expanduser(template_file_name), 'r')
    t = Template(file=template_file)

    t.bpy = bpy
    t.project = args.project
    t.bpfile = args.bpfile
    t.noxml = args.noxml
    skel_file.write (str(t) )
Exemple #29
0
def gen_suite_with_args (parent_parser):
    args = pparse_command_line (parent_parser)

    print "Generating test suite using %s" % args.yamlfile

    suite_gen_file_name = "%s_gen_suite.sh" % args.project
    suite_gen_file = open (suite_gen_file_name, "w")
    plan = skel_test_plan.skel_test_plan (args.yamlfile)

    # Generate gen_suite.sh shell script
    from Cheetah.Template import Template
    template_file = open (os.path.expanduser("~/.skel/templates/create_suite.tmpl"), 'r')
    t = Template(file=template_file)
    t.test_plan = plan

    # No, I don't like these either.
    t.yamlfile = args.yamlfile
    t.project = args.project
    t.force = args.force

    suite_gen_file.write (str(t) )

    suite_gen_file.close()

    # Adjust the permissions of the replay script to make it runnable by user
    os.chmod (suite_gen_file_name, stat.S_IXUSR | stat.S_IWUSR | stat.S_IRUSR)

    # Run it
    #print "Run ./%s [disabled]" % suite_gen_file_name
    subprocess.check_call ("./%s" % suite_gen_file_name)
Exemple #30
0
def render_template(plugin, vm, tmplname, context=None):
    # Import here to avoid having to build-dep on python-cheetah
    from   Cheetah.Template import Template
    searchList = []
    if context:
        searchList.append(context)
    searchList.append(vm)

    tmpldirs = [os.path.expanduser('~/.vmbuilder/%s'),
                os.path.dirname(__file__) + '/plugins/%s/templates',
                '/etc/vmbuilder/%s']

    if vm.templates:
        tmpldirs.insert(0,'%s/%%s' % vm.templates)
    
    tmpldirs = [dir % plugin for dir in tmpldirs]

    for dir in tmpldirs:
        tmplfile = '%s/%s.tmpl' % (dir, tmplname)
        if os.path.exists(tmplfile):
            t = Template(file=tmplfile, searchList=searchList)
            output = t.respond()
            logging.debug('Output from template \'%s\': %s' % (tmplfile, output))
            return output

    raise VMBuilderException('Template %s.tmpl not found in any of %s' % (tmplname, ', '.join(tmpldirs)))
def page_render_html(json, **argd):
    action = argd.get("formtype", "overview")
    R = RecordRender(argd["__environ__"])
    DB = PeopleDatabase

    if action == "overview":
        # Show the database & a few options
        records = DB.read_database()
        rendered_records = R.rendered_record_list(records)
        return R.render_page(content=rendered_records)

    if action == "view":
        # Show the database & a few options
        record = DB.get_record(argd["personid"])
        records = DB.read_database()
        rendered_records = R.rendered_record_list(records)
        rendered_record = R.rendered_record(record)

        return R.render_page(content=rendered_records,
                             dataentry=rendered_record)

    if action == "edit_new":
        # Show the database & a form for creating a new person
        records = DB.read_database()
        rendered_records = R.rendered_record_list(records)
        empty_data_entry = R.rendered_record_entry_form({})
        configured_form = R.render_configured_form(empty_data_entry)

        return R.render_page(content=rendered_records,
                             dataentry=configured_form)

    if action == "create_new":
        # Take the data sent to us, and use that to fill out an edit form
        # Note: This is actually filling in an *edit* form at that point, not a *new* user form
        # If they submit the new form, the surely they should be viewed to be updating the form?
        # yes...
        #
        new_record = make_person(
            stem="form", **argd)  # This also stores them in the database

        records = DB.read_database()
        rendered_records = R.rendered_record_list(records)
        pre_filled_data_entry = R.rendered_record_entry_form(new_record)
        configured_form = R.render_configured_form(pre_filled_data_entry,
                                                   nextstep="update")

        return R.render_page(content=rendered_records,
                             dataentry=configured_form)

    if action == "edit":
        record = DB.get_record(argd["personid"])

        records = DB.read_database()
        rendered_records = R.rendered_record_list(records)
        pre_filled_data_entry = R.rendered_record_entry_form(record)
        configured_form = R.render_configured_form(pre_filled_data_entry,
                                                   nextstep="update")

        return R.render_page(content=rendered_records,
                             dataentry=configured_form)

    if action == "update":
        # Take the data sent to us, and use that to fill out an edit form
        #
        # Note: This is actually filling in an *edit* form at that point, not a *new* user form
        # If they submit the new form, the surely they should be viewed to be updating the form?
        # yes...
        #
        record = update_person(stem="form", **argd)

        records = DB.read_database()
        rendered_records = R.rendered_record_list(records)
        pre_filled_data_entry = R.rendered_record_entry_form(record)
        configured_form = R.render_configured_form(pre_filled_data_entry,
                                                   nextstep="update",
                                                   submitlabel="Update")

        return R.render_page(content=rendered_records,
                             dataentry=configured_form)

    if action == "delete":
        # Take the data sent to us, and use that to fill out an edit form
        #
        # Note: This is actually filling in an *edit* form at that point, not a *new* user form
        # If they submit the new form, the surely they should be viewed to be updating the form?
        # yes...
        #
        # Show the database & a few options
        person = DB.get_record(argd["personid"])
        people = DB.read_database()
        rendered_people = R.rendered_record_list(people)
        rendered_person = R.rendered_record(person)
        rendered_person = "<h3> Are you sure you wish to delete this person?</h3><ul>" + str(
            rendered_person)

        delete_action = "<a href='/cgi-bin/app/people?formtype=confirm_delete&personid=%s'>%s</a>" % (
            person["personid"], "Delete this person")
        cancel_action = "<a href='/cgi-bin/app/people?formtype=view&personid=%s'>%s</a>" % (
            person["personid"], "Cancel deletion")
        rendered_person += "</ul><h3> %s | %s </h3>" % (delete_action,
                                                        cancel_action)

        return R.render_page(content=rendered_people,
                             dataentry=rendered_person)

    if action == "confirm_delete":
        # Show the database & a few options
        record = DB.get_record(argd["personid"])
        DB.delete_record(argd["personid"])

        records = DB.read_database()
        rendered_records = R.rendered_record_list(records)
        #        rendered_record = R.rendered_record(record)

        return R.render_page(content=rendered_records,
                             dataentry="<h1> %s Deleted </h1>" %
                             record["person"])

    return str(
        Template(
            file='templates/Page.tmpl',
            searchList=[
                argd["__environ__"],
                {
                    "extra": "",
                    "content": "Sorry, got no idea what you want!",
                    "dataentry": "",
                    "banner":
                    "Not found",  # should send back a 404 status then? Or similar?
                }
            ]))
Exemple #32
0
for k in exps.keys():
    foo = []
    f = open('%s/avgstats.txt' % '/tmp/report-%s' % k, 'r')
    while True:
        line = f.readline().strip()
        if not line:
            break
        if line.startswith('#'):
            continue
        foo.append(line.split())
    f.close()
    stats[k] = foo
data.stats = stats

# create the report template
template = Template(file=templatefile, searchList=data)

statsstats = {}
for k in exps.keys():
    files = glob.glob('/tmp/report-%s/log-*' % k)
    a = numpy.matrix(numpy.zeros((len(files), 7)))
    for i in xrange(len(files)):
        p = files[i]
        a[i, :] = readDataFromFile(p)[-1, :]
    foo = numpy.ones((4, 7))
    foo[0, :] = numpy.max(a, 0)
    foo[1, :] = numpy.average(a, 0)
    foo[2, :] = numpy.min(a, 0)
    foo[3, :] = numpy.std(a, 0)
    foo = [['%g' % elem for elem in row] for row in foo.tolist()]
    statsstats[k] = foo
def matrixmul_opt(mat_a,
                  mat_b,
                  block_size=DEFAULT_BLOCK_SIZE,
                  work_size=DEFAULT_WORK_SIZE,
                  unroll=DEFAULT_UNROLL,
                  spill=DEFAULT_SPILL,
                  prefetch=DEFAULT_PREFETCH):
    ah, aw = mat_a.shape
    bh, bw = mat_b.shape

    assert aw == bh

    # -- pad input matrices appropriately
    ah_padded = int(np.ceil(ah / block_size)) * block_size
    aw_padded = int(np.ceil(aw / block_size)) * (block_size * work_size)
    mat_a_padded = np.zeros((ah_padded, aw_padded), np.float32)
    mat_a_padded[:ah, :aw] = mat_a

    bh_padded = aw_padded
    bw_padded = int(np.ceil(
        bw / (block_size * work_size))) * (block_size * work_size)
    mat_b_padded = np.zeros((bh_padded, bw_padded), np.float32)
    mat_b_padded[:bh, :bw] = mat_b

    ch_padded = ah_padded
    cw_padded = bw_padded

    # -- upload padded input matrices to the GPU
    mat_a_gpu = gpuarray.to_gpu(mat_a_padded)
    mat_b_gpu = gpuarray.to_gpu(mat_b_padded)

    # -- create empty container matrix for the result (C = A * B)
    mat_c_gpu = gpuarray.zeros((ch_padded, cw_padded), np.float32)

    # -- generate and compile the code
    # prepare the template parameters
    template_params = {
        'BLOCK_SIZE': block_size,
        'WORK_SIZE': work_size,
        'UNROLL': unroll,
        'SPILL': spill,
        'PREFETCH': prefetch,
        'A_WIDTH': aw_padded,
        'A_HEIGHT': ah_padded,
        'B_WIDTH': bw_padded,
    }

    # run the template engine to get the code
    kernel_code = Template(
        file=TEMPLATE_FILENAME,
        searchList=[template_params],
    )

    # compile the code
    module = compiler.SourceModule(kernel_code)

    # get the kernel from the module
    matrixmul_func = module.get_function("matrixMul")

    # some info about the module
    print("number of registers used:", matrixmul_func.num_regs)

    # block of threads
    # ATTENTION: block is (threadDim.x, threadDim.y, threadDim.z)
    #            and not (threadDim.z, threadDim.y, threadDim.x)
    block = block_size, block_size, 1

    # grid of blocks
    # ATTENTION: it's (blockDim.x, blockDim.y)
    #            and not (blockDim.y, blockDim.x)
    grid = int(cw_padded / block_size / work_size), int(ch_padded / block_size)

    # -- call the kernel on the GPU
    # Note that when we use time_kernel=True pycuda will automatically synchronize the kernel
    # to make sure that the timing is correct. If you time the code yourself, you'll have to
    # synchronize the current Context.
    gpu_time = matrixmul_func(
        # -- output
        mat_c_gpu,
        # -- inputs
        mat_a_gpu,
        mat_b_gpu,
        # -- grid of blocks
        grid=grid,
        # -- block of threads
        block=block,
        # -- time the kernel (approx.)
        time_kernel=True,
    )

    # get the GPU matrix back to CPU memory
    mat_c_padded = mat_c_gpu.get()
    mat_c = mat_c_padded[:ah, :bw]

    return mat_c, gpu_time
Exemple #34
0
import logging
import yaml
from Cheetah.Template import Template
from threading import Thread

# constants for resolution and period
day = 0
week = 1
month = 2

PLATANE_HOME = os.path.dirname(__file__)

model.schema = yaml.load(file(PLATANE_HOME + '/data/schema', 'r'))
model.root = PLATANE_HOME + "/data/root"

list_template = Template.compile(file=file(PLATANE_HOME + '/list.html', "r"))
task_template = Template.compile(file=file(PLATANE_HOME + '/task.html', "r"))
message_template = Template.compile(file=file(PLATANE_HOME +
                                              '/message.html', "r"))
visualize.tasks_template = Template.compile(
    file=file(PLATANE_HOME + '/tasks.html', "r"))

render_handlers = {}


# REST methods
def do_get(env, start_response):
    return handle(env, start_response, get_body)


def do_put(env, start_response):
Exemple #35
0
 def index(self, num=None):
     if cherrypy.session.get('login', None) == 'login':
         raise cherrypy.HTTPRedirect('/database/')
     else:
         userForm = Template(file=os.path.join(os.curdir, 'index.tmpl'))
         return str(userForm)
def STTY(stream):
    return 'STTY%s' % __stream(stream)


def CAPTURE(stream):
    return 'CAPTURE%s' % __stream(stream)


def DISCONNECT(stream):
    stream = stream.lower()
    if stream == 'slave':
        return 'A = disconnect 0'
    elif stream == 'master':
        return 'A = disconnect 1'


if __name__ == '__main__':
    if len(sys.argv) < 2:
        print "Usage %s <file>" % sys.argv[0]
        sys.exit(1)
    t = Template(file=sys.argv[1])
    t.INPUT = INPUT
    t.PRINT = PRINT
    t.TIMEOUT = TIMEOUT
    t.GET = GET
    t.STTY = STTY
    t.CAPTURE = CAPTURE
    t.DISCONNECT = DISCONNECT
    print str(t)
Exemple #37
0
        elif options.language == 'xml':
            templates.append(directory + "/../data/DBus-xml.xml")
            header_ext = ".xml"
        else:
            parser.error("Unsupported language: " + options.language)
            sys.exit(1)

    if len(templates) == 0:
        parser.error("Specify language")
        sys.exit(1)

    name = None
    if len(args) >= 2:
        name = args[1]

    binding = TopNode(args[0], name, options.backend, header_ext)
    binding.parse()

    for template_name in templates:
        t = Template(file=template_name)
        t.model = binding
        s = str(t)

        ext = os.path.splitext(template_name)[1]

        f = open(binding.name + ext, 'w+')
        try:
            f.write(s)
        finally:
            f.close()
Exemple #38
0
def display(conf,inputs,outputs):
	nameSpace = {'conf': conf,'inputs': inputs, 'outputs': outputs}
	t = Template(file=conf["lenv"]["cwd"]+"/configuration/display.html",searchList=nameSpace)
	outputs["Result"]["value"]=t.__str__()
	return 3
Exemple #39
0
    def gen_config_data(self):
        """
        Generate configuration data for repos, ldap, files,
        packages, and monit. Returns a dict.
        """
        config_data = {
            'repo_data': self.handle.get_repo_config_for_system(self.system),
            'repos_enabled': self.get_cobbler_resource('repos_enabled'),
            'ldap_enabled': self.get_cobbler_resource('ldap_enabled'),
            'monit_enabled': self.get_cobbler_resource('monit_enabled')
        }
        package_set = set()
        file_set = set()

        for mgmtclass in self.mgmtclasses:
            _mgmtclass = self.handle.find_mgmtclass(name=mgmtclass)
            for package in _mgmtclass.packages:
                package_set.add(package)
            for file in _mgmtclass.files:
                file_set.add(file)

        # Generate LDAP data
        if self.get_cobbler_resource("ldap_enabled"):
            if self.system.ldap_type in ["", "none"]:
                utils.die(self.logger, "LDAP management type not set for this system (%s, %s)" % (self.system.ldap_type, self.system.name))
            else:
                template = utils.get_ldap_template(self.system.ldap_type)
                t = Template(file=template, searchList=[self.host_vars])
                print t
                config_data['ldap_data'] = t.respond()

        # Generate Package data
        pkg_data = {}
        for package in package_set:
            _package = self.handle.find_package(name=package)
            if _package is None:
                raise CX('%s package resource is not defined' % package)
            else:
                pkg_data[package] = {}
                pkg_data[package]['action'] = self.resolve_resource_var(_package.action)
                pkg_data[package]['installer'] = _package.installer
                pkg_data[package]['version'] = self.resolve_resource_var(_package.version)
                if pkg_data[package]['version'] != "":
                    pkg_data[package]["install_name"] = "%s-%s" % (package, pkg_data[package]['version'])
                else:
                    pkg_data[package]["install_name"] = package
        config_data['packages'] = pkg_data

        # Generate File data
        file_data = {}
        for file in file_set:
            _file = self.handle.find_file(name=file)

            if _file is None:
                raise CX('%s file resource is not defined' % file)

            file_data[file] = {}
            file_data[file]['is_dir'] = _file.is_dir
            file_data[file]['action'] = self.resolve_resource_var(_file.action)
            file_data[file]['group'] = self.resolve_resource_var(_file.group)
            file_data[file]['mode'] = self.resolve_resource_var(_file.mode)
            file_data[file]['owner'] = self.resolve_resource_var(_file.owner)
            file_data[file]['path'] = self.resolve_resource_var(_file.path)

            if not _file.is_dir:
                file_data[file]['template'] = self.resolve_resource_var(_file.template)
                try:
                    t = Template(file=file_data[file]['template'], searchList=[self.host_vars])
                    file_data[file]['content'] = t.respond()
                except:
                    utils.die(self.logger, "Missing template for this file resource %s" % (file_data[file]))

        config_data['files'] = file_data
        return config_data
Exemple #40
0
    def read(fname):
        f = open(os.path.join(dirname, fname), 'r')
        template = Template(template=f.read())
        template.converters["h"] = cgi.escape

        return template
Exemple #41
0
     if conf.keys().count('senv') > 0:
         lastMap = conf['senv']['last_map']
         if toLoad is not None:
             conf["senv"]["toLoad"] = toLoad
     #else:
     #	conf['senv']['last_map']="Georeferencer"
     pass
 t = None
 try:
     tmplName = ""
     for i in range(1, len(tmpName)):
         if tmplName != "":
             tmplName += "/"
         tmplName += tmpName[i]
     t = Template(file=conf["main"]["templatesPath"] + "/preview/" +
                  tmplName + ".tmpl",
                  searchList=nameSpace)
 except:
     if len(tmpName) > 0:
         t = Template(file=conf["main"]["templatesPath"] + "/" +
                      tmpName[0] + ".tmpl",
                      searchList=nameSpace)
     else:
         conf["lenv"]["message"] = zoo._(
             "Error loading your template file ") + conf["main"][
                 "templatesPath"] + "/preview/" + tmplName + ".tmpl"
         return zoo.SERVICE_SUCCEEDED
     verif = not (conf.has_key("senv"))
     if verif:
         conf["senv"] = {}
         conf["senv"]["MMID"] = "MM" + str(time.time()).split(".")[0]
Exemple #42
0
                        entry.update(basic_meta[url])
                    else:
                        basic_data = metadata.from_container(item)
                        entry.update(basic_data)
                        basic_meta[url] = basic_data

                data.append(entry)
        else:
            data = []
            tivoIP = ''
            TotalItems = 0
            ItemStart = 0
            ItemCount = 0
            FirstAnchor = ''

        t = Template(NPL_TEMPLATE, filter=EncodeUnicode)
        t.escape = escape
        t.quote = quote
        t.folder = folder
        t.status = status
        if tivoIP in queue:
            t.queue = queue[tivoIP]
        t.has_tivodecode = has_tivodecode
        t.tname = tivo_name
        t.tivoIP = tivoIP
        t.container = handler.cname
        t.data = data
        t.len = len
        t.TotalItems = int(TotalItems)
        t.ItemStart = int(ItemStart)
        t.ItemCount = int(ItemCount)
Exemple #43
0
def main(args):

    #Much of the argparse/configparser parts taken from
    #http://blog.vwelch.com/2011/04/combining-configparser-and-argparse.html

    conf_parser = argparse.ArgumentParser(
        # Turn off help, so we print all options in response to -h
        add_help=False)

    conf_parser.add_argument("-c",
                             "--config-file",
                             dest="configfile",
                             help="Use a different config file than %s" %
                             CONFIG_FILE)

    args, remaining_argv = conf_parser.parse_known_args()

    if args.configfile:
        configfile = args.configfile
    else:
        configfile = CONFIG_FILE

    # Make sure the configfile is a file
    if not os.path.isfile(configfile):
        print >> sys.stderr, 'ERROR: %s is not a file' % configfile
        sys.exit(1)

    config = ConfigParser.SafeConfigParser()
    try:
        config.read([configfile])
    except:
        print >> sys.stderr, 'ERROR: There is an error in the config file'
        sys.exit(1)

    defaults = dict(config.items("default"))

    parser = argparse.ArgumentParser(
        # Inherit options from config_parser
        parents=[conf_parser],
        # print script description with -h/--help
        description=__doc__,
        # Don't mess with format of description
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )

    parser.set_defaults(**defaults)

    # Now that we've dealt with getting defaults from a config file we can
    # continue on adding arguments.
    parser.add_argument(
        "-i",
        "--ipaddress",
        dest="ipaddress",
        help="Set the ip address for the host in the kickstart",
    )
    parser.add_argument(
        "-g",
        "--gateway",
        dest="gateway",
        help="Set the gateway for the new host in the kickstart")
    parser.add_argument(
        "-n",
        "--netmask",
        dest="netmask",
        help="Set the netmask for the new host in the kickstart")
    parser.add_argument("-m",
                        "--mode",
                        dest="mode",
                        help="Set a mode, eg. domU_kvm or dom0")
    parser.add_argument(
        "-o",
        "--os",
        dest="os",
        help="What os to create a kickstart for, eg. rhel5 or rhel6")
    parser.add_argument("-k",
                        "--key",
                        dest="key",
                        help="If you have a Redhat install key number")
    parser.add_argument("-r",
                        "--rootpw",
                        dest="rootpw",
                        help="Hashed root password")
    parser.add_argument("-t",
                        "--timezone",
                        dest="timezone",
                        help="Timezone in 'American/Edmonton' format")
    parser.add_argument("-d",
                        "--nameservers",
                        dest="nameservers",
                        help="Nameservers in appropriate kickstart format")
    parser.add_argument(
        "--hostname",
        dest="hostname",
        help="Set the hostname for the new host in the kickstart")
    parser.add_argument(
        "-p",
        "--template-dir",
        dest="templatedir",
        help="Directory where the kickstart template files are located")

    # Capture args
    args = parser.parse_args(remaining_argv)

    # Makes args into a dictionary to feed to searchList
    d = args.__dict__

    # Change to template dir
    pwd = os.getcwd()
    try:
        os.chdir(args.templatedir)
    except:
        print >>sys.stderr, \
        'ERROR: Template path %s is not a directory' % templatedir
        sys.exit(1)

    # Create template object
    # - the searchList=[d] is the best!
    t = Template(file=args.main_template, searchList=[d])

    print(t.respond())
    os.chdir(pwd)
    sys.exit(0)
Exemple #44
0
 def template(**kw):
     t = Template(file=path, searchList=[kw])
     return t.respond()
Exemple #45
0
def output_cpp(output_file, template_file):
    global tlm_duration
    global tlm_period
    global tlm_packet_list
    global tlm_max_packet_bytes

    t = Template(file=template_file)
    t.tlm_packet_list = tlm_packet_list

    # Generate schedule code if both duration and period defined
    if (tlm_duration is not None) and (tlm_period is not None):
        t.tlm_max_cycles = int(tlm_duration * tlm_period)
    else:
        t.tlm_max_cycles = None

    t.tlm_cycle_max_list = sched_cycle_ids_max(t.tlm_max_cycles)
    t.tlm_cycle_id_list = sched_cycle_ids(t.tlm_max_cycles)
    # Create ID to channel mapping
    t.tlm_cycle_id_arr_size = sched_id_arr_size(t.tlm_cycle_id_list)
    t.tlm_max_packet_bytes = tlm_max_packet_bytes
    t.tlm_max_num_chan = sum(
        [pkt.m_chan is not None for pkt in tlm_packet_list])
    # Create duration and period values
    t.tlm_max_num_freq = sum(
        [pkt.m_freq is not None for pkt in tlm_packet_list])
    if tlm_duration is not None:
        t.tlm_duration = tlm_duration
    else:
        t.tlm_duration = -1.0
    #
    if tlm_period is not None:
        t.tlm_period = tlm_period
    else:
        t.tlm_period = -1

    f = open(output_file, "w")
    print(t, file=f)
      $key: $type
    #end for
    }

    configOptions: {
    #for $key, $type in $configOptions.items():
      $key: $type
    #end for
    }
  }

  collections: Record<string, ZoteroCollection>

  isJurisM: boolean
  isZotero: boolean
  unicode: boolean
  platform: string
  paths: {
    caseSensitive: boolean
    sep: string
  }
  BetterTeX?: boolean
  BetterCSL?: boolean

  stringCompare: (a: string, b: string) => number
}
"""

with open(os.path.join(root, 'gen/typings/translator.d.ts'), 'w') as out:
    out.write(str(Template(template, searchList=[variables.to_dict()])))
Exemple #47
0
def buildCopyright(page):
    page.meta.copyright = Template(file='./templates/copyright.tmpl')
    page.meta.copyright.year = str(t.strftime("%Y"))
Exemple #48
0
    parser.add_option(
        "-t",
        "--template",
        default='templates/resume.%s.tmpl',
        help=
        "Filename of the output format template. Defaults to templates/resume.<extension>.tmpl"
    )

    options, extra_args = parser.parse_args()
    if len(extra_args) < 1:
        parser.print_help()
        exit()

    return options, extra_args[0]


if __name__ == '__main__':
    options, extension = get_cmd_line_args()

    contents = yaml.load(open(options.source, 'r').read())

    escape_func = getattr(escapes, 'escape_' + extension, lambda x: x)
    escaped_contents = escape_leaves(escape_func, contents)
    template = Template(file=options.template % extension,
                        searchList=[escaped_contents])

    output_dir = options.output_dir
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)
    open('%s/resume.%s' % (output_dir, extension), 'w').write(str(template))
Exemple #49
0
def buildSwLicense(page):
    page.meta.swlicense = Template(file='./templates/swlicense.tmpl')
    page.meta.swlicense.generator = generator
    page.meta.swlicense.year = str(t.strftime("%Y"))
Exemple #50
0
def buildMeta(conn, cursor, page):
    page.meta = Template(file='./templates/meta.tmpl')
    buildImprint(conn, cursor, page)
    buildSwLicense(page)
    buildDataLicense(page)
    buildCopyright(page)
 def __repr__(self):
     return str(
         Template(self.getWorklistTemplate(),
                  searchList={'e': self.__dict__}))
Exemple #52
0
def buildDataLicense(page):
    page.meta.license = Template(file='./templates/license.tmpl')
    page.meta.license.year = str(t.strftime("%Y"))
Exemple #53
0
 def test_help(self):
     klass = Template.compile(source='$foo')
     t = klass()
     cmdline = CmdLineIface(t, scriptName='test', cmdLineArgs=['-h'])
     self.assertRaises(SystemExit, cmdline._processCmdLineArgs)
Exemple #54
0
def buildImprint(conn, cursor, page):
    page.meta.imprint = Template(file='./templates/imprint.tmpl')
    page.meta.imprint.generator = generator
    page.meta.imprint.time = t.strftime("%Y-%m-%d %H:%M")
    page.meta.imprint.swVersion = swVersion
    page.meta.imprint.dataAge = osmstat.dataAge(conn, cursor)
Exemple #55
0
 def _eval_cheetah(element):
     from Cheetah.Template import Template
     namespace = element.get_namespace(**kwds)
     return str(Template(element.code, namespaces=[namespace]))
Exemple #56
0
 def test_env(self):
     klass = Template.compile(source='$foo')
     t = klass()
     cmdline = CmdLineIface(t, scriptName='test', cmdLineArgs=['--env'])
     cmdline._processCmdLineArgs()
     assert str(t) == 'test foo'
Exemple #57
0
def render_template(template, input):
    template = get_template(template)
    return Template(template, searchList=[input]).__str__()
Exemple #58
0
def a():
    return Template("sink")
Exemple #59
0
 def get_data(template_file_path, search_list):
     if not os.path.isabs(template_file_path):
         template_file_path = os.path.join(TemplateManager.template_dir, template_file_path)
     tpl = Template(file=template_file_path,
                    searchList=search_list)
     return str(tpl)
Exemple #60
0
    def handle_notification(self, wid):
        """ Extracts the needed data from the workitem, prepares the email and
            then sends it
            :param wid: Workitem
            :type wid: object
        """

        wid.result = False
        if not wid.fields.msg:
            wid.fields.msg = []

        subject = wid.params.subject or wid.fields.subject
        template_body = wid.params.template_body or wid.fields.template_body
        template_name = wid.params.template or wid.fields.template
        mail_from = wid.params.mail_from or wid.fields.mail_from \
                    or self.default_sender
        mail_to = (wid.fields.mail_to or []) + (wid.params.mail_to or [])
        mail_cc = (wid.fields.mail_cc or []) + (wid.params.mail_cc or [])
        wid.fields.mail_to = []
        wid.fields.mail_cc = []

        if wid.params.extra_msg:
            wid.fields.msg.append(wid.params.extra_msg)

        if not subject:
            raise RuntimeError("Missing mandatory field or param 'subject'")

        if not (template_body or template_name):
            raise RuntimeError("Both of field or param 'template_body' and "
                               "'template_name' missing")

        if template_body and template_name:
            raise RuntimeError("Both field or param 'template_body' and "
                               "'template_name' defined")

        if template_name:
            template_fname = os.path.join(self.email_store, template_name)
            with open(template_fname) as fil:
                template_body = fil.read()

        attachments = []
        for attachment in (wid.fields.attachments or []):
            attachment = os.path.abspath(attachment)
            if not allowed_file(attachment, self.allowed_attachment_dirs):
                wid.fields.msg.append("Refusing to attach %s" % attachment)
            elif not os.path.isfile(attachment):
                wid.fields.msg.append("Could not find attachment %s" %
                                      attachment)
            else:
                attachments.append(attachment)

        mail_to = remove_duplicate_addrs(mail_to)
        mail_cc = remove_duplicate_addrs(mail_cc, relative_to=mail_to)

        if not mail_to and not mail_cc:
            err = "No recipients listed; not sending mail."
            self.log.info(err)
            wid.fields.msg.append(err)
            wid.result = True
            return

        searchlist = {
            'f':
            general_map(wid.fields.as_dict(),
                        dicts=ForgivingDict,
                        values=fixup_utf8)
        }
        searchlist['req'] = searchlist['f']['req'] or ForgivingDict()

        # Try the template but if there's an error, re-do with the
        # more informative errorCatcher and send to the log
        try:
            template = Template(template_body, searchList=searchlist)
            message = unicode(template)
        except NotFound, err:
            # You can't set the errorCatcher using a class - this is
            # pattern a) usage
            self.log.info(
                "Error processing template - trying with errorCatcher")
            template = Template("#errorCatcher BigEcho\n" + template_body,
                                searchList=searchlist)
            message = unicode(template)
            self.log.info("Processed template with highlights:")
            self.log.info(message)
            raise