Python Pynliner.run方法代码示例

# 需要导入模块: from pynliner import Pynliner [as 别名]
# 或者: from pynliner.Pynliner import run [as 别名]
class LogOptions(unittest.TestCase):
    def setUp(self):
        self.html = "<style>h1 { color:#ffcc00; }</style><h1>Hello World!</h1>"

    def test_no_log(self):
        self.p = Pynliner()
        self.assertEqual(self.p.log, None)
        self.assertEqual(cssutils.log.enabled, False)

    def test_custom_log(self):
        self.log = logging.getLogger('testlog')
        self.log.setLevel(logging.DEBUG)

        self.logstream = StringIO.StringIO()
        handler = logging.StreamHandler(self.logstream)
        log_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
        formatter = logging.Formatter(log_format)
        handler.setFormatter(formatter)
        self.log.addHandler(handler)

        self.p = Pynliner(self.log).from_string(self.html)

        self.p.run()
        log_contents = self.logstream.getvalue()
        self.assertTrue("DEBUG" in log_contents)

# 需要导入模块: from pynliner import Pynliner [as 别名]
# 或者: from pynliner.Pynliner import run [as 别名]
class CommaSelector(unittest.TestCase):
    def setUp(self):
        self.html = """<style>.b1,.b2 { font-weight:bold; } .c {color: red}</style><span class="b1">Bold</span><span class="b2 c">Bold Red</span>"""
        self.p = Pynliner().from_string(self.html)

    def test_fromString(self):
        """Test 'fromString' constructor"""
        self.assertEqual(self.p.source_string, self.html)

    def test_get_soup(self):
        """Test '_get_soup' method"""
        self.p._get_soup()
        self.assertEqual(unicode(self.p.soup), self.html)

    def test_get_styles(self):
        """Test '_get_styles' method"""
        self.p._get_soup()
        self.p._get_styles()
        self.assertEqual(self.p.style_string, u'.b1,.b2 { font-weight:bold; } .c {color: red}\n')
        self.assertEqual(unicode(self.p.soup), u'<span class="b1">Bold</span><span class="b2 c">Bold Red</span>')

    def test_apply_styles(self):
        """Test '_apply_styles' method"""
        self.p._get_soup()
        self.p._get_styles()
        self.p._apply_styles()
        self.assertEqual(unicode(self.p.soup), u'<span class="b1" style="font-weight: bold">Bold</span><span class="b2 c" style="color: red; font-weight: bold">Bold Red</span>')

    def test_run(self):
        """Test 'run' method"""
        output = self.p.run()
        self.assertEqual(output, u'<span class="b1" style="font-weight: bold">Bold</span><span class="b2 c" style="color: red; font-weight: bold">Bold Red</span>')

    def test_with_cssString(self):
        """Test 'with_cssString' method"""
        cssString = '.b1,.b2 {font-size: 2em;}'
        self.p = Pynliner().from_string(self.html).with_cssString(cssString)
        output = self.p.run()
        self.assertEqual(output, u'<span class="b1" style="font-weight: bold; font-size: 2em">Bold</span><span class="b2 c" style="color: red; font-weight: bold; font-size: 2em">Bold Red</span>')

    def test_fromString_complete(self):
        """Test 'fromString' complete"""
        output = pynliner.fromString(self.html)
        desired = u'<span class="b1" style="font-weight: bold">Bold</span><span class="b2 c" style="color: red; font-weight: bold">Bold Red</span>'
        self.assertEqual(output, desired)

    def test_comma_whitespace(self):
        """Test excess whitespace in CSS"""
        html = '<style>h1,  h2   ,h3,\nh4{   color:    #000}  </style><h1>1</h1><h2>2</h2><h3>3</h3><h4>4</h4>'
        desired_output = '<h1 style="color: #000">1</h1><h2 style="color: #000">2</h2><h3 style="color: #000">3</h3><h4 style="color: #000">4</h4>'
        output = Pynliner().from_string(html).run()
        self.assertEqual(output, desired_output)

    def test_comma_separated_nested_styles(self):
        html = """<style>.orange-wrapper p, .super-orange-wrapper p { color:orange; }</style><div class="orange-wrapper"><p>Orange</p></div><div><p>Black</p></div>"""
        desired_output = """<div class="orange-wrapper"><p style="color: orange">Orange</p></div><div><p>Black</p></div>"""
        output = Pynliner().from_string(html).run()
        self.assertEqual(output, desired_output)

