pycqa / redbaron Goto Github PK

>>> red = RedBaron('''def inline_temp(red_cache, jscript):
    """
    :type red_cache: RedCache
    :type jscript: jedi.Script
    """
    assigns = jscript.goto_assignments()
    if not assigns:
        raise NoAssignmentsFound()
    if len(assigns) > 1:
        raise MultipleAssignmentsFound()
    jassign = assigns[0]
    rdef = jdef_to_rdef(jassign, red_cache)
    rdef = up_to_assignment(rdef)
    assigned_expr_raw = rdef.value.dumps()
    rusages = collect_usages(jscript, red_cache)
    for rusage in rusages:
        if rusage.parent == rdef:
            continue
        rusage.replace(assigned_expr_raw)

    # del rdef.parent[rdef.index_on_parent]
    index = rdef.index_on_parent
    par = rdef.parent
    # this line triggers a bug: some parts are deleted, but they shouldn't be deleted
    del par[index]
    return red_cache
''')
>>> red[0]
def inline_temp(red_cache, jscript):
    """
    :type red_cache: RedCache
    :type jscript: jedi.Script
    """
    assigns = jscript.goto_assignments()
    if not assigns:
        raise NoAssignmentsFound()
    if len(assigns) > 1:
        raise MultipleAssignmentsFound()
    jassign = assigns[0]
    rdef = jdef_to_rdef(jassign, red_cache)
    rdef = up_to_assignment(rdef)
    assigned_expr_raw = rdef.value.dumps()
    rusages = collect_usages(jscript, red_cache)
    for rusage in rusages:
        if rusage.parent == rdef:
            continue
        rusage.replace(assigned_expr_raw)

    # del rdef.parent[rdef.index_on_parent]
    index = rdef.index_on_parent
    par = rdef.parent
    # this line triggers a bug: some parts are deleted, but they shouldn't be deleted
    del par[index]
    return red_cache
>>> red[0][8]
rusages = collect_usages(jscript, red_cache)
>>> del red[0][8]
>>> red[0]
def inline_temp(red_cache, jscript):
    """
    :type red_cache: RedCache
    :type jscript: jedi.Script
    """
    assigns = jscript.goto_assignments()
    if not assigns:
        raise NoAssignmentsFound()
    if len(assigns) > 1:
        raise MultipleAssignmentsFound()
    jassign = assigns[0]
    rdef = jdef_to_rdef(jassign, red_cache)
    rdef = up_to_assignment(rdef)
    assigned_expr_raw = rdef.value.dumps()
    for rusage in rusages:
        if rusage.parent == rdef:
            continue
        rusage.replace(assigned_expr_raw)

    # del rdef.parent[rdef.index_on_parent]

In [27]: source = '''#!/usr/bin/env python
# coding: utf8
'''

In [28]: red = RedBaron(source)

In [29]: red
Out[29]: 
0   '#!/usr/bin/env python\n'
1   '#!/usr/bin/env python\n'


In [30]: red[0]
Out[30]: '#!/usr/bin/env python\n'

In [31]: red[1]
Out[31]: '#!/usr/bin/env python\n'

In [32]: red.dumps()
Out[32]: '#!/usr/bin/env python\n\n'

In [7]: RedBaron("def __init__(self, a,\n   b, c): pass")[0].arguments.pop()
---------------------------------------------------------------------------
Exception                                 Traceback (most recent call last)
<ipython-input-7-4d3f9b02d5b0> in <module>()
----> 1 RedBaron("def __init__(self, a,\n   b, c): pass")[0].arguments.pop()

/home/psycojoker/code/python/redbaron/redbaron/base_nodes.pyc in pop(self, index)
   1348         else:
   1349             self.data.pop()
-> 1350         self._synchronise()
   1351 
   1352     def remove(self, value):

/home/psycojoker/code/python/redbaron/redbaron/base_nodes.pyc in _synchronise(self)
   1325 
   1326     def _synchronise(self):
