def _render(self, template_path):
        if 'api.balancedpayments.com' in self.ctx.storage['api_location']:
            api_location = None
        else:
            api_location = self.ctx.storage['api_location']
        context = {
            'ctx': self.ctx,
            'Endpoint': Endpoint,
            'api_location': api_location,
            'api_key': self.ctx.api_key,
        }
        context.update(request=self.metadata)

        # definition
        logger.debug('rendering definition for "%s"', template_path)
        template = mako.template.Template(
            filename=template_path,
            lookup=self.ctx.template_lookup
        )
        try:
            definition = template.render(mode='definition', **context).strip()
        except Exception:
            print mako.exceptions.text_error_template().render()
            raise

        # request
        logger.debug('rendering request for "%s"', template_path)
        if 'payload' in context['request']:
            context['payload'] = context['request']['payload']
        template = mako.template.Template(
            filename=template_path,
            lookup=self.ctx.template_lookup
        )
        try:
            request = template.render(mode='request', **context).strip()
        except Exception:
            print mako.exceptions.text_error_template().render()
            raise

        # response
        logger.debug('rendering response for "%s"', template_path)
        template = mako.template.Template(
            filename=template_path,
            lookup=self.ctx.template_lookup
        )
        try:
            response = template.render(mode='response', **context).strip()
        except Exception:
            print mako.exceptions.text_error_template().render()
            raise

        return {
            'definition': definition,
            'request': request,
            'response': response
        }
Beispiel #2
0
    def get_edit(self, request):
        user_session = request.getSession()
        username = self.__user_sessions.get(user_session)

        title = request.args.get('title', '')
        request.args['title'] = title

        if 'delete' in request.args and title != '':
            user_id = model.ensure_user_exists(self.__SessionMaker, username)
            model.remove_graph(self.__SessionMaker, user_id, title)

            request.setResponseCode(303)
            request.redirect('/')
            request.finish()
            return

        graph_type = request.args.get('graph_type', '')

        data_sources = model.get_data_sources(self.__SessionMaker)

        for each_metric in data_sources.itervalues():
            each_metric.sort()

        template = self.__template_lookup.get_template('edit.mako')

        return template.render(kwargs=request.args, data_sources=data_sources,
                username=username, timescales=self.timescales,
                graph_types=self.graph_types)
Beispiel #3
0
    def get_component(self, request, component):
        user_session = request.getSession()
        username = self.__user_sessions.get(user_session)

        timescale = request.args.get('ts', '6h')

        if timescale not in self.timescales:
            timescale = '6h'

        metrics = []

        session = self.__SessionMaker()
        rows = session.query(Data).filter(Data.component == component).group_by(
                Data.metric).order_by(Data.metric).all()

        for each in rows:
            data, should_save = each.get_data(timescale)

            if should_save:
                session.merge(each)

            current = data[-1]
            minimum = min(data)
            maximum = max(data)

            metrics.append((each.metric, each.metric.replace('.', '-').replace(
                    ':', '-'), data, current, minimum, maximum))

        session.commit()

        template = self.__template_lookup.get_template('component.mako')

        return template.render(component=component, metrics=metrics,
                username=username, timescale=timescale,
                timescales=self.timescales)
Beispiel #4
0
 def __init__(
         self, model_path, frame_skip=1, position_only=False,
         obs_noise=0.0, action_noise=0.0, template_string=None,
         template_args=None,
 ):
     self.full_model_path = model_path
     if template_string is None:
         if model_path.endswith(".mako"):
             with open(model_path) as template_file:
                 template = mako.template.Template(
                     template_file.read())
             template_string = template.render(
                 opts=template_args if template_args is not None else {},
             )
         else:
             with open(model_path, "r") as f:
                 template_string = f.read()
     world, extra_data = world_from_xml(template_string)
     self.world = world
     self.extra_data = extra_data
     self.initial_state = self._state
     self.viewer = None
     self.frame_skip = frame_skip
     self.timestep = self.extra_data.timeStep
     self.position_only = position_only
     self.obs_noise = obs_noise
     self.action_noise = action_noise
     self._action_bounds = None
     # cache the computation of position mask
     self._position_ids = None
     self._cached_obs = None
     self._cached_coms = {}
Beispiel #5
0
    def render_string(self, filename, **kwargs):
        kwargs["current_user"] = self.current_user
        template = self.lookup.get_template(filename)
        namespace = self.get_template_namespace()
        namespace.update(kwargs)

        return template.render(**namespace)
Beispiel #6
0
    def get_graph(self, request):
        username = request.getCookie("username")

        graph_id = request.args.get("graph_id", "")
        title = request.args.get("title", "")
        graph_type = request.args.get("graph_type", "")
        timescale = request.args.get("timescale", "")

        for each in [graph_id, title, graph_type, timescale]:
            if each == "":
                request.setResponseCode(400)
                return ""

        keys = request.args.keys()

        for each in ["graph_id", "title", "graph_type", "timescale"]:
            index = keys.index(each)
            del keys[index]

        graph = model.get_data_for_graph(self.__SessionMaker, graph_id, title, graph_type, keys, timescale)

        template = self.__template_lookup.get_template("graph.mako")

        return template.render(
            username=username, title=title, graph_type=graph_type, components=keys, graph=[graph]
        ).encode("utf8")
Beispiel #7
0
    def get_edit(self, request):
        username = request.getCookie("username")

        title = request.args.get("title", "")
        request.args["title"] = title

        if "delete" in request.args and title != "":
            user_id = model.ensure_user_exists(self.__SessionMaker, username)
            model.remove_graph(self.__SessionMaker, user_id, title)

            request.setResponseCode(303)
            request.redirect("/")
            return ""

        data_sources = model.get_data_sources(self.__SessionMaker)

        for each_metric in data_sources.itervalues():
            each_metric.sort()

        active_components = [each.split("|")[0] for each in request.args if "|" in each]

        graph_type = request.args.get("graph_type", "")

        template = self.__template_lookup.get_template("edit.mako")

        return template.render(
            kwargs=request.args,
            data_sources=data_sources,
            active_components=active_components,
            username=username,
            timescales=self.timescales,
            graph_types=self.graph_types,
        ).encode("utf8")
Beispiel #8
0
def _renderer(type, data):
    lookup = TemplateLookup(directories = [configuration.email_template_directory], 
	    module_directory = configuration.email_template_cache,
	    output_encoding = 'utf-8', input_encoding = 'utf-8')
    template = lookup.get_template(configuration.email_template_map.get(type))
    data = dict((str(k), v) for k, v in data.items())
    return template.render(**data)
