Python domain.Domain类代码示例

    def load(self,template,vars):
        dp=os.path.dirname(template)
        if dp != '':
            self.domain=dp
            
        filename=os.path.basename(template)

        try:
            d=Domain(self.domain, quoting=None, errors=4) # fixme: what do we really want for quoting?
            t=Domain(self.domain, errors=4).get_template(filename, quoting="str") # fixme: why create two Domains?
        except Exception as e:
            print "(domain is %s)" % self.domain
            raise e

        evars=evoque_dict()             # special dict that returns missing keys as "${key}"
        evars.update(vars)
        yaml_txt=t.evoque(evars)

        # fix eval errors:
        # fixed_yaml=re.sub('\[EvalError\(([a-z_]+)\)]', "${\g<1>}", yaml_txt) # ooh, magic! great.
        # fixed_yaml=re.sub('\[NameError: name &#39; ([a-z_]+)\)]', "${\g<1>}", yaml_txt) # ooh, magic! great.
        # fixed_yaml=re.sub('&lt;built-in function ([a-z_]+)&gt;', "${\g<1>}", fixed_yaml) # christ, more magic

#        warn("syml.load: fixed_yaml is %s" % fixed_yaml)
        d=yaml.load(yaml_txt)
            
        # "fix" config; ie, resolve referenced values
        d=self._fix_hash(d,d)
        return d

 def test_overlay(self):
     td = Domain(DEFAULT_DIR)
     t = td.get_template('overlay.html')
     self.assertEqual(
             eval("dict(%s)"%(t.eval_overlay)), dict(name="base.html"))
     space, overlay = t.get_space_overlay()
     self.failUnless(space is True)
     self.failUnless(t.labels == ["content"])
     # t.evoque(title="positive overlay test", parametrized="and happy")
     
     chain_pos = td.get_template('overlay_chain_pos.html')
     self.assertEqual(
         eval("dict(%s)"%(chain_pos.eval_overlay)), dict(name="overlay_mid.html"))
     space, overlay = chain_pos.get_space_overlay()
     self.failUnless(space is True)
     self.failUnless(chain_pos.labels == ["content"])
     # chain_pos.evoque(title="positive overlay test", parametrized="and happy")
     
     chain_neg = td.get_template('overlay_chain_neg.html')
     self.assertEqual(eval("dict(%s)"%(chain_neg.eval_overlay)), 
         dict(name="overlay_mid.html", space="negative"))
     space, overlay = chain_neg.get_space_overlay()
     self.failUnless(space is False)
     self.failUnless(chain_neg.labels == ["content", "footer"])
     # chain_neg.evoque(title="negative overlay test", parametrized="and happy")
     
     b = td.get_template('base.html')
     self.failUnless(b.labels == ["header", "content", "footer"])
     self.failIf(b.eval_overlay is not None)
     self.assertRaises((TypeError,), b.get_space_overlay)

    def load(self):
        # get globals if necessary
        if (self.globals == {}) and self.globals_file:
            f = open(self.globals_file, "r")
            self.globals = yaml.load(f)
            f.close

        # read config template (with globals)
        if not self.config_file:
            raise Exception("no config_file")

        if not self.domain:
            try:
                self.domain = self.globals["domain"]
            except:
                self.domain = os.getcwd()
                print "warning: looking for globals.yml in local directory!"

        try:
            t = Domain(self.domain).get_template(self.config_file)
        except Exception as e:
            print "(domain is %s)" % self.domain
            raise e

        conf_yaml = t.evoque(self.globals)
        conf = yaml.load(conf_yaml)

        # "fix" config; ie, resolve referenced values
        conf = self._fix_hash(conf, conf)
        conf.update({"globals": self.globals})

        self.config = conf

 def test_literals(self):
     td = Domain(DEFAULT_DIR, restricted=RESTRICTED, errors=ERRORS)
     name = "template.html"
     t = td.get_template(name + "#literals")
     r = "<p>a $ dollar, a literal ${expr}, a % percent... { } ! \ etc.</p>"
     self.assertEqual(r, t.evoque())
     self.assertRaises((SyntaxError,), td.get_template, name+"#unescaped")

 def test_evoque_local_nested_from_string(self):
     td = Domain(DEFAULT_DIR, restricted=RESTRICTED, errors=ERRORS)
     src = open(join(DEFAULT_DIR, "evoque_local_nested.html")).read()
     name = "fromstr"
     nested_name = name + "#label"
     data = dict(title="A Title", param="A Param")
     r = "<h1>A Title</h1><p>some A Param text</p>"
     # Load a from_string template that locally-nests another template
     td.set_template(name, src=src, from_string=True)
     t1 = td.get_template(name)
     # Verify nested template is not yet loaded
     self.assertEqual(False, t1.collection.has_template(nested_name))
     # Evoque, and verify response (multiple times, ensure data stays ok)
     self.assertEqual(r, t1.evoque(data)) # data as locals
     self.assertEqual(r, t1.evoque(**data)) # data as kw
     self.assertEqual(r, t1.evoque(data)) # data as locals
     self.assertEqual(r, t1.evoque(**data)) # data as kw
     # Verify nested template is now loaded
     self.assertEqual(True, t1.collection.has_template(nested_name))
     # Verify that tring to set nested template will fail
     self.assertRaises((ValueError,), td.set_template, nested_name, 
             src=src, from_string=True)
     t2 = td.get_template(nested_name)
     self.assertEqual(t2.ts, "<h1>%(title)s</h1><p>some %(param)s text</p>")
     self.assertEqual(r, t2.evoque(**data))

    def test_raw_nested(self):
        if not xml:
            return 
        td = Domain(DEFAULT_DIR, restricted=RESTRICTED, errors=ERRORS)
        t = td.get_template('raw_nested.html')
        self.assertEqual(t.evoque()[:87], """
$begin{table_row}
    $for{ col in row }
        <td>${col}</td>
    $else""")
        self.failUnless(isinstance(t.evoque(), xml))
        # template #snapshot is already loaded with raw=True, quoting=str
        snap = td.get_template('raw_nested.html#snapshot')
        self.failUnless(snap.raw)
        self.failUnless(snap.qsclass is unistr)
        self.failUnless(isinstance(snap.evoque(), unistr))
        # template #snapshot is still already loaded...
        snapx = td.get_template('raw_nested.html#snapshot_xml')
        self.failUnless(isinstance(snapx.evoque(), xml))
        self.failUnless(snap.qsclass is unistr)
        self.failUnless(isinstance(snap.evoque(), unistr))
        snap.unload()
        self.failUnless(isinstance(snapx.evoque(), xml)) # reloads #snapshot
        snap = td.get_template('raw_nested.html#snapshot')
        self.failUnless(snap.qsclass is xml)
        self.failUnless(isinstance(snap.evoque(raw=True), xml))

 def test_get_mixed_name_src(self):
     td = Domain(DEFAULT_DIR, restricted=RESTRICTED, errors=ERRORS)
     name = '#label'
     src = 'evoque_local_nested.html'
     # Load a nested template and evoque it
     t = td.get_template(name, src)
     self.assertEqual(t.ts, "<h1>%(title)s</h1><p>some %(param)s text</p>")