# 需要导入模块: from pynliner import Pynliner [as 别名]
# 或者: from pynliner.Pynliner import run [as 别名]
class CommaSelector(unittest.TestCase):
    
    def setUp(self):
        self.html = """<style>.b1,.b2 { font-weight:bold; } .c {color: red}</style><span class="b1">Bold</span><span class="b2 c">Bold Red</span>"""
        self.p = Pynliner().from_string(self.html)
    
    def test_01_fromString(self):
        """Test 'fromString' constructor"""
        self.assertEqual(self.p.source_string, self.html)
    
    def test_02_get_soup(self):
        """Test '_get_soup' method"""
        self.p._get_soup()
        self.assertEqual(unicode(self.p.soup), self.html)
    
    def test_03_get_styles(self):
        """Test '_get_styles' method"""
        self.p._get_soup()
        self.p._get_styles()
        self.assertEqual(self.p.style_string, u'.b1,.b2 { font-weight:bold; } .c {color: red}\n')
        self.assertEqual(unicode(self.p.soup), u'<span class="b1">Bold</span><span class="b2 c">Bold Red</span>')
    
    def test_04_apply_styles(self):
        """Test '_apply_styles' method"""
        self.p._get_soup()
        self.p._get_styles()
        self.p._apply_styles()
        self.assertEqual(unicode(self.p.soup), u'<span class="b1" style="font-weight: bold">Bold</span><span class="b2 c" style="font-weight: bold; color: red">Bold Red</span>')
    
    def test_05_run(self):
        """Test 'run' method"""
        output = self.p.run()
        self.assertEqual(output, u'<span class="b1" style="font-weight: bold">Bold</span><span class="b2 c" style="font-weight: bold; color: red">Bold Red</span>')
    
    def test_06_with_cssString(self):
        """Test 'with_cssString' method"""
        cssString = '.b1,.b2 {font-size: 2em;}'
        self.p = Pynliner().from_string(self.html).with_cssString(cssString)
        self.assertEqual(self.p.style_string, cssString + '\n')
        
        output = self.p.run()
        self.assertEqual(output, u'<span class="b1" style="font-size: 2em; font-weight: bold">Bold</span><span class="b2 c" style="font-size: 2em; font-weight: bold; color: red">Bold Red</span>')
    
    def test_07_fromString(self):
        """Test 'fromString' complete"""
        output = pynliner.fromString(self.html)
        desired = u'<span class="b1" style="font-weight: bold">Bold</span><span class="b2 c" style="font-weight: bold; color: red">Bold Red</span>'
        self.assertEqual(output, desired)
    
    def test_08_comma_whitespace(self):
        """Test excess whitespace in CSS"""
        html = '<style>h1,  h2   ,h3,\nh4{   color:    #000}  </style><h1>1</h1><h2>2</h2><h3>3</h3><h4>4</h4>'
        desired_output = '<h1 style="color: #000">1</h1><h2 style="color: #000">2</h2><h3 style="color: #000">3</h3><h4 style="color: #000">4</h4>'
        output = Pynliner().from_string(html).run()
        self.assertEqual(output, desired_output)