-> 1327         self.node_list.data = self._generate_expected_list()[:]
   1328         self.data = self._build_inner_list(self.node_list.data)
   1329 

/home/psycojoker/code/python/redbaron/redbaron/base_nodes.pyc in _generate_expected_list(self)
   1493                     if self.style == "indented":
   1494                         if not expected_list[-1].second_formatting.endl:
-> 1495                             raise Exception("Unhandled case")
   1496                         elif expected_list[-1].second_formatting.endl.indent != self.parent.indentation + " "*4:
   1497                             expected_list[-1].second_formatting.endl.indent = self.parent.indentation + " "*4

Exception: Unhandled case

>>> baron.parse("{k: v for k, v in {0: 1}.items()}")
[{'first_formatting': [], 'fourth_formatting': [], 'second_formatting': [], 'third_formatting': [], 'generators': [{'first_formatting': [{'type': 'space', 'value': ' '}], 'third_formatting': [{'type': 'space', 'value': ' '}], 'target': {'type': 'atomtrailers', 'value': [{'first_formatting': [], 'fourth_formatting': [], 'value': [{'first_formatting': [], 'type': 'dictitem', 'value': {'section': 'number', 'type': 'int', 'value': '1'}, 'key': {'section': 'number', 'type': 'int', 'value': '0'}, 'second_formatting': [{'type': 'space', 'value': ' '}]}], 'second_formatting': [], 'third_formatting': [], 'type': 'dict'}, {'first_formatting': [], 'type': 'dot', 'second_formatting': []}, {'type': 'name', 'value': 'items'}, {'first_formatting': [], 'fourth_formatting': [], 'value': [], 'second_formatting': [], 'third_formatting': [], 'type': 'call'}]}, 'iterator': {'first_formatting': [], 'fourth_formatting': [], 'value': [{'type': 'name', 'value': 'k'}, {'first_formatting': [], 'type': 'comma', 'second_formatting': [{'type': 'space', 'value': ' '}]}, {'type': 'name', 'value': 'v'}], 'second_formatting': [], 'third_formatting': [], 'with_parenthesis': False, 'type': 'tuple'}, 'ifs': [], 'fourth_formatting': [{'type': 'space', 'value': ' '}], 'type': 'comprehension_loop', 'second_formatting': [{'type': 'space', 'value': ' '}]}], 'result': {'first_formatting': [], 'value': {'type': 'name', 'value': 'v'}, 'key': {'type': 'name', 'value': 'k'}, 'second_formatting': [{'type': 'space', 'value': ' '}]}, 'type': 'dict_comprehension'}]
>>> red = RedBaron("{k: v for k, v in {0: 1}.items()}")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "redbaron.py", line 296, in __init__
    self.data = map(to_node, baron.parse(source_code))
  File "redbaron.py", line 17, in to_node
    return type(class_name, (Node,), {})(node)
  File "redbaron.py", line 77, in __init__
    setattr(self, key, to_node(value))
  File "redbaron.py", line 13, in to_node
    class_name = "".join(map(lambda x: x.capitalize(), node["type"].split("_"))) + "Node"
KeyError: 'type'

baron.parse("{k: v for k, v in {0: 1}.items()}")[0]["result"]

from redbaron import RedBaron

template = """\
class A(object):
    a = 1
    b = 2
    c = 3
"""

red = RedBaron(template)
B = red[0].copy()
red[0].insert_after(B)

print B.find('assign').index_on_parent
print B.find_all('assign')[0].index_on_parent
print B('assign')[0].index_on_parent
print '-----'
print B.find_all('assign').find_all('name', 'a').index_on_parent
print B('assign')('name', 'a').index_on_parent

def set_attribute(red, name, value):
    assignment_node = red('assign')('name', name).parent
    assignment_node.value.value = -1

Python 3.4.2 (default, Oct  8 2014, 10:45:20) 
Type "copyright", "credits" or "license" for more information.

IPython 3.2.1 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object', use 'object??' for extra details.

In [1]: from redbaron import RedBaron