Beispiel #9
0
 def render_string(self, filename, **kwargs):
     '''
         Override render_string to use mako template.
         Like tornado render_string method, this method also
         pass request handler environment to template engine
     '''
     try:
         # if not self.is_mobile:
         #     template = self.LOOK_UP.get_template(filename)
         # else:
         #     template = self.LOOK_UP_MOBILE.get_template(filename)
         template = self.LOOK_UP.get_template(filename)
         env_kwargs = dict(
             handler = self,
             request = self.request,
             locale = self.locale,
             _ = self.locale.translate,
             static_url = self.static_url,
             xsrf_form_html = self.xsrf_form_html,
             reverse_url = self.application.reverse_url,
             agent = self.agent,
         )
         env_kwargs.update(kwargs)
         return template.render(**env_kwargs)
     except:
         from mako.exceptions import RichTraceback
         tb = RichTraceback()
         for (module_name, line_no, function_name, line) in tb.traceback:
             print('File:{}, Line:{} in {}'.format(module_name, line_no, function_name))
             print(line)
         access_log.error('Render {} failed, {}:{}'.format(filename, tb.error.__class__.__name__, tb.error), 
                      exc_info=True)
         raise HTTPError(500, 'Render page failed')
Beispiel #10
0
    def get_graph(self, request):
        username = request.getCookie('username')

        graph_id = request.args.get('graph_id', '')
        title = request.args.get('title', '')
        graph_type = request.args.get('graph_type', '')
        timescale = request.args.get('timescale', '')

        for each in [graph_id, title, graph_type, timescale]:
            if each == '':
                request.setResponseCode(400)
                return ''

        keys = request.args.keys()

        for each in ['graph_id', 'title', 'graph_type', 'timescale']:
            index = keys.index(each)
            del keys[index]

        graph = model.get_data_for_graph(self.__SessionMaker, graph_id, title,
                graph_type, keys, timescale)

        template = self.__template_lookup.get_template('graph.mako')

        return template.render(username=username, title=title,
                graph_type=graph_type, components=keys, graph=[graph]).encode('utf8')
Beispiel #11
0
    def __finish_get_component(self, request, component, username, timescale):
        metrics = yield self.__redis_model_data.get_metrics(component)
        metric_data = []

        for each_metric in metrics:
            data = yield self.__redis_model_data.get_data(component,
                    each_metric, timescale)

            # HACK: if the last value is 0, set it the previous value so sparkline doesn't drop off to 0
            if data[-1] == 0:
                data[-1] = data[-2]

            current = data[-1]
            minimum = min(data)
            maximum = max(data)

            metric_data.append((each_metric, data, current, minimum, maximum))

        template = self.__template_lookup.get_template('component.mako')

        ret = template.render(component=component, metrics=metric_data,
                username=username, timescale=timescale,
                timescales=self.timescales, cgi=cgi).encode('utf8')

        request.write(ret)
        request.finish()
Beispiel #12
0
    def get_edit(self, request):
        username = request.getCookie('username')

        title = request.args.get('title', '')
        request.args['title'] = title

        if 'delete' in request.args and title != '':
            user_id = model.ensure_user_exists(self.__SessionMaker, username)
            model.remove_graph(self.__SessionMaker, user_id, title)

            request.setResponseCode(303)
            request.redirect('/')
            return ''

        data_sources = model.get_data_sources(self.__SessionMaker)

        for each_metric in data_sources.itervalues():
            each_metric.sort()

        active_components = \
                [each.split('|')[0] for each in request.args if '|' in each]

        graph_type = request.args.get('graph_type', '')

        template = self.__template_lookup.get_template('edit.mako')

        return template.render(kwargs=request.args, data_sources=data_sources,
                active_components=active_components, username=username,
                timescales=self.timescales,
                graph_types=self.graph_types).encode('utf8')
Beispiel #13
0
 def fill_template_mako( self, filename, **kwargs ):
     template = self.webapp.mako_template_lookup.get_template( filename )
     template.output_encoding = 'utf-8' 
     data = dict( caller=self, t=self, trans=self, h=webhelpers, util=util, request=self.request, response=self.response, app=self.app )
     data.update( self.template_context )
     data.update( kwargs )
     return template.render( **data )
Beispiel #14
0
 def data(self, container):
     import mako.template
     template = mako.template.Template(self.file.data(container))
     context = {'this': container}
     context.update(self.context)
     self.logger.debug('rendering template file', context=context)
     return template.render(**context)
Beispiel #15
0
    def __finish_get_edit(self, request, username, title):
        data_sources = {}

        components = yield self.__redis_model_data.get_components()

        for each_component in components:
            metrics = yield self.__redis_model_data.get_metrics(each_component)
            metrics.sort()

            data_sources[each_component] = metrics

        graphs = yield self.__redis_model_graph.get_graphs(username)
        if title and title in graphs:
            fields = graphs[title]['fields']
            active_components = [each.split('|')[0] for each in fields]

        else:
            fields = []
            active_components = []

        graph_type = request.args.get('graph_type', '')

        template = self.__template_lookup.get_template('edit.mako')

        ret = template.render(kwargs=request.args, fields=fields,
                data_sources=data_sources, active_components=active_components,
                username=username, timescales=self.timescales,
                graph_types=self.graph_types, cgi=cgi).encode('utf8')

        request.write(ret)
        request.finish()
Beispiel #16
0
    def get_index(self, request):
        username = request.getCookie('username')

        if 'edit' in request.args:
            edit = request.args['edit']
        else:
            edit = None

        session = self.__SessionMaker()

        rows = session.query(Data.component).group_by(Data.component).order_by(
                Data.component).all()

        session.close()

        keys = [each[0] for each in rows]

        # Look up custom graphs for this user
        if username is not None:
            user_id = model.ensure_user_exists(self.__SessionMaker, username)
            graphs = model.get_graphs(self.__SessionMaker, user_id)

        else:
            user_id = None
            graphs = None

        template = self.__template_lookup.get_template('index.mako')

        return template.render(components=keys, username=username, edit=edit,
                user_id=user_id, graphs=graphs).encode('utf8')
def generate_report(log_dir="/var/ceilometer_stats/", points=500,
                    template_dir="./template"):
    statistics = collect_stats_from_logs(log_dir, points)

    template = get_template(template_dir, "report.mako")
    source, scenarios = _process_results(statistics)
    return template.render(data=json.dumps(scenarios),
                           source=json.dumps(source))
Beispiel #18
0
def plot(results):
    results = _process_results(results)

    abspath = os.path.dirname(__file__)
    with open("%s/src/index.mako" % abspath) as index:
        template = mako.template.Template(index.read())
        return template.render(data=json.dumps(results),
                               tasks=map(lambda r: r["name"], results))
Beispiel #19
0
def plot(results):
    data = _process_results(results)

    template_file = os.path.join(os.path.dirname(__file__),
                                 "src", "index.mako")
    with open(template_file) as index:
        template = mako.template.Template(index.read())
        return template.render(data=json.dumps(data))
Beispiel #20
0
    def get_index(self, request):
        favorites_url = "https://api.twitter.com/1/favorites.json"
        response, content = self.__client.request(favorites_url, method="GET")

        content = simplejson.loads(content)

        template = self.__template_lookup.get_template("index.mako")
        return template.render(content=content).encode("utf8")