# 需要导入模块: from pynliner import Pynliner [as 别名]
# 或者: from pynliner.Pynliner import run [as 别名]
    def test_08_fromURL(self):
        """Test 'fromURL' constructor"""
        url = 'http://media.tannern.com/pynliner/test.html'
        p = Pynliner()
        p.from_url(url)
        self.assertEqual(p.root_url, 'http://media.tannern.com')
        self.assertEqual(p.relative_url, 'http://media.tannern.com/pynliner/')
        
        p._get_soup()
        
        p._get_external_styles()
        self.assertEqual(p.style_string, "p {color: #999}")
        
        p._get_internal_styles()
        self.assertEqual(p.style_string, "p {color: #999}\nh1 {color: #ffcc00;}\n")
        
        p._get_styles()
        
        output = p.run()
        desired = u"""<?xml version='1.0' encoding='utf-8'?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>test</title>


</head>
<body>
<h1 style="color: #fc0">Hello World!</h1>
<p style="color: #999">Possim tincidunt putamus iriure eu nulla. Facer qui volutpat ut aliquam sequitur. Mutationem legere feugiat autem clari notare. Nulla typi augue suscipit lectores in.</p>
<p style="color: #999">Facilisis claritatem eum decima dignissim legentis. Nulla per legentis odio molestie quarta. Et velit typi claritas ipsum ullamcorper.</p>
</body>
</html>"""
        self.assertEqual(output, desired) 

# 需要导入模块: from pynliner import Pynliner [as 别名]
# 或者: from pynliner.Pynliner import run [as 别名]
    def process_dict(self, input_dict):
        converter = Ansi2HTMLConverter()
        full = self.arg_value('full', False)

        ext = self.artifact.input_ext
        if input_dict.has_key('1') and not input_dict['1'] and ext == ".css":
            # Special case if we get a virtual empty file, generate style file
            self.artifact.final = True
            self.artifact.ext = ext
            output_dict = OrderedDict()
            output_dict['1'] = self.generate_css()

        else:
            p = None
            css = None
            inline_css = self.arg_value('inline', False)
            if inline_css:
                css = "\n".join(converter.produce_headers().strip().splitlines()[1:-1])
                self.log.debug(css)
                try:
                    from pynliner import Pynliner
                except ImportError:
                    raise UserFeedback("You must install BeautifulSoup, cssutils and pynliner in order to use 'inline' option:\n   pip install BeautifulSoup cssutils pynliner\n")

            output_dict = OrderedDict()
            for section_name, section_text in input_dict.iteritems():
                html = converter.convert(section_text, full=full)
                if inline_css:
                    p = Pynliner(self.log).from_string(html).with_cssString(css)
                    html = "<pre>\n%s</pre>" % p.run()
                output_dict[section_name] = html

        return output_dict

# 需要导入模块: from pynliner import Pynliner [as 别名]
# 或者: from pynliner.Pynliner import run [as 别名]
def ansi_output_to_html(ansi_text, log=None):
    try:
        converter = Ansi2HTMLConverter()
        html = converter.convert(ansi_text)
    except IOError as e:
        if re.search("templates/header.mak", str(e)):
            print e
            raise Exception(
                "Your installation of ansi2html is missing some template files, please try 'pip install --upgrade ansi2html' or install from source."
            )
        raise e

    try:
        p = Pynliner(log)
        if not log:  # put after call to Pynliner() so it doesn't print in case of error
            print """a custom log has not been passed to dexy.utils.ansi_output_to_html,
            harmless but annoying CSS errors will appear on the console."""
    except TypeError:
        print "========== Start of harmless but annoying CSS errors..."
        print "You can install pynliner from source (https://github.com/rennat/pynliner.git) or version > 0.2.1 to get rid of these"
        p = Pynliner()

    p.from_string(html)
    html_with_css_inline = p.run()

    # Ansi2HTMLConverter returns a complete HTML document, we just want body
    doc = BeautifulSoup(html_with_css_inline)
    return doc.body.renderContents()

# 需要导入模块: from pynliner import Pynliner [as 别名]
# 或者: from pynliner.Pynliner import run [as 别名]
class WithCustomLog(unittest.TestCase):
    def setUp(self):
        self.log = logging.getLogger('testlog')
        self.log.setLevel(logging.DEBUG)

        self.logstream = StringIO.StringIO()
        handler = logging.StreamHandler(self.logstream)
        formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
        handler.setFormatter(formatter)
        self.log.addHandler(handler)

        self.html = "<style>h1 { color:#ffcc00; }</style><h1>Hello World!</h1>"
        self.p = Pynliner(self.log).from_string(self.html)

    def test_custom_log(self):
        self.p.run()
        log_contents = self.logstream.getvalue()
        assert "DEBUG" in log_contents

