Python token.STRING属性代码示例

# 需要导入模块: from lib2to3.pgen2 import token [as 别名]
# 或者: from lib2to3.pgen2.token import STRING [as 别名]
def test(self):
        kids = [None,
                [Leaf(token.NUMBER, 1), Leaf(token.NUMBER, 2),
                 Leaf(token.NUMBER, 3)],
                [Leaf(token.NUMBER, 1), Leaf(token.NUMBER, 3),
                 Leaf(token.NUMBER, 2), Leaf(token.NUMBER, 4)],
                [Leaf(token.STRING, "b"), Leaf(token.STRING, "j", prefix=" ")]
                ]
        self.assertStr(self._Call("A"), "A()")
        self.assertStr(self._Call("b", kids[1]), "b(1,2,3)")
        self.assertStr(self._Call("a.b().c", kids[2]), "a.b().c(1,3,2,4)")
        self.assertStr(self._Call("d", kids[3], prefix=" "), " d(b, j)") 

# 需要导入模块: from lib2to3.pgen2 import token [as 别名]
# 或者: from lib2to3.pgen2.token import STRING [as 别名]
def transform(self, node, results):
        if node.type == token.STRING:
            if _literal_re.match(node.value):
                new = node.clone()
                new.value = u'b' + new.value
                return new 

# 需要导入模块: from lib2to3.pgen2 import token [as 别名]
# 或者: from lib2to3.pgen2.token import STRING [as 别名]
def transform(self, node, results):
        if node.type == token.STRING:
            touch_import_top(u'past.types', u'oldstr', node)
            if _literal_re.match(node.value):
                new = node.clone()
                # Strip any leading space or comments:
                # TODO: check: do we really want to do this?
                new.prefix = u''
                new.value = u'b' + new.value
                wrapped = wrap_in_fn_call("oldstr", [new], prefix=node.prefix)
                return wrapped 

# 需要导入模块: from lib2to3.pgen2 import token [as 别名]
# 或者: from lib2to3.pgen2.token import STRING [as 别名]
def transform(self, node, results):
        syms = self.syms

        exc = results["exc"].clone()
        if exc.type == token.STRING:
            msg = "Python 3 does not support string exceptions"
            self.cannot_convert(node, msg)
            return

        # Python 2 supports
        #  raise ((((E1, E2), E3), E4), E5), V
        # as a synonym for
        #  raise E1, V
        # Since Python 3 will not support this, we recurse down any tuple
        # literals, always taking the first element.
        if is_tuple(exc):
            while is_tuple(exc):
                # exc.children[1:-1] is the unparenthesized tuple
                # exc.children[1].children[0] is the first element of the tuple
                exc = exc.children[1].children[0].clone()
            exc.prefix = u" "

        if "val" not in results:
            # One-argument raise
            new = pytree.Node(syms.raise_stmt, [Name(u"raise"), exc])
            new.prefix = node.prefix
            return new

        val = results["val"].clone()
        if is_tuple(val):
            args = [c.clone() for c in val.children[1:-1]]
        else:
            val.prefix = u""
            args = [val]

        return pytree.Node(syms.raise_stmt,
                           [Name(u"raise"), Call(exc, args)],
                           prefix=node.prefix) 

# 需要导入模块: from lib2to3.pgen2 import token [as 别名]
# 或者: from lib2to3.pgen2.token import STRING [as 别名]
def transform(self, node, results):
        if node.type == token.STRING and _literal_re.match(node.value):
            new = node.clone()
            new.value = new.value[1:]
            new.prefix = ''
            node.replace(Call(Name(u'u', prefix=node.prefix), [new])) 

# 需要导入模块: from lib2to3.pgen2 import token [as 别名]
# 或者: from lib2to3.pgen2.token import STRING [as 别名]
def transform(self, node, results):
        import pdb
        pdb.set_trace()
        if node.type == token.STRING:
            touch_import_top(u'past.types', u'oldstr', node)
            if _literal_re.match(node.value):
                new = node.clone()
                # Strip any leading space or comments:
                # TODO: check: do we really want to do this?
                new.prefix = u''
                new.value = u'b' + new.value
                wrapped = wrap_in_fn_call("oldstr", [new], prefix=node.prefix)
                return wrapped 

# 需要导入模块: from lib2to3.pgen2 import token [as 别名]
# 或者: from lib2to3.pgen2.token import STRING [as 别名]
def testSimple(self):
    tok = format_token.FormatToken(pytree.Leaf(token.STRING, "'hello world'"))
    self.assertEqual("FormatToken(name=STRING, value='hello world', lineno=0)",
                     str(tok))
    self.assertTrue(tok.is_string)

    tok = format_token.FormatToken(pytree.Leaf(token.COMMENT, '# A comment'))
    self.assertEqual('FormatToken(name=COMMENT, value=# A comment, lineno=0)',
                     str(tok))
    self.assertTrue(tok.is_comment) 

# 需要导入模块: from lib2to3.pgen2 import token [as 别名]
# 或者: from lib2to3.pgen2.token import STRING [as 别名]
def testIsMultilineString(self):
    tok = format_token.FormatToken(pytree.Leaf(token.STRING, '"""hello"""'))
    self.assertTrue(tok.is_multiline_string)

    tok = format_token.FormatToken(pytree.Leaf(token.STRING, 'r"""hello"""'))
    self.assertTrue(tok.is_multiline_string) 

# 需要导入模块: from lib2to3.pgen2 import token [as 别名]
# 或者: from lib2to3.pgen2.token import STRING [as 别名]
def _c_str(s):
    return Leaf(token.STRING, repr(s.s)) 

# 需要导入模块: from lib2to3.pgen2 import token [as 别名]
# 或者: from lib2to3.pgen2.token import STRING [as 别名]
def get_offset_and_prefix(body, skip_assignments=False):
    """Returns the offset after which a statement can be inserted to the `body`.

    This offset is calculated to come after all imports, and maybe existing
    (possibly annotated) assignments if `skip_assignments` is True.

    Also returns the indentation prefix that should be applied to the inserted
    node.
    """
    assert body.type in (syms.file_input, syms.suite)

    _offset = 0
    prefix = ""
    for _offset, child in enumerate(body.children):
        if child.type == syms.simple_stmt:
            stmt = child.children[0]
            if stmt.type == syms.expr_stmt:
                expr = stmt.children
                if not skip_assignments:
                    break

                if (
                    len(expr) != 2
                    or expr[0].type != token.NAME
                    or expr[1].type != syms.annassign
                    or _eq in expr[1].children
                ):
                    break

            elif stmt.type not in (syms.import_name, syms.import_from, token.STRING):
                break

        elif child.type == token.INDENT:
            assert isinstance(child, Leaf)
            prefix = child.value
        elif child.type != token.NEWLINE:
            break

    prefix, child.prefix = child.prefix, prefix
    return _offset, prefix