Beispiel #21
0
 def render_string(self, filename, **kwargs):
     kwargs["current_user"] = self.current_user
     kwargs["WEB_INFO"] = self.web_info
     kwargs["STATIC_HOST"] = str(STATIC_HOST)
     template = self.lookup.get_template(filename)
     namespace = self.get_template_namespace()
     namespace.update(kwargs)
     return template.render(**namespace)
Beispiel #22
0
 def render_page(self, template, request_handler, **kwargs):
     template = self._lookup.get_template(template)
     return template.render(
         CONFIG=CONFIG,
         DATABASE=DATABASE,
         REQUEST_HANDLER=request_handler,
         VALUE_MAX=VALUE_MAX, VALUE_MIN=VALUE_MIN, VALUE_NOSTOCK=VALUE_NOSTOCK,
         **kwargs
     )
Beispiel #23
0
Datei: ssl.py Projekt: r3boot/pki
    def setup_ca_structure(self):
        """Creates the directory structure for this CA and initializes it's
        databases. It will return False for various errors, these include:

        * An existing base directory
        * A missing root.template
        * Failure to parse the template

        :returns:   Flag indicating the success of this function
        :rtype:     bool
        """
        basedir = self.ca_data['basedir']
        templates = self.ca_data['templates']
        cfg = self.ca_data['cfg']
        root_template = '{0}/root.template'.format(templates)

        # Check if root.template exists
        if not os.path.exists(root_template):
            log.warning('{0} does not exist'.format(root_template))
            return False

        # Setup base directory
        if os.path.exists(basedir):
            log.warning('{0} already exists'.format(basedir))
            return False

        log.debug('Setting up directory structure for {0} CA'.format(
            self.ca_data['name']
        ))

        os.mkdir(basedir)

        # Setup CA directories
        for directory in ['certs', 'cfg', 'crl', 'csr', 'db', 'private']:
            dest_dir = '{0}/{1}'.format(basedir, directory)
            os.mkdir(dest_dir)

        # Initialize databases
        for new_file in [self.ca_data['db'], self.ca_data['db_attr']]:
            open(new_file, 'w').write('')

        # Initialize indices
        for new_file in [self.ca_data['crt_idx'], self.ca_data['crl_idx']]:
            open(new_file, 'w').write('01\n')

        # Initialize configuration file
        template_data = open(root_template, 'r').read()
        template = mako.template.Template(template_data)
        try:
            cfg_data = template.render(**self.ca_data)
        except NameError as err:
            log.warning('Failed to generate configuration: {0}'.format(err))
            return False
        open(cfg, 'w').write(cfg_data)

        return True
Beispiel #24
0
 def create_report(self):
     report_attrs = self._getReportAttributes()
     generator = 'json2html %s' % __version__
     heading = self._generate_heading(report_attrs)
     report = self._generate_report()
     with open("%s/report_templates/main.mako" % self.abspath) as main:
         template = mako.template.Template(main.read())
         output = template.render(title=DEFAULT_TITLE, generator=generator,
                                  heading=heading, report=report)
     return output.encode('utf8')
Beispiel #25
0
    def __finish_get_dashboards(self, request, username):
        graphs_per_user = yield self.__redis_model_graph.get_graphs_per_user()

        template = self.__template_lookup.get_template('dashboards.mako')

        page = template.render(username=username,
                graphs_per_user=graphs_per_user).encode('utf8')

        request.write(page)
        request.finish()
Beispiel #26
0
def WriteLexerList(config):
  """Writes the Java class containing the list of all lexers.

  Args:
    config: an OutputConfiguration object.
  """
  outfile = config.OutputFile('Lexers')
  template = mako.template.Template(
      resources.GetResource(os.path.join(_TEMPLATES_DIR, 'lexers.mako')))
  lexer_list = dict((name, _JavaLexerName(name)) for name in lexers.ALL)
  outfile.write(template.render(lexers=lexer_list, package=config.package))
Beispiel #27
0
def print_namespaces(default_namespace, section_namespaces):
    """Print namespaces with the MarioFile format.

    :param dict default_namespace: Default namespace dictionary.
    :param dict section_namespaces: Section namespaces dictionary.
    :return: str
    """
    template = mako.template.Template(TEMPLATE)
    namespaces = template.render(
            default_namespace=default_namespace, section_namespaces=section_namespaces
    )
    return namespaces
Beispiel #28
0
 def index(self):
     # for debug purposes:
     #HueBridge.update()
     template = mako.template.Template(filename='plugins/HueControl/HueControl.tmpl')
     try:
         # Check the authentication with the bridge
         HueBridge.authenticate()
         HueBridge.update()
     except ConnectionException as e:
         return Template.render_template("", error="Bridge is not authenticated! Press the link button and <a href=\"\"> try again</a>!")
         
     rendered_template = template.render(lights=HueBridge.lights, groups=HueBridge.groups)
     return Template.render_template(rendered_template)
Beispiel #29
0
def render_file(src, dst, coins, support_info):
    """Renders `src` template into `dst`.

    `src` is a filename, `dst` is an open file object.
    """
    template = mako.template.Template(filename=src)
    result = template.render(
        support_info=support_info,
        supported_on=make_support_filter(support_info),
        **coins,
        **MAKO_FILTERS,
    )
    dst.write(result)
Beispiel #30
0
def render(data_file, template_file, destination_file):
    """Build the HTML content from scraped data"""
    template = mako.template.Template(filename=template_file)
    print "Loading data from %s..." % data_file
    with open(data_file) as f:
        instances = json.load(f)
    for i in instances:
        add_render_info(i)
    print "Rendering to %s..." % destination_file
    with open(destination_file, 'w') as fh:
        try:
            fh.write(template.render(instances=instances))
        except:
            print mako.exceptions.text_error_template().render()
Beispiel #31
0
def main():
    options = make_argparser().parse_args()

    template = mako.template.Template(filename=os.path.abspath(options.input))

    try:
        rendered = template.render(**MAKO_GLOBALS)
    except:
        traceback = mako.exceptions.RichTraceback()
        for (filename, lineno, function, line) in traceback.traceback:
            print "  File %s, line %s, in %s" % (filename, lineno, function)
            print "    %s" % line
        print "%s: %s" % (str(traceback.error.__class__.__name__), traceback.error)
        sys.exit(1)

    with open(options.output, "w") as out_file:
        out_file.write(rendered)
Beispiel #32
0
def render(data_file, template_file, destination_file):
    """Build the HTML content from scraped data"""
    template = mako.template.Template(filename=template_file)
    print "Loading data from %s..." % data_file
    with open(data_file) as f:
        instances = json.load(f)
    for i in instances:
        add_render_info(i)
    print "Rendering to %s..." % destination_file
    generated_at = datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC')
    with open(destination_file, 'w') as fh:
        try:
            fh.write(
                template.render(instances=instances,
                                generated_at=generated_at))
        except:
            print mako.exceptions.text_error_template().render()