In [2]: test = RedBaron("hello = 'Hello world!'\nprint(hello)")

In [3]: test
Out[3]: ---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/home/thomas/projets/ve/lib/python3.4/site-packages/IPython/core/formatters.py in __call__(self, obj)
    688                 type_pprinters=self.type_printers,
    689                 deferred_pprinters=self.deferred_printers)
--> 690             printer.pretty(obj)
    691             printer.flush()
    692             return stream.getvalue()

/home/thomas/projets/ve/lib/python3.4/site-packages/IPython/lib/pretty.py in pretty(self, obj)
    407                             if callable(meth):
    408                                 return meth(obj, self, cycle)
--> 409             return _default_pprint(obj, self, cycle)
    410         finally:
    411             self.end_group()

/home/thomas/projets/ve/lib/python3.4/site-packages/IPython/lib/pretty.py in _default_pprint(obj, p, cycle)
    527     if _safe_getattr(klass, '__repr__', None) not in _baseclass_reprs:
    528         # A user-provided repr. Find newlines and replace them with p.break_()
--> 529         _repr_pprint(obj, p, cycle)
    530         return
    531     p.begin_group(1, '<')

/home/thomas/projets/ve/lib/python3.4/site-packages/IPython/lib/pretty.py in _repr_pprint(obj, p, cycle)
    709     """A pprint that just redirects to the normal repr function."""
    710     # Find newlines and replace them with p.break_()
--> 711     output = repr(obj)
    712     for idx,output_line in enumerate(output.splitlines()):
    713         if idx:

/home/thomas/projets/ve/lib/python3.4/site-packages/redbaron.py in __repr__(self)
   1308     def __repr__(self):
   1309         if in_a_shell():