def write_rnaseq_script(globals,pipeline,sample):
    domain=globals['domain']
    d=Domain(domain)
    t=d.get_template(globals['rnaseq_template'])

    # build up list of rnaseq.steps to be included in the final script:

    # augment globals hash with rnaseq vars:
    vars={'globals_file':'globals.yml',
          'rnaseq_steps':pipeline.as_python(),
          'steps_syml':os.path.join(globals['python_lib'],'pipeline.steps.syml'),     # hardcoded (for now?)
          'sample_yml':sample.conf_file,
          'timestamp':sample.timestamp(),
          }
    vars.update(globals)
    rnaseq_script=t.evoque(vars)

    # write script:
    os.mkdir(os.path.join(sample.working_dir(),'starflow','rnaseq'))
    fn=pipeline.script_filename('starflow/rnaseq','rnaseq','py')
    f=open(fn, 'w')
    f.write(rnaseq_script)
    f.close
    print "%s written" % fn
    return fn

 def test_overlay_kwargs(self):
     td = Domain(DEFAULT_DIR)
     r = "<base>base content!</base>"
     r_neg = ""
     responses = [ r, r, r, r, r_neg ]
     t = td.get_template('overlay_kwargs.html')
     for i, s in enumerate(t.test()):
         self.assertEqual(responses[i], s)

 def test_from_string_td(self):
     td = Domain(DEFAULT_DIR, restricted=RESTRICTED, errors=ERRORS)
     src = "<h1>${title}</h1><p>some ${param} text</p>"
     data = dict(title="A Title", param="A Param")
     r = "<h1>A Title</h1><p>some A Param text</p>"
     td.set_template("fromstr", src=src, from_string=True)
     t = td.get_template("fromstr")
     self.assertEqual(r, t.evoque(**data))

 def test_typical_usage_via_domain_implied_collection(self):
     td = Domain(DEFAULT_DIR, restricted=RESTRICTED, errors=ERRORS)
     name = 'template.html'
     t = td.get_template(name)
     self.failUnless(t.collection is td.get_collection())
     self.failUnless(t.collection is td.collections[""])
     self.failUnless(t is t.collection.get_template(name))
     self.failUnless(t is t.collection.domain.get_template(name, 
             collection=t.collection))

 def test_evoque_raw(self):
     td = Domain(DEFAULT_DIR, restricted=RESTRICTED, errors=ERRORS)
     name = 'evoque_local_nested.html#label'
     r = "<h1>${title}</h1><p>some ${param} text</p>"
     t = td.get_template(name, raw=True)
     self.assertEqual([], list(t.test()))
     self.assertEqual(None, t.ts)
     self.assertEqual(r, t.evoque(raw=True))
     self.assertEqual(r, t.evoque())

 def test_evoque_kwargs(self):
     td = Domain(DEFAULT_DIR, restricted=RESTRICTED, errors=4)
     r = "<h1>TITLE</h1><p>some PARAM text</p>"
     r_raw = "<h1>${title}</h1><p>some ${param} text</p>"
     r_q_str = "&lt;h1&gt;TITLE&lt;/h1&gt;&lt;p&gt;some PARAM text&lt;/p&gt;"
     responses = [ r, r, r, r, r, r_raw, r, r_q_str, r ]
     t = td.get_template('evoque_kwargs.html')
     for i, s in enumerate(t.test()):
         self.assertEqual(responses[i], s)

 def test_manual_quoting(self):
     td = Domain(DEFAULT_DIR, restricted=RESTRICTED, errors=ERRORS, quoting="str")
     name = "template.html#label"
     t = td.get_template(name)
     self.failUnless(unistr is t.qsclass)
     self.failUnless(unistr is t.evoque(title="str", param="<str/>").__class__)
     from cgi import escape
     self.assertEqual(self.r_xml_escaped, 
             t.evoque(title="q-xml", param=escape("<in>rm *</in>")))

 def test_file_addressing_collection_root_relative(self):
     td = Domain(DEFAULT_DIR, restricted=RESTRICTED, errors=ERRORS)
     name = '/template.html'
     src = '/template.html'
     self.assertRaises((LookupError,), td.get_template, name)
     self.assertRaises((LookupError,), td.get_template, name, src)
     # can have names start with "/" as long as the c-rel locator does not
     src = 'template.html'
     t = td.get_template(name, src=src)
     self.assertEqual(t.name, name)