Beispiel #33
0
    def __init__(self,
                 difficulty=1.0,
                 texturedir='/tmp/mujoco_textures',
                 hfield_dir='/tmp/mujoco_terrains',
                 regen_terrain=True,
                 *args,
                 **kwargs):
        Serializable.quick_init(self, locals())

        self.difficulty = max(difficulty, self.MIN_DIFFICULTY)
        self.texturedir = texturedir
        self.hfield_dir = hfield_dir

        model_cls = self.__class__.MODEL_CLASS
        if model_cls is None:
            raise "MODEL_CLASS unspecified!"

        template_file_name = 'hill_' + model_cls.__module__.split(
            '.')[-1] + '.xml.mako'

        template_options = dict(difficulty=self.difficulty,
                                texturedir=self.texturedir,
                                hfield_file=os.path.join(
                                    self.hfield_dir, self.HFIELD_FNAME))

        file_path = os.path.join(MODEL_DIR, template_file_name)
        lookup = mako.lookup.TemplateLookup(directories=[MODEL_DIR])
        with open(file_path) as template_file:
            template = mako.template.Template(template_file.read(),
                                              lookup=lookup)
        content = template.render(opts=template_options)

        tmp_f, file_path = tempfile.mkstemp(suffix=".xml", text=True)
        with open(file_path, 'w') as f:
            f.write(content)

        if self._iam_terrain_generator(regen_terrain):
            self._gen_terrain(regen_terrain)
            os.remove(self._get_lock_path())

        inner_env = model_cls(*args, file_path=file_path,
                              **kwargs)  # file to the robot specifications
        ProxyEnv.__init__(
            self, inner_env)  # here is where the robot env will be initialized

        os.close(tmp_f)
Beispiel #34
0
 def __init__(self, action_noise=0.0, file_path=None, template_args=None):
     # compile template
     if file_path is None:
         if self.__class__.FILE is None:
             raise "Mujoco file not specified"
         file_path = osp.join(MODEL_DIR, self.__class__.FILE)
     if file_path.endswith(".mako"):
         lookup = mako.lookup.TemplateLookup(directories=[MODEL_DIR])
         with open(file_path) as template_file:
             template = mako.template.Template(template_file.read(),
                                               lookup=lookup)
         content = template.render(
             opts=template_args if template_args is not None else {}, )
         tmp_f, file_path = tempfile.mkstemp(text=True)
         with open(file_path, 'w') as f:
             f.write(content)
         self.model = MjModel(file_path)
         os.close(tmp_f)
     else:
         self.model = MjModel(file_path)
     self.data = self.model.data
     self.viewer = None
     self.init_qpos = self.model.data.qpos
     self.init_qvel = self.model.data.qvel
     self.init_qacc = self.model.data.qacc
     self.init_ctrl = self.model.data.ctrl
     self.qpos_dim = self.init_qpos.size
     self.qvel_dim = self.init_qvel.size
     self.ctrl_dim = self.init_ctrl.size
     self.action_noise = action_noise
     if "frame_skip" in self.model.numeric_names:
         frame_skip_id = self.model.numeric_names.index("frame_skip")
         addr = self.model.numeric_adr.flat[frame_skip_id]
         self.frame_skip = int(self.model.numeric_data.flat[addr])
     else:
         self.frame_skip = 1
     if "init_qpos" in self.model.numeric_names:
         init_qpos_id = self.model.numeric_names.index("init_qpos")
         addr = self.model.numeric_adr.flat[init_qpos_id]
         size = self.model.numeric_size.flat[init_qpos_id]
         init_qpos = self.model.numeric_data.flat[addr:addr + size]
         self.init_qpos = init_qpos
     self.dcom = None
     self.current_com = None
     self.reset()
     super(MujocoEnv, self).__init__()
Beispiel #35
0
 def run(self):
     self.write_metadata()
     logging.info('\tcreating index.html')
     # Remove the ./ from the beginning of these paths for use in filter
     self.flist = [x[2:] for x in self.file_list()]
     #self.flist = self.file_list()
     template = mako.template.Template(
         filename=pkg_resources.resource_filename('apps.data',
                                                  'index.html'),
         cache_enabled=False)
     index = open(os.path.join(self.project.path, 'build', 'index.html'),
                  'wb')
     index.write(
         template.render(scripts=self._scripts_list(self.project.metadata),
                         styles=self._styles_list(),
                         debug=self.vanguard.options.debug))
     index.close()
Beispiel #36
0
def render(data_file, template_file, destination_file):
    """Build the HTML content from scraped data"""
    lookup = mako.lookup.TemplateLookup(directories=['.'])
    template = mako.template.Template(filename=template_file, lookup=lookup)
    print("Loading data from %s..." % data_file)
    with open(data_file) as f:
        instances = json.load(f)
    for i in instances:
        add_render_info(i)
    print("Rendering to %s..." % destination_file)
    generated_at = datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC')
    with io.open(destination_file, 'w', encoding="utf-8") as fh:
        try:
            fh.write(
                template.render(instances=instances,
                                generated_at=generated_at))
        except:
            print(mako.exceptions.text_error_template().render())
Beispiel #37
0
def generate_service_file(metadata, template_file_name, generated_file_suffix,
                          gen_dir):
    current_dir = os.path.dirname(__file__)
    template_file_path = os.path.join(current_dir, "templates",
                                      template_file_name)
    template_directory = os.path.dirname(template_file_path)
    module_name = metadata["config"]["module_name"]
    output_dir = os.path.join(gen_dir, module_name)
    file_name = module_name + generated_file_suffix
    output_file_path = os.path.join(output_dir, file_name)

    os.makedirs(output_dir, exist_ok=True)
    template_lookup = TemplateLookup(directories=template_directory + "/")
    template = mako.template.Template(filename=template_file_path,
                                      lookup=template_lookup)
    f = open(output_file_path, "w+", newline="")
    f.write(template.render(data=metadata))
    f.close()
Beispiel #38
0
def reflect(**kw):
    from tweedr.models import metadata
    schema_filepath = os.path.join(os.path.dirname(metadata.__file__),
                                   'schema.py')
    schema_template_filepath = os.path.join(os.path.dirname(metadata.__file__),
                                            'schema.template')

    template = mako.template.Template(filename=schema_template_filepath)
    metadata.metadata.reflect()
    schema = template.render(metadata=metadata.metadata)

    if kw.get('in_place'):
        with open(schema_filepath, 'w') as out:
            out.write(schema)
    else:
        sys.stdout.write(schema)

    print >> sys.stderr, '\nDone printing schema'
Beispiel #39
0
 def render_dir(name):
     os.makedirs(os.path.join(target, name))
     for file in pkg_resources.resource_listdir(__name__, name):
         path = os.path.join(name, file)
         if pkg_resources.resource_isdir(__name__, path):
             render_dir(path)
         else:
             filename = pkg_resources.resource_filename(__name__, path)
             template = mako.template.Template(filename=filename)
             utils.getlogger().debug("rendering file %s", path)
             rendered = template.render(
                 packagename=packagename,
                 shipment=shipment,
                 distribution=distribution,
                 urgency=urgency,
             )
             with open(os.path.join(target, path), 'w+') as output:
                 output.write(rendered)