-> 1310             return self.__str__()
   1311 
   1312         return "<%s %s, \"%s\" %s, on %s %s>" % (

/home/thomas/projets/ve/lib/python3.4/site-packages/redbaron.py in __str__(self)
   1339         to_return = ""
   1340         for number, value in enumerate(self.data):
-> 1341             to_return += ("%-3s " % number) + "\n    ".join(value.__repr__().split("\n"))
   1342             to_return += "\n"
   1343         return to_return

TypeError: Type str doesn't support the buffer API

to_return += ("%-3s " % number) + "\n    ".join(value.__repr__().decode("Utf-8").split("\n"))

import urllib, sys, string
from string import maketrans

bbb = 0

f = urllib.urlopen("http://www.pythonchallenge.com/pc/def/equality.html")
while 1:
    buf = f.read(200000)
    if not len(buf):
        break
    for x in range(len(buf)):
        if buf[x] in string.ascii_lowercase:
           if buf[x+1] in string.ascii_uppercase:
               if buf[x-1] in string.ascii_uppercase:
                   if buf[x+2] in string.ascii_uppercase:
                       if buf[x-2] in string.ascii_uppercase:
                           if buf[x+3] in string.ascii_uppercase:
                               if buf[x-3] in string.ascii_uppercase:
                                   if buf[x+4] in string.ascii_lowercase:
                                       if buf[x-4] in string.ascii_lowercase:
                                           bbb = x
    sys.stdout.write(buf)
    print(buf[bbb-3:bbb+4])

while parent:
    if isinstance(parent.parent, redbaron.RedBaron) or isinstance(parent, redbaron.RedBaron):
        break
    else:
        parent = parent.parent
        k += parent.index_on_parent_raw

def get_int_value(node):
    NUMBERS = IntNode, FloatNode, OctaNode, HexaNode, LongNode

    if isinstance(node, NUMBERS):
        if isinstance(node, IntNode):
            return node.value
        else:
            return ast.literal_eval(node.value)
    else:
        raise ValueError

code = RedBaron('a = 12\na = 0xC')
get_int_value(code[0].assign.value), get_int_value(code[1].assign.value)

from redbaron import RedBaron
rb = RedBaron('''
  class A(object):
      a = 1
      b = 2
      c = 3
''')

node_b = rb.find('assignment', target=lambda x: x.dumps() == 'b')
node_b.insert_after('d = -1')
node_d = rb.find('assignment', target=lambda x: x.dumps() == 'd')
node_d.insert_after('o = 3')

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-6-681d36ee36d7> in <module>()
----> 1 node_d.insert_after('o = 3')

/usr/local/lib/python2.7/dist-packages/redbaron.py in insert_after(self, value, offset)
   1014 
   1015     def insert_after(self, value, offset=0):
-> 1016         self.parent.insert(self.index_on_parent + 1 + offset, value)
   1017 
   1018 

TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

>>> red = RedBaron('foo.real')
>>> red[0]
foo.real
>>> red[0].type
'atomtrailers'
>>> red[0][0] = 'random()'
>>> red[0] # expected result: random().real
().real
>>> red = RedBaron('foo.real')
>>> red[0][1] = 'random()'
>>> red[0] # expected result: foo.random()
foo()

>>> red = RedBaron('foo.real')
>>> red[0][0].replace('random()')
>>> red[0]
random().real
>>> red = RedBaron('foo.real')
>>> red[0][1].replace('random()')
>>> red[0]
foo.random()

from redbaron import RedBaron
RedBaron("1")

# where z is a FuncdefNode

z.arguments.extend(z.arguments[1:])  # works

z.arguments[1:].extend(z.arguments[1:])

AttributeError                            Traceback (most recent call last)
<ipython-input-10-fa58bfbd216f> in <module>()
----> 1 z.arguments[1:].extend(z.arguments[1:])

/home/psycojoker/code/python/redbaron/redbaron.py in extend(self, values)
   1302 
   1303     def extend(self, values):
-> 1304         self.data.extend(self._convert_input_to_node_object_list(values, parent=self.node_list, on_attribute=self.on_attribute))
   1305         self._diff_augmented_list()
   1306 

/home/psycojoker/code/python/redbaron/redbaron.py in _convert_input_to_node_object_list(self, value, parent, on_attribute)
   1242             return self.node_list.parent._convert_input_to_node_object_list(value, parent, on_attribute)
   1243         else:
-> 1244             return NodeList([self._convert_input_to_node_object(x, parent, on_attribute) for x in value])
   1245 
   1246     def _generate_expected_list(self):

/home/psycojoker/code/python/redbaron/redbaron.py in _convert_input_to_node_object(self, value, parent, on_attribute)
   1232 
   1233     def _convert_input_to_node_object(self, value, parent, on_attribute):
-> 1234         lst = self.node_list.parent._convert_input_to_node_object_list(value, parent, on_attribute)
   1235         if all(i.type == 'endl' for i in lst):
   1236             return lst[0]

AttributeError: 'NoneType' object has no attribute '_convert_input_to_node_object_list'

>>> r = redbaron.RedBaron("4 / 5 / 6")
>>> r[0].help()                                                                              
BinaryOperatorNode()                                                                         
  # identifiers: binary_operator, binary_operator_, binaryoperator, binaryoperatornode       
  value='/'                                                                                  
  first ->                                                                                   
    IntNode()                                                                                
      # identifiers: int, int_, intnode                                                      
      value=4                                                                                
  second ->                                                                                  
    BinaryOperatorNode()                                                                     
      # identifiers: binary_operator, binary_operator_, binaryoperator, binaryoperatornode   
      value='/'                                                                              
      first ->                                                                               
        IntNode() ...                                                                        
      second ->                                                                              
        IntNode() ...                                                                        
>>> r[0].second.help()                                                                       
BinaryOperatorNode()                                                                         
  # identifiers: binary_operator, binary_operator_, binaryoperator, binaryoperatornode       
  value='/'                                                                                  
  first ->                                                                                   
    IntNode()                                                                                
      # identifiers: int, int_, intnode                                                      
      value=5                                                                                
  second ->                                                                                  
    IntNode()                                                                                
      # identifiers: int, int_, intnode                                                      
      value=6