# 需要导入模块: from pynliner import Pynliner [as 别名]
# 或者: from pynliner.Pynliner import run [as 别名]
    def process_dict(self, input_dict):
        #matches = [k for k in self.artifact.input_artifacts_dict.keys() if k.endswith(".css|dexy")]
        #k = matches[0]
        css = open("pastie.css", "r").read()

        output_dict = OrderedDict()
        for k, v in input_dict.items():
            try:
                p = Pynliner(self.log)
            except TypeError:
                print "the pynliner filter says: please install pynliner from source (https://github.com/rennat/pynliner.git) or version > 0.2.1"
                p = Pynliner()
            p.from_string(v).with_cssString(css)
            output_dict[k] = p.run()
        return output_dict

# 需要导入模块: from pynliner import Pynliner [as 别名]
# 或者: from pynliner.Pynliner import run [as 别名]
    def test_fromURL(self):
        """Test 'fromURL' constructor"""
        url = 'http://media.tannern.com/pynliner/test.html'
        p = Pynliner()
        with mock.patch.object(Pynliner, '_get_url') as mocked:
            mocked.return_value = u"""<?xml version='1.0' encoding='utf-8'?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>test</title>
<link rel="stylesheet" type="text/css" href="test.css"/>
<style type="text/css">h1 {color: #fc0;}</style>
</head>
<body>
<h1>Hello World!</h1>
<p>:)</p>
</body>
</html>"""
            p.from_url(url)
        self.assertEqual(p.root_url, 'http://media.tannern.com')
        self.assertEqual(p.relative_url, 'http://media.tannern.com/pynliner/')

        p._get_soup()

        with mock.patch.object(Pynliner, '_get_url') as mocked:
            mocked.return_value = 'p {color: #999}'
            p._get_external_styles()
        self.assertEqual(p.style_string, "p {color: #999}")

        p._get_internal_styles()
        self.assertEqual(p.style_string, "p {color: #999}\nh1 {color: #fc0;}\n")

        p._get_styles()

        output = p.run()
        desired = u"""<?xml version='1.0' encoding='utf-8'?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>test</title>


</head>
<body>
<h1 style="color: #fc0">Hello World!</h1>
<p style="color: #999">:)</p>
</body>
</html>"""
        self.assertEqual(output, desired)

# 需要导入模块: from pynliner import Pynliner [as 别名]
# 或者: from pynliner.Pynliner import run [as 别名]
    def test_08_fromURL(self):
        """Test 'fromURL' constructor"""
        url = 'https://raw.github.com/voidfiles/pynliner/master/test_data/test.html'
        p = Pynliner()
        p.from_url(url)
        self.assertEqual(p.root_url, 'https://raw.github.com')
        self.assertEqual(p.relative_url, 'https://raw.github.com/voidfiles/pynliner/master/test_data/')

        p._get_soup()

        p._get_external_styles()
        self.assertEqual(p.style_string, "p {color: #999}")

        p._get_internal_styles()
        self.assertEqual(p.style_string, "p {color: #999}\nh1 {color: #ffcc00;}")

        p._get_styles()

        output = p.run()
        desired = u"""<html><head></head><body>\n        <h1 style="color: #fc0">Testing Title</h1>\n        <p style="color: #999">Awesome</p>\n    </body></html>"""
        self.assertEqual(output, desired)