Beispiel #40
0
def create_report(results):
    template_kw = {
        "heading": {
            "title": __title__,
            "description": __description__,
            "parameters": [("Difference Count", len(results))]
        },
        "generator": "compare2html %s" % __version__,
        "results": results
    }

    template_path = os.path.join(os.path.dirname(__file__), "report_templates",
                                 "compare.mako")

    with open(template_path) as f:
        template = mako.template.Template(f.read(), strict_undefined=True)
        output = template.render(**template_kw)
        return output.encode("utf8")
Beispiel #41
0
def _render_entry_content(feed, max_ssh_info, config):
    max_ssh_time_local = arrow.get(max_ssh_info["max_ssh_time"]).to("local")
    feed_config = config["storm surge feeds"]["feeds"][feed]
    tide_gauge_stn = feed_config["tide gauge stn"]
    max_ssh_info.update(_calc_wind_4h_avg(feed, max_ssh_info["max_ssh_time"], config))
    values = {
        "city": feed_config["city"],
        "tide_gauge_stn": tide_gauge_stn,
        "conditions": {
            tide_gauge_stn: {
                "risk_level": max_ssh_info["risk_level"],
                "max_ssh_msl": max_ssh_info["max_ssh"],
                "wind_speed_4h_avg_kph": converters.mps_kph(
                    max_ssh_info["wind_speed_4h_avg"]
                ),
                "wind_speed_4h_avg_knots": converters.mps_knots(
                    max_ssh_info["wind_speed_4h_avg"]
                ),
                "wind_dir_4h_avg_heading": converters.bearing_heading(
                    converters.wind_to_from(max_ssh_info["wind_dir_4h_avg"])
                ),
                "wind_dir_4h_avg_bearing": converters.wind_to_from(
                    max_ssh_info["wind_dir_4h_avg"]
                ),
                "max_ssh_time": max_ssh_time_local,
                "max_ssh_time_tzname": max_ssh_time_local.tzinfo.tzname(
                    max_ssh_time_local.datetime
                ),
                "humanized_max_ssh_time": converters.humanize_time_of_day(
                    max_ssh_time_local
                ),
            }
        },
    }
    template = mako.template.Template(
        filename=os.path.join(
            os.path.dirname(__file__),
            config["storm surge feeds"]["feed entry template"],
        ),
        input_encoding="utf-8",
    )
    rendered_rst = template.render(**values)
    html = docutils.core.publish_parts(rendered_rst, writer_name="html")
    return html["body"]
Beispiel #42
0
    def index(self):
        # for debug purposes:
        #HueBridge.update()
        template = mako.template.Template(
            filename='plugins/HueControl/HueControl.tmpl')
        try:
            # Check the authentication with the bridge
            HueBridge.authenticate()
            HueBridge.update()
        except ConnectionException as e:
            return Template.render_template(
                "",
                error=
                "Bridge is not authenticated! Press the link button and <a href=\"\"> try again</a>!"
            )

        rendered_template = template.render(lights=HueBridge.lights,
                                            groups=HueBridge.groups)
        return Template.render_template(rendered_template)
Beispiel #43
0
    def __finish_get_graph(self, request, username, graph_username, title,
                           graph_type, timescale, force_max_value):

        graphs = yield self.__redis_model_graph.get_graphs(graph_username)

        graph_details = yield self.__get_graph_details(title, graphs[title],
                                                       graph_type, timescale)

        template = self.__template_lookup.get_template('graph.mako')

        ret = template.render(username=username,
                              graph_username=graph_username,
                              title=title,
                              graph_type=graph_type,
                              graph=[graph_details],
                              force_max_value=force_max_value).encode('utf8')

        request.write(ret)
        request.finish()
Beispiel #44
0
    def parse_and_compare(self, old, new):
        """
    Combine the parse and compare methods into one step.

    old -- the old web page.
    new -- the new web page.
    """

        parsed_new = self.parse(new)
        for parsed_new_row in self.parse(old).itervalues():
            logging.debug('Row: %s, Timestamp: %s', parsed_new_row['title'],
                          parsed_new_row['timestamp'])
        changed, diff_results = self.compare(self.parse(old), parsed_new)
        if not changed:
            return self.unchanged()
        else:
            filename = os.path.join(os.path.dirname(__file__),
                                    'template.forumdiff.html')
            template = mako.template.Template(filename=filename)
            return self.changed(template.render(diff_results=diff_results))
Beispiel #45
0
    def render_string(self, template_path, **kwargs):
        try:
            _debug = self.get_argument("debug", "false")
            template = self.lookup.get_template(template_path)
            namespace = self.get_template_namespace()
            namespace.update(kwargs)

            env_kwargs = dict(
                handler=self,
                request=self.request,
                locale=self.locale,
                static_url=self.static_url,
                xsrf_form_html=self.xsrf_form_html,
                reverse_url=self.application.reverse_url,
            )
            env_kwargs.update(kwargs)
            return template.render(**env_kwargs)
        except Exception as e:
            print("服务端错误")
            print(e)
Beispiel #46
0
def main(config, template, outfile=None, **args):
    template = load_template(template)

    data = load_yaml(config)
    validate_yaml(data)
    data['tree'] = prepare_tree(data, data['tree'])
    data['all_ids'] = list(gather_ids(data['tree']))
    data['all_ids_as_json'] = json.dumps(data['all_ids'], indent=4)
    data['tree_as_json'] = json.dumps(data['tree'], indent=4)

    kwargs = copy.copy(defaults)
    kwargs.update(data)
    html = template.render(**kwargs)

    if outfile:
        with open(outfile, 'w') as f:
            f.write(html)
        print("Wrote", outfile)
    else:
        print(html)
Beispiel #47
0
    def render_string(self, template_name, **context):

        try:
            context.update({
                'xsrf': self.xsrf_form_html,
                'module': self.ui.modules,
                'request': self.request,
                'user': self.current_user,
                'handler': self,
            })

            template = self.lookup.get_template(template_name)
            namespace = self.get_template_namespace()
            namespace.update(context)
            return template.render(**namespace)
        except:
            #print(exceptions.text_error_template().render())
            #return exceptions.text_error_template().render()
            #print(exceptions.html_error_template().render())
            return exceptions.html_error_template().render()
Beispiel #48
0
    def _apply_text_cmd(self, node, data_object):
        # Mako text substitution
        template = mako.template.Template(self._args_text,
                                          strict_undefined=True)
        render_result = template.render(**data_object.variables)

        if node.tag == "{http://www.w3.org/2000/svg}text":
            tspan = node.find("{http://www.w3.org/2000/svg}tspan")
            if tspan is not None:
                tspan.text = render_result
            else:
                print("No tspan found in text element.")
        elif node.tag == "{http://www.w3.org/2000/svg}flowRoot":
            para = node.find("{http://www.w3.org/2000/svg}flowPara")
            if para is not None:
                para.text = render_result
            else:
                print("No flowPara found in flowRoot element.")
        else:
            print("Do not know how to substitute text in node '%s'." %
                  (node.tag))
def _render_entry_content(feed, max_ssh_info, config):
    max_ssh_time_local = arrow.get(max_ssh_info['max_ssh_time']).to('local')
    feed_config = config['storm surge feeds']['feeds'][feed]
    tide_gauge_stn = feed_config['tide gauge stn']
    max_ssh_info.update(
        _calc_wind_4h_avg(feed, max_ssh_info['max_ssh_time'], config))
    values = {
        'city': feed_config['city'],
        'tide_gauge_stn': tide_gauge_stn,
        'conditions': {
            tide_gauge_stn: {
                'risk_level':
                max_ssh_info['risk_level'],
                'max_ssh_msl':
                max_ssh_info['max_ssh'],
                'wind_speed_4h_avg_kph':
                converters.mps_kph(max_ssh_info['wind_speed_4h_avg']),
                'wind_speed_4h_avg_knots':
                converters.mps_knots(max_ssh_info['wind_speed_4h_avg']),
                'wind_dir_4h_avg_heading':
                converters.bearing_heading(
                    converters.wind_to_from(max_ssh_info['wind_dir_4h_avg'])),
                'wind_dir_4h_avg_bearing':
                converters.wind_to_from(max_ssh_info['wind_dir_4h_avg']),
                'max_ssh_time':
                max_ssh_time_local,
                'max_ssh_time_tzname':
                max_ssh_time_local.tzinfo.tzname(max_ssh_time_local.datetime),
                'humanized_max_ssh_time':
                converters.humanize_time_of_day(max_ssh_time_local),
            }
        }
    }
    template = mako.template.Template(filename=os.path.join(
        os.path.dirname(__file__),
        config['storm surge feeds']['feed entry template']),
                                      input_encoding='utf-8')
    rendered_rst = template.render(**values)
    html = docutils.core.publish_parts(rendered_rst, writer_name='html')
    return html['body']
Beispiel #50
0
 def render_string(self, filename, **kwargs):
     '''Override render_string to use mako template.
     Like tornado render_string method, this method
     also pass request handler environment to template engine.
     '''
     try:
         template = self._lookup.get_template(filename)
         env_kwargs = dict(
             handler=self,
             request=self.request,
             current_user=self.current_user,
             locale=self.locale,
             _=self.locale.translate,
             static_url=self.static_url,
             xsrf_form_html=self.xsrf_form_html,
             reverse_url=self.application.reverse_url,
         )
         env_kwargs.update(kwargs)
         return template.render(**env_kwargs)
     except:
         # exception handler
         return exceptions.html_error_template().render()
Beispiel #51
0
 def __init__(self, action_noise=0.0, file_path=None, template_args=None):
     # compile template
     if file_path is None:
         if self.__class__.FILE is None:
             raise NotImplementedError("Mujoco file not specified")
         file_path = osp.join(MODEL_DIR, self.__class__.FILE)
     if file_path.endswith(".mako"):
         lookup = mako.lookup.TemplateLookup(directories=[MODEL_DIR])
         with open(file_path) as template_file:
             template = mako.template.Template(template_file.read(),
                                               lookup=lookup)
         content = template.render(
             opts=template_args if template_args is not None else {}, )
         tmp_f, file_path = tempfile.mkstemp(suffix=".xml", text=True)
         with open(file_path, 'w') as f:
             f.write(content)
         self.model = load_model_from_path(file_path)
         os.close(tmp_f)
     else:
         self.model = load_model_from_path(file_path)
     self.sim = MjSim(self.model)
     self.data = self.sim.data
     self.viewer = None
     self.render_width = 512
     self.render_height = 512
     self.render_camera = None
     self.init_qpos = self.sim.data.qpos
     self.init_qvel = self.sim.data.qvel
     self.init_qacc = self.sim.data.qacc
     self.init_ctrl = self.sim.data.ctrl
     self.qpos_dim = self.init_qpos.size
     self.qvel_dim = self.init_qvel.size
     self.ctrl_dim = self.init_ctrl.size
     self.action_noise = action_noise
     self.frame_skip = 1
     self.dcom = None
     self.current_com = None
     self.reset()
     super().__init__()
Beispiel #52
0
    def instanciate(self, templatename, destfilename, **kwargs):
        perms = kwargs.get("perms", 0o644)
        usergrp = kwargs.get("usergrp", "root:root")
        print(
            "%s: Creating %s from %s -> %s with %o perms" %
            (self._generatorname, destfilename, templatename, usergrp, perms),
            file=sys.stderr)

        # Some templates have special data
        renderdata = kwargs.get("data", {})

        infolines = [
            destfilename,
            "Automatically generated by module %s of networkconfig on %s." %
            (self._generatorname, time.strftime("%Y-%m-%d %H:%M:%S")),
            "DO NOT CHANGE MANUALLY. All changes will be overwritten.",
        ]

        # But these are available in every script
        renderdata.update({
            "hosts": self._data["hosts"],
            "networks": self._data["networks"],
            "geninfo": infolines,
        })

        template = _Template(self._cmdlineargs.gendir + self._generatorname +
                             "/" + templatename)
        result = template.render(renderdata)

        outfilename = self._cmdlineargs.outdir + destfilename
        outdir = os.path.dirname(outfilename)
        try:
            os.makedirs(outdir)
        except OSError:
            pass

        with open(outfilename, "w") as f:
            f.write(result)
Beispiel #53
0
    def __finish_get_user_dashboards(self, request, dashboard_username,
                                     username):

        graphs = yield self.__redis_model_graph.get_graphs(dashboard_username)

        graph_data = [None] * len(graphs)

        for title, each_graph in graphs.iteritems():
            graph_data[
                each_graph['ordering']] = yield self.__get_graph_details(
                    title, each_graph)

        template = self.__template_lookup.get_template('index.mako')

        ret = template.render(components=[],
                              username=username,
                              dashboard_username=dashboard_username,
                              edit=None,
                              graphs=graph_data,
                              cgi=cgi).encode('utf8')

        request.write(ret)
        request.finish()
Beispiel #54
0
 def render_string(self, filename, **kwargs):
     '''
         Override render_string to use mako template.
         Like tornado render_string method, this method also
         pass request handler environment to template engine
     '''
     try:
         # if not self.is_mobile():
         #     template = self.LOOK_UP.get_template(filename)
         # else:
         #     template = self.LOOK_UP_MOBILE.get_template(filename)
         # cms = 'http://cms.bidongwifi.com/'
         template = self.LOOK_UP.get_template(filename)
         env_kwargs = dict(
             handler=self,
             request=self.request,
             # current_user = self.current_user
             locale=self.locale,
             _=self.locale.translate,
             static_url=self.static_url,
             xsrf_form_html=self.xsrf_form_html,
             reverse_url=self.application.reverse_url,
             cms=self._cms,
         )
         env_kwargs.update(kwargs)
         return template.render(**env_kwargs)
     except:
         from mako.exceptions import RichTraceback
         tb = RichTraceback()
         for (module_name, line_no, function_name, line) in tb.traceback:
             print('File:{}, Line:{} in {}'.format(module_name, line_no,
                                                   function_name))
             print(line)
         logger.error('Render {} failed, {}:{}'.format(
             filename, tb.error.__class__.__name__, tb.error),
                      exc_info=True)
         raise HTTPError(500, 'Render page failed')