# 需要导入模块: from pynliner import Pynliner [as 别名]
# 或者: from pynliner.Pynliner import run [as 别名]
class Basic(unittest.TestCase):
    
    def setUp(self):
        self.html = "<style>h1 { color:#ffcc00; }</style><h1>Hello World!</h1>"
        self.p = Pynliner().from_string(self.html)
    
    def test_01_fromString(self):
        """Test 'fromString' constructor"""
        self.assertEqual(self.p.source_string, self.html)
    
    def test_02_get_soup(self):
        """Test '_get_soup' method"""
        self.p._get_soup()
        self.assertEqual(unicode(self.p.soup), self.html)
    
    def test_03_get_styles(self):
        """Test '_get_styles' method"""
        self.p._get_soup()
        self.p._get_styles()
        self.assertEqual(self.p.style_string, u'h1 { color:#ffcc00; }\n')
        self.assertEqual(unicode(self.p.soup), u'<h1>Hello World!</h1>')
    
    def test_04_apply_styles(self):
        """Test '_apply_styles' method"""
        self.p._get_soup()
        self.p._get_styles()
        self.p._apply_styles()
        self.assertEqual(unicode(self.p.soup), u'<h1 style="color: #fc0">Hello World!</h1>')
    
    def test_05_run(self):
        """Test 'run' method"""
        output = self.p.run()
        self.assertEqual(output, u'<h1 style="color: #fc0">Hello World!</h1>')
    
    def test_06_with_cssString(self):
        """Test 'with_cssString' method"""
        cssString = 'h1 {font-size: 2em;}'
        self.p = Pynliner().from_string(self.html).with_cssString(cssString)
        self.assertEqual(self.p.style_string, cssString + '\n')
        
        output = self.p.run()
        self.assertEqual(output, u'<h1 style="font-size: 2em; color: #fc0">Hello World!</h1>')
    
    def test_07_fromString(self):
        """Test 'fromString' complete"""
        output = pynliner.fromString(self.html)
        desired = u'<h1 style="color: #fc0">Hello World!</h1>'
        self.assertEqual(output, desired)
    
    def test_08_fromURL(self):
        """Test 'fromURL' constructor"""
        url = 'http://media.tannern.com/pynliner/test.html'
        p = Pynliner()
        p.from_url(url)
        self.assertEqual(p.root_url, 'http://media.tannern.com')
        self.assertEqual(p.relative_url, 'http://media.tannern.com/pynliner/')
        
        p._get_soup()
        
        p._get_external_styles()
        self.assertEqual(p.style_string, "p {color: #999}")
        
        p._get_internal_styles()
        self.assertEqual(p.style_string, "p {color: #999}\nh1 {color: #ffcc00;}\n")
        
        p._get_styles()
        
        output = p.run()
        desired = u"""<?xml version='1.0' encoding='utf-8'?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>test</title>


</head>
<body>
<h1 style="color: #fc0">Hello World!</h1>
<p style="color: #999">Possim tincidunt putamus iriure eu nulla. Facer qui volutpat ut aliquam sequitur. Mutationem legere feugiat autem clari notare. Nulla typi augue suscipit lectores in.</p>
<p style="color: #999">Facilisis claritatem eum decima dignissim legentis. Nulla per legentis odio molestie quarta. Et velit typi claritas ipsum ullamcorper.</p>
</body>
</html>"""
        self.assertEqual(output, desired) 