Beispiel #55
0
    def render(self,
               caller,
               template_path=None,
               template_text=None,
               template_vars=None):
        """
        Renders the template with variable bindings.

        It's okay to invoke |render| method recursively and |caller| is pushed
        onto the call stack, which is accessible via |callers| and |last_caller|
        methods.

        Args:
            template_path: A filepath to a template file.
            template_text: A text content to be used as a template.  Either of
                |template_path| or |template_text| must be specified.
            template_vars: Template variable bindings.
            caller: An object to be pushed onto the call stack.
        """

        assert template_path is not None or template_text is not None
        assert template_path is None or template_text is None
        assert isinstance(template_vars, dict)
        assert caller is not None

        self._caller_stack.append(caller)

        try:
            if template_path is not None:
                template = self._template_lookup.get_template(template_path)
            elif template_text is not None:
                template = mako.template.Template(text=template_text)
            text = template.render(**template_vars)
        finally:
            self._caller_stack.pop()

        return text
Beispiel #56
0
def render(data_file, template_file, destination_file):
    """Build the HTML content from scraped data"""
    lookup = mako.lookup.TemplateLookup(directories=["."])
    template = mako.template.Template(filename=template_file, lookup=lookup)
    with open(data_file, "r") as f:
        instances = json.load(f)

    print("Loading data from %s..." % data_file)
    for i in instances:
        add_render_info(i)
    pricing_json = compress_pricing(instances)
    generated_at = datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S UTC")
    instance_azs_json = compress_instance_azs(instances)

    sitemap = []
    if data_file == "www/instances.json":
        sitemap.extend(build_detail_pages_ec2(instances, destination_file))
    elif data_file == "www/rds/instances.json":
        sitemap.extend(build_detail_pages_rds(instances, destination_file))

    print("Rendering to %s..." % destination_file)
    os.makedirs(os.path.dirname(destination_file), exist_ok=True)
    with io.open(destination_file, "w+", encoding="utf-8") as fh:
        try:
            fh.write(
                template.render(
                    instances=instances,
                    pricing_json=pricing_json,
                    generated_at=generated_at,
                    instance_azs_json=instance_azs_json,
                ))
            sitemap.append(destination_file)
        except:
            print(mako.exceptions.text_error_template().render())

    return sitemap
Beispiel #57
0
    def package(self, release=False, dev=False, android=None, magicleap=None, debug=False,
                debugger=None, target=None, flavor=None, maven=False):
        if android is None:
            android = self.config["build"]["android"]
        if target and android:
            print("Please specify either --target or --android.")
            sys.exit(1)
        if not android:
            android = self.handle_android_target(target)
        else:
            target = self.config["android"]["target"]
        if target and magicleap:
            print("Please specify either --target or --magicleap.")
            sys.exit(1)
        if magicleap:
            target = "aarch64-linux-android"
        env = self.build_env(target=target)
        binary_path = self.get_binary_path(release, dev, android=android, magicleap=magicleap)
        dir_to_root = self.get_top_dir()
        target_dir = path.dirname(binary_path)
        if magicleap:
            if platform.system() not in ["Darwin"]:
                raise Exception("Magic Leap builds are only supported on macOS.")
            if not env.get("MAGICLEAP_SDK"):
                raise Exception("Magic Leap builds need the MAGICLEAP_SDK environment variable")
            if not env.get("MLCERT"):
                raise Exception("Magic Leap builds need the MLCERT environment variable")
            mabu = path.join(env.get("MAGICLEAP_SDK"), "mabu")
            package = "./support/magicleap/Servo2D/Servo2D.package"
            if dev:
                build_type = "lumin_debug"
            else:
                build_type = "lumin_release"
            argv = [
                mabu,
                "-o", target_dir,
                "-t", build_type,
                package
            ]
            try:
                subprocess.check_call(argv, env=env)
            except subprocess.CalledProcessError as e:
                print("Packaging Magic Leap exited with return value %d" % e.returncode)
                return e.returncode
        elif android:
            android_target = self.config["android"]["target"]
            if "aarch64" in android_target:
                build_type = "Arm64"
            elif "armv7" in android_target:
                build_type = "Armv7"
            elif "i686" in android_target:
                build_type = "x86"
            else:
                build_type = "Arm"

            if dev:
                build_mode = "Debug"
            else:
                build_mode = "Release"

            flavor_name = "Main"
            if flavor is not None:
                flavor_name = flavor.title()

            vr = flavor == "googlevr" or flavor == "oculusvr"

            dir_to_resources = path.join(self.get_top_dir(), 'target', 'android', 'resources')
            if path.exists(dir_to_resources):
                delete(dir_to_resources)

            shutil.copytree(path.join(dir_to_root, 'resources'), dir_to_resources)
            change_prefs(dir_to_resources, "android", vr=vr)

            variant = ":assemble" + flavor_name + build_type + build_mode
            apk_task_name = ":servoapp" + variant
            aar_task_name = ":servoview" + variant
            maven_task_name = ":servoview:uploadArchive"
            argv = ["./gradlew", "--no-daemon", apk_task_name, aar_task_name]
            if maven:
                argv.append(maven_task_name)
            try:
                with cd(path.join("support", "android", "apk")):
                    subprocess.check_call(argv, env=env)
            except subprocess.CalledProcessError as e:
                print("Packaging Android exited with return value %d" % e.returncode)
                return e.returncode
        elif is_macosx():
            print("Creating Servo.app")
            dir_to_dmg = path.join(target_dir, 'dmg')
            dir_to_app = path.join(dir_to_dmg, 'Servo.app')
            dir_to_resources = path.join(dir_to_app, 'Contents', 'Resources')
            if path.exists(dir_to_dmg):
                print("Cleaning up from previous packaging")
                delete(dir_to_dmg)

            print("Copying files")
            shutil.copytree(path.join(dir_to_root, 'resources'), dir_to_resources)
            shutil.copy2(path.join(dir_to_root, 'Info.plist'), path.join(dir_to_app, 'Contents', 'Info.plist'))

            content_dir = path.join(dir_to_app, 'Contents', 'MacOS')
            os.makedirs(content_dir)
            shutil.copy2(binary_path, content_dir)

            change_prefs(dir_to_resources, "macosx")

            print("Finding dylibs and relinking")
            copy_dependencies(path.join(content_dir, 'servo'), content_dir)

            print("Adding version to Credits.rtf")
            version_command = [binary_path, '--version']
            p = subprocess.Popen(version_command,
                                 stdout=subprocess.PIPE,
                                 stderr=subprocess.PIPE,
                                 universal_newlines=True)
            version, stderr = p.communicate()
            if p.returncode != 0:
                raise Exception("Error occurred when getting Servo version: " + stderr)
            version = "Nightly version: " + version

            import mako.template
            template_path = path.join(dir_to_resources, 'Credits.rtf.mako')
            credits_path = path.join(dir_to_resources, 'Credits.rtf')
            with open(template_path) as template_file:
                template = mako.template.Template(template_file.read())
                with open(credits_path, "w") as credits_file:
                    credits_file.write(template.render(version=version))
            delete(template_path)

            print("Creating dmg")
            os.symlink('/Applications', path.join(dir_to_dmg, 'Applications'))
            dmg_path = path.join(target_dir, "servo-tech-demo.dmg")

            if path.exists(dmg_path):
                print("Deleting existing dmg")
                os.remove(dmg_path)

            try:
                subprocess.check_call(['hdiutil', 'create',
                                       '-volname', 'Servo',
                                       '-megabytes', '900',
                                       dmg_path,
                                       '-srcfolder', dir_to_dmg])
            except subprocess.CalledProcessError as e:
                print("Packaging MacOS dmg exited with return value %d" % e.returncode)
                return e.returncode
            print("Cleaning up")
            delete(dir_to_dmg)
            print("Packaged Servo into " + dmg_path)

            print("Creating brew package")
            dir_to_brew = path.join(target_dir, 'brew_tmp')
            dir_to_tar = path.join(target_dir, 'brew')
            if not path.exists(dir_to_tar):
                os.makedirs(dir_to_tar)
            tar_path = path.join(dir_to_tar, "servo.tar.gz")
            if path.exists(dir_to_brew):
                print("Cleaning up from previous packaging")
                delete(dir_to_brew)
            if path.exists(tar_path):
                print("Deleting existing package")
                os.remove(tar_path)
            shutil.copytree(path.join(dir_to_root, 'resources'), path.join(dir_to_brew, 'resources'))
            os.makedirs(path.join(dir_to_brew, 'bin'))
            shutil.copy2(binary_path, path.join(dir_to_brew, 'bin', 'servo'))
            # Note that in the context of Homebrew, libexec is reserved for private use by the formula
            # and therefore is not symlinked into HOMEBREW_PREFIX.
            os.makedirs(path.join(dir_to_brew, 'libexec'))
            copy_dependencies(path.join(dir_to_brew, 'bin', 'servo'), path.join(dir_to_brew, 'libexec'))
            archive_deterministically(dir_to_brew, tar_path, prepend_path='servo/')
            delete(dir_to_brew)
            print("Packaged Servo into " + tar_path)
        elif is_windows():
            dir_to_msi = path.join(target_dir, 'msi')
            if path.exists(dir_to_msi):
                print("Cleaning up from previous packaging")
                delete(dir_to_msi)
            os.makedirs(dir_to_msi)

            print("Copying files")
            dir_to_temp = path.join(dir_to_msi, 'temp')
            dir_to_resources = path.join(dir_to_temp, 'resources')
            shutil.copytree(path.join(dir_to_root, 'resources'), dir_to_resources)
            shutil.copy(binary_path, dir_to_temp)
            copy_windows_dependencies(target_dir, dir_to_temp)

            change_prefs(dir_to_resources, "windows")

            # generate Servo.wxs
            import mako.template
            template_path = path.join(dir_to_root, "support", "windows", "Servo.wxs.mako")
            template = mako.template.Template(open(template_path).read())
            wxs_path = path.join(dir_to_msi, "Installer.wxs")
            open(wxs_path, "w").write(template.render(
                exe_path=target_dir,
                dir_to_temp=dir_to_temp,
                resources_path=dir_to_resources))

            # run candle and light
            print("Creating MSI")
            try:
                with cd(dir_to_msi):
                    subprocess.check_call(['candle', wxs_path])
            except subprocess.CalledProcessError as e:
                print("WiX candle exited with return value %d" % e.returncode)
                return e.returncode
            try:
                wxsobj_path = "{}.wixobj".format(path.splitext(wxs_path)[0])
                with cd(dir_to_msi):
                    subprocess.check_call(['light', wxsobj_path])
            except subprocess.CalledProcessError as e:
                print("WiX light exited with return value %d" % e.returncode)
                return e.returncode
            dir_to_installer = path.join(dir_to_msi, "Installer.msi")
            print("Packaged Servo into " + dir_to_installer)

            # Generate bundle with Servo installer.
            print("Creating bundle")
            shutil.copy(path.join(dir_to_root, 'support', 'windows', 'Servo.wxs'), dir_to_msi)
            bundle_wxs_path = path.join(dir_to_msi, 'Servo.wxs')
            try:
                with cd(dir_to_msi):
                    subprocess.check_call(['candle', bundle_wxs_path, '-ext', 'WixBalExtension'])
            except subprocess.CalledProcessError as e:
                print("WiX candle exited with return value %d" % e.returncode)
                return e.returncode
            try:
                wxsobj_path = "{}.wixobj".format(path.splitext(bundle_wxs_path)[0])
                with cd(dir_to_msi):
                    subprocess.check_call(['light', wxsobj_path, '-ext', 'WixBalExtension'])
            except subprocess.CalledProcessError as e:
                print("WiX light exited with return value %d" % e.returncode)
                return e.returncode
            print("Packaged Servo into " + path.join(dir_to_msi, "Servo.exe"))

            print("Creating ZIP")
            zip_path = path.join(dir_to_msi, "Servo.zip")
            archive_deterministically(dir_to_temp, zip_path, prepend_path='servo/')
            print("Packaged Servo into " + zip_path)

            print("Cleaning up")
            delete(dir_to_temp)
            delete(dir_to_installer)
        else:
            dir_to_temp = path.join(target_dir, 'packaging-temp')
            if path.exists(dir_to_temp):
                # TODO(aneeshusa): lock dir_to_temp to prevent simultaneous builds
                print("Cleaning up from previous packaging")
                delete(dir_to_temp)

            print("Copying files")
            dir_to_resources = path.join(dir_to_temp, 'resources')
            shutil.copytree(path.join(dir_to_root, 'resources'), dir_to_resources)
            shutil.copy(binary_path, dir_to_temp)

            change_prefs(dir_to_resources, "linux")

            print("Creating tarball")
            tar_path = path.join(target_dir, 'servo-tech-demo.tar.gz')

            archive_deterministically(dir_to_temp, tar_path, prepend_path='servo/')

            print("Cleaning up")
            delete(dir_to_temp)
            print("Packaged Servo into " + tar_path)
 def render_string(self, filename, **kwargs):
     template = self.lookup.get_template(filename)
     namespace = self.get_template_namespace()
     namespace.update(kwargs)
     return template.render(**namespace)
Beispiel #59
0
 def renderer(data, opts):
     kwargs = mako_env.copy()
     kwargs.update({"data": data, "opts": opts})
     return template.render(**kwargs)
Beispiel #60
0
 def _render_template(template_file, **kwargs):
     template = mako.template.Template(filename=str(template_file))
     return template.render(**kwargs)