# 需要导入模块: from pynliner import Pynliner [as 别名]
# 或者: from pynliner.Pynliner import run [as 别名]
class Basic(unittest.TestCase):

    def setUp(self):
        self.html = "<html><head><style>h1 { color:#ffcc00; }</style></head><body><h1>Hello World!</h1></body></html>"
        self.p = Pynliner().from_string(self.html)

    def test_01_fromString(self):
        """Test 'fromString' constructor"""
        self.assertEqual(self.p.source_string, self.html)

    def test_02_get_soup(self):
        """Test '_get_soup' method"""
        self.p._get_soup()
        self.assertEqual(lxml.html.tostring(self.p.soup), self.html)

    def test_03_get_styles(self):
        """Test '_get_styles' method"""
        self.p._get_soup()
        self.p._get_styles()
        self.assertEqual(self.p.style_string, u'h1 { color:#ffcc00; }')
        self.assertEqual(lxml.html.tostring(self.p.soup), u'<html><head></head><body><h1>Hello World!</h1></body></html>')

    def test_04_apply_styles(self):
        """Test '_apply_styles' method"""
        self.p._get_soup()
        self.p._get_styles()
        self.p._apply_styles()
        self.assertEqual(lxml.html.tostring(self.p.soup), u'<html><head></head><body><h1 style="color: #fc0">Hello World!</h1></body></html>')

    def test_05_run(self):
        """Test 'run' method"""
        output = self.p.run()
        self.assertEqual(output, u'<html><head></head><body><h1 style="color: #fc0">Hello World!</h1></body></html>')

    def test_06_with_cssString(self):
        """Test 'with_cssString' method"""
        cssString = 'h1 {font-size: 2em;}'
        self.p = Pynliner().from_string(self.html).with_cssString(cssString)
        self.assertEqual(self.p.style_string, cssString + '\n')

        output = self.p.run()
        self.assertEqual(output, '<html><head></head><body><h1 style="font-size: 2em; color: #fc0">Hello World!</h1></body></html>')

    def test_07_fromString(self):
        """Test 'fromString' complete"""
        output = pynliner.fromString(self.html)
        desired = u'<html><head></head><body><h1 style="color: #fc0">Hello World!</h1></body></html>'
        self.assertEqual(output, desired)

    def test_08_fromURL(self):
        """Test 'fromURL' constructor"""
        url = 'https://raw.github.com/voidfiles/pynliner/master/test_data/test.html'
        p = Pynliner()
        p.from_url(url)
        self.assertEqual(p.root_url, 'https://raw.github.com')
        self.assertEqual(p.relative_url, 'https://raw.github.com/voidfiles/pynliner/master/test_data/')

        p._get_soup()

        p._get_external_styles()
        self.assertEqual(p.style_string, "p {color: #999}")

        p._get_internal_styles()
        self.assertEqual(p.style_string, "p {color: #999}\nh1 {color: #ffcc00;}")

        p._get_styles()

        output = p.run()
        desired = u"""<html><head></head><body>\n        <h1 style="color: #fc0">Testing Title</h1>\n        <p style="color: #999">Awesome</p>\n    </body></html>"""
        self.assertEqual(output, desired)

    def test_09_overloadedStyles(self):
        html = '<style>h1 { color: red; } #test { color: blue; }</style><h1 id="test">Hello world!</h1>'
        expected = '<html><head></head><body><h1 id="test" style="color: blue">Hello world!</h1></body></html>'
        output = Pynliner().from_string(html).run()
        self.assertEqual(expected, output)

# 需要导入模块: from pynliner import Pynliner [as 别名]
# 或者: from pynliner.Pynliner import run [as 别名]
class Basic(unittest.TestCase):
    def setUp(self):
        self.html = "<style>h1 { color:#ffcc00; }</style><h1>Hello World!</h1>"
        self.p = Pynliner().from_string(self.html)

    def test_fromString(self):
        """Test 'fromString' constructor"""
        self.assertEqual(self.p.source_string, self.html)

    def test_get_soup(self):
        """Test '_get_soup' method"""
        self.p._get_soup()
        self.assertEqual(unicode(self.p.soup), self.html)

    def test_get_styles(self):
        """Test '_get_styles' method"""
        self.p._get_soup()
        self.p._get_styles()
        self.assertEqual(self.p.style_string, u'h1 { color:#ffcc00; }\n')
        self.assertEqual(unicode(self.p.soup), u'<h1>Hello World!</h1>')

    def test_apply_styles(self):
        """Test '_apply_styles' method"""
        self.p._get_soup()
        self.p._get_styles()
        self.p._apply_styles()
        attr_dict = dict(self.p.soup.contents[0].attrs)
        self.assertTrue('style' in attr_dict)
        self.assertEqual(attr_dict['style'], u'color: #fc0')

    def test_run(self):
        """Test 'run' method"""
        output = self.p.run()
        self.assertEqual(output, u'<h1 style="color: #fc0">Hello World!</h1>')

    def test_with_cssString(self):
        """Test 'with_cssString' method"""
        cssString = 'h1 {color: #f00;}'
        self.p.with_cssString(cssString)
        output = self.p.run()
        self.assertEqual(output, u'<h1 style="color: #f00">Hello World!</h1>')

    def test_fromString_complete(self):
        """Test 'fromString' complete"""
        output = pynliner.fromString(self.html)
        desired = u'<h1 style="color: #fc0">Hello World!</h1>'
        self.assertEqual(output, desired)

    def test_fromURL(self):
        """Test 'fromURL' constructor"""
        url = 'http://media.tannern.com/pynliner/test.html'
        p = Pynliner()
        with mock.patch.object(Pynliner, '_get_url') as mocked:
            mocked.return_value = u"""<?xml version='1.0' encoding='utf-8'?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>test</title>
<link rel="stylesheet" type="text/css" href="test.css"/>
<style type="text/css">h1 {color: #fc0;}</style>
</head>
<body>
<h1>Hello World!</h1>
<p>:)</p>
</body>
</html>"""
            p.from_url(url)
        self.assertEqual(p.root_url, 'http://media.tannern.com')
        self.assertEqual(p.relative_url, 'http://media.tannern.com/pynliner/')

        p._get_soup()

        with mock.patch.object(Pynliner, '_get_url') as mocked:
            mocked.return_value = 'p {color: #999}'
            p._get_external_styles()
        self.assertEqual(p.style_string, "p {color: #999}")

        p._get_internal_styles()
        self.assertEqual(p.style_string, "p {color: #999}\nh1 {color: #fc0;}\n")

        p._get_styles()

        output = p.run()
        desired = u"""<?xml version='1.0' encoding='utf-8'?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>test</title>


</head>
<body>
<h1 style="color: #fc0">Hello World!</h1>
<p style="color: #999">:)</p>
</body>
</html>"""
        self.assertEqual(output, desired)

    def test_overloaded_styles(self):
        html = '<style>h1 { color: red; } #test { color: blue; }</style>' \
               '<h1 id="test">Hello world!</h1>'
        expected = '<h1 id="test" style="color: blue">Hello world!</h1>'
#.........这里部分代码省略.........

# 需要导入模块: from pynliner import Pynliner [as 别名]
# 或者: from pynliner.Pynliner import run [as 别名]
    # choose a random problem 
    max_set, max_prob = 427, 4
    while True:
        try:
            prob_code = (randint(1, max_set), chr(randint(0, max_prob) + 65))

            if prob_code in used_probs:
                raise Exception('This code is terrible.')

            if not get_problem_html(prob_code):
                raise Exception('This code is terrible.')
                
            ufile.write(str(prob_code) + '\n')
            break
        except:
            pass


    out.append('<hr>')
    
out.append('</body>')
out.append('</html>')

preinline_html = '\n'.join(out)

final_p = Pynliner().from_string(preinline_html).with_cssString(css_string)
final_html = final_p.run()

print final_html

# 需要导入模块: from pynliner import Pynliner [as 别名]
# 或者: from pynliner.Pynliner import run [as 别名]
    print "\nGetting CSS..."
    cssFile = open(os.path.join(templateDir, "css/email.css"), "r")
    css = cssFile.read();
    cssFile.close()
   
    for name in files:
        print "    Found: " + name
        output = name.replace(".template.html", ".html")

        if doInlining:
            inputFile = open(name, 'r')
            origEmail = inputFile.read()
            inputFile.close()

            inliner = Pynliner().from_string(origEmail).with_cssString(css)
            inlinedEmail = inliner.run()
            prettyEmail = BeautifulSoup(inlinedEmail).prettify()

            outputFile = open(output, "w")
            outputFile.write(prettyEmail)
            outputFile.close()
                            
            print "      Gen: " + output
            print ""

    return

if __name__ == '__main__':
    sys.exit(main())

# $eof