def readCode(self,modulepath=None): result=Bag() modulepath=modulepath or sys.modules[self.__module__].__file__ with open(modulepath, "r") as source_code: red = RedBaron(source_code.read()) result.fromJson(red.fst()) return result
def main(): """Rewrite Thrift-generated Python clients to handle recursive structs. For more details see: https://issues.apache.org/jira/browse/THRIFT-2642. Requires package `RedBaron`, available via pip: $ pip install redbaron To use: $ thrift -gen py mapd.thrift $ mv gen-py/mapd/ttypes.py gen-py/mapd/ttypes-backup.py $ python fix_recursive_structs.py gen-py/mapd/ttypes-backup.py gen-py/mapd/ttypes.py """ in_file = open(sys.argv[1], 'r') out_file = open(sys.argv[2], 'w') red_ast = RedBaron(in_file.read()) thrift_specs = [ts.parent for ts in red_ast.find_all( 'name', 'thrift_spec') if ts.parent.type == 'assignment' and ts.parent.parent.name in ['TDatumVal', 'TColumnData']] nodes = [] for ts in thrift_specs: node = ts.copy() node.target = ts.parent.name + '.' + str(node.target) nodes.append(node) ts.value = 'None' red_ast.extend(nodes) out_file.write(red_ast.dumps())
def _cleanupPyLintComments(filename, abort): from baron.parser import ( # pylint: disable=I0021,import-error,no-name-in-module ParsingError, # @UnresolvedImport ) from redbaron import ( # pylint: disable=I0021,import-error,no-name-in-module RedBaron, # @UnresolvedImport ) old_code = getFileContents(filename) try: red = RedBaron(old_code) # red = RedBaron(old_code.rstrip()+'\n') except ParsingError: if abort: raise my_print("PARSING ERROR.") return 2 for node in red.find_all("CommentNode"): try: _updateCommentNode(node) except Exception: my_print("Problem with", node) node.help(deep=True, with_formatting=True) raise new_code = red.dumps() if new_code != old_code: with open(filename, "w") as source_code: source_code.write(red.dumps())
def compare(s1, s2, decay_factor = DEFAULT_DECAY_FACTOR): red1 = RedBaron(s1) red2 = RedBaron(s2) result = [] for ast_f2 in red2.find_all('def'): ast_f1 = red1.find('def', name = ast_f2.name) if ast_f1 is not None: additions, deletions = preprocess_files(ast_f1.dumps(), ast_f2.dumps()) comments, exceptions = preprocess_comments(ast_f2, additions) for a in additions: for c in comments: line, _ = c.left_bounds distance = math.fabs(line - a) score = int(c.score() - float(decay_factor) / (distance * distance)) c.setScore(score if score > 0 else 0) for d in deletions: for c in comments: line, _ = c.left_bounds line = line + 1 if line >= d else line distance = math.fabs(line - d) score = int(c.score() - float(decay_factor) / (distance * distance)) c.setScore(score if score > 0 else 0) result.extend(comments) result.extend(exceptions) else: result.extend(preprocess_comments(ast_f2, [])) return result
def insert_output_start_stop_indicators(src): """ Insert identifier strings so that output can be segregated from input. Parameters ---------- src : str String containing input and output lines. Returns ------- str String with output demarked. """ rb = RedBaron(src) # find lines with trailing comments so we can preserve them properly lines_with_comments = {} comments = rb.findAll('comment') for c in comments: if c.previous and c.previous.type != 'endl': lines_with_comments[c.previous] = c input_block_number = 0 # find all nodes that might produce output nodes = rb.findAll(lambda identifier: identifier in ['print', 'atomtrailers']) for r in nodes: # assume that whatever is in the try block will fail and produce no output # this way we can properly handle display of error messages in the except if hasattr(r.parent, 'type') and r.parent.type == 'try': continue # Output within if/else statements is not a good idea for docs, because # we don't know which branch execution will follow and thus where to put # the output block. Regardless of which branch is taken, though, the # output blocks must start with the same block number. if hasattr(r.parent, 'type') and r.parent.type == 'if': if_block_number = input_block_number if hasattr(r.parent, 'type') and r.parent.type in ['elif', 'else']: input_block_number = if_block_number if is_output_node(r): # if there was a trailing comment on this line, output goes after it if r in lines_with_comments: r = lines_with_comments[r] # r is now the comment # find the correct node to 'insert_after' while hasattr(r, 'parent') and not hasattr(r.parent, 'insert'): r = r.parent r.insert_after('print(">>>>>%d")\n' % input_block_number) input_block_number += 1 # curse you, redbaron! stop inserting endl before trailing comments! for l, c in lines_with_comments.items(): if c.previous and c.previous.type == 'endl': c.previous.value = '' return rb.dumps()
def test_node_elif_ifelseblock_next(): red = RedBaron("if a:\n pass\nelif a:\n pass") assert red.elif_.next is None red = RedBaron("if a:\n pass\nelif a:\n pass\nelse:\n pass") assert red.elif_.next is red.else_ red = RedBaron("if a:\n pass\nelif a:\n pass\nchocolat") assert red.elif_.next is red.find("name", "chocolat")
def test_find_empty(): red = RedBaron("") assert red.find("stuff") is None assert red.find("something_else") is None assert red.find("something_else", useless="pouet") is None with pytest.raises(AttributeError): red.will_raises
def test_node_if_ifelseblock_previous_intuitive(): red = RedBaron("if a:\n pass") assert red.if_.previous_intuitive is None red = RedBaron("chocolat\nif a:\n pass") assert red.if_.previous_intuitive is red.find("endl") red = RedBaron("pouet\nif a:\n pass\nelif a:\n pass\nelse:\n pass") assert red.else_.previous_intuitive is red.elif_ assert red.if_.previous is None
def test_node_else_elseelseblock_next_generator(): red = RedBaron("if a:\n pass\nelse:\n pass") assert len(list(red.else_.next_generator())) == 0 red = RedBaron("if a:\n pass\nelse:\n pass\nchocolat") assert list(red.else_.next_generator())[0] is red.find("name", "chocolat") red = RedBaron("if a:\n pass\nelse:\n pass\nchocolat") assert list(red.else_.next_generator()) == [red.find("name", "chocolat")]
def main(meetup, tc=(255, 255, 255), bg=None, *tags): target_url = meetup soup = BeautifulSoup(requests.get(target_url).content, "html.parser") description = soup.find("div", id="groupDesc") description = (" " * 4).join(map(lambda x: str(x), description.contents)) + (" " * 4) description = "\n".join(map(lambda x: x.rstrip(), description.split("\n"))) target_meetup_name = target_url.split("/")[-2] target = target_url.split("/")[-2].lower().replace("-", "_") if re.match("^\d", target): target = "_" + target logo_url = soup.find("img", "photo")["src"] if soup.find("img", "photo") else None if bg == None: if logo_url: palette = extract_colors(Image.open(BytesIO(requests.get(logo_url).content))) colors = palette.colors background_color = colors[0].value text_color = tc else: h = (random.randint(1, 100) * 0.618033988749895) % 1 background_color = hsv_to_rgb(h, .5, .95) text_color = "#000000" h, s, v = rgb_to_hsv(background_color) else: background_color = bg text_color = tc # background_color = map(lambda x: (x + 255)/2, background_color) red = RedBaron(open("agendas/be.py", "r").read()) for i in red("def", recursive=False): if target < i.name: break i.insert_before(template % { "background_color": rgb_to_hex(background_color) if not (isinstance(background_color, basestring) and background_color.startswith("#")) else background_color, "text_color": rgb_to_hex(text_color) if not (isinstance(text_color, basestring) and text_color.startswith("#")) else text_color, "url": target_url, "tags": ", ".join(map(repr, tags)), "function_name": target, "description": description, "meetup_name": target_meetup_name, }) red.dumps() open("agendas/be.py", "w").write(red.dumps()) os.system("python manage.py fetch_events %s" % target)
def test_comma_proxy_list_set_item(): red = RedBaron("[1]") comma_proxy_list = red[0].value comma_proxy_list[0] = "42" assert comma_proxy_list[0].type == "int" assert comma_proxy_list[0].value == 42 comma_proxy_list[0] = "plop" assert comma_proxy_list[0].type == "name" assert comma_proxy_list[0].value == "plop" assert red.dumps() == "[plop]"
def test_comma_proxy_list_indented_set_item(): red = RedBaron("[\n 1,\n]") comma_proxy_list = red[0].value comma_proxy_list[0] = "42" assert comma_proxy_list[0].type == "int" assert comma_proxy_list[0].value == "42" comma_proxy_list[0] = "plop" assert comma_proxy_list[0].type == "name" assert comma_proxy_list[0].value == "plop" assert red.dumps() == "[\n plop,\n]"
def replace_argument(txt, pos, new): """ """ red = RedBaron(txt) fst = red.fst()[0] args = fst['arguments'] args = filter(arg_type_no_comma, args) args.pop(pos) args.insert(pos, new) res = reform_input(args, method=fst['name']) return res
def get_method_body(method_code): '''Using the RedBaron module, get the body of a method. Do not want the definition signature line ''' method_code = '\n' + method_code # For some reason RedBaron has problems with this if # if it does not start with an empty line rb = RedBaron(method_code) def_node = rb.findAll("DefNode")[0] # Look for the 'def' node. Should only be one! def_node.value.decrease_indentation(8) # so that the code is all the way to the left return def_node.value.dumps()
def remove_raise_skip_tests(src): """ Remove from the code any raise unittest.SkipTest lines since we don't want those in what the user sees. """ rb = RedBaron(src) raise_nodes = rb.findAll("RaiseNode") for rn in raise_nodes: # only the raise for SkipTest if rn.value[:2].dumps() == 'unittestSkipTest': rn.parent.value.remove(rn) return rb.dumps()
def test_node_previous_recursive(): red = RedBaron("def a():\n b = 1\ndef c():\n d = 1") assert red.previous is None assert red.previous_recursive is None first, second = red.find_all('def') assert second.previous is first inner = second.value.node_list assert inner[2].previous == inner[1] assert inner[2].previous_recursive == inner[1] assert inner[1].previous == inner[0] assert inner[1].previous_recursive == inner[0] assert inner[0].previous == None assert inner[0].previous_recursive == first
def test_node_next_recursive(): red = RedBaron("def a():\n b = 1\ndef c():\n d = 1") assert red.next is None assert red.next_recursive is None first, second = red.find_all('def') assert first.next is second inner = first.value.node_list assert inner[0].next == inner[1] assert inner[0].next_recursive == inner[1] assert inner[1].next == inner[2] assert inner[1].next_recursive == inner[2] assert inner[2].next == None assert inner[2].next_recursive == second
def reform_input(args, method="foo"): """Re-give the def repr. - args: a list of dicts, representing redbaron's arguments - return: something like "def foo(args):" (without 'pass') """ # https://redbaron.readthedocs.io/en/latest/nodes_reference.html#funcdefnode args = interpose_commas(args) newdef = "def {}(): pass".format(method) red = RedBaron(newdef) red[0].arguments = args res = red.dumps().strip() res = res.strip(" pass") return res
def replace_asserts_with_prints(source_code): """ Replace asserts with print statements. Using RedBaron, replace some assert calls with print statements that print the actual value given in the asserts. Depending on the calls, the actual value can be the first or second argument. """ rb = RedBaron(source_code) # convert to RedBaron internal structure for assert_type in ['assertAlmostEqual', 'assertLess', 'assertGreater', 'assertEqual', 'assert_equal_arrays', 'assertTrue', 'assertFalse']: assert_nodes = rb.findAll("NameNode", value=assert_type) for assert_node in assert_nodes: assert_node = assert_node.parent remove_redbaron_node(assert_node, 0) # remove 'self' from the call assert_node.value[0].replace('print') if assert_type not in ['assertTrue', 'assertFalse']: remove_redbaron_node(assert_node.value[1], 1) # remove the expected value argument assert_nodes = rb.findAll("NameNode", value='assert_rel_error') for assert_node in assert_nodes: assert_node = assert_node.parent # If relative error tolerance is specified, there are 4 arguments if len(assert_node.value[1]) == 4: remove_redbaron_node(assert_node.value[1], -1) # remove the relative error tolerance remove_redbaron_node(assert_node.value[1], -1) # remove the expected value remove_redbaron_node(assert_node.value[1], 0) # remove the first argument which is # the TestCase assert_node.value[0].replace("print") assert_nodes = rb.findAll("NameNode", value='assert_almost_equal') for assert_node in assert_nodes: assert_node = assert_node.parent # If relative error tolerance is specified, there are 3 arguments if len(assert_node.value[1]) == 3: remove_redbaron_node(assert_node.value[1], -1) # remove the relative error tolerance remove_redbaron_node(assert_node.value[1], -1) # remove the expected value assert_node.value[0].replace("print") source_code_with_prints = rb.dumps() # get back the string representation of the code return source_code_with_prints
def test_rendering_iter(): red = RedBaron("a + 2") assert list(red._generate_nodes_in_rendering_order()) == [ red[0], red.name, red[0].first_formatting[0], red[0], red[0].second_formatting[0], red.int, ] assert list(red[0]._generate_nodes_in_rendering_order()) == [ red[0], red.name, red[0].first_formatting[0], red[0], red[0].second_formatting[0], red.int, ]
def sort_arguments(txt=""): """Txt (str): a valid python code of a def with arguments. Be careful, txt must be valid python code. example: : def foo(arg): pass - return: str (the def with sorted arguments). """ if not txt: txt = "def foo(first, **kwargs, second=foo): pass" red = RedBaron(txt) fst = red.fst()[0] args = fst['arguments'] args = filter(arg_type_no_comma, args) sargs = sorted(args, cmp=arg_lower) res = reform_input(sargs, method=fst['name']) return res
def functionalize(src): red = RedBaron(src) red.insert(0, 'import pync') for func in red.find_all('def'): func.decorators.append('@pync.curry') for l in red.find_all('list') + red.find_all('list_comprehension'): l.replace("pync.list(%s)" % l) return red.dumps()
def compare(s1, s2, decay_factor = PYTHON_DECAY_FACTOR): try: red1 = RedBaron(s1) red2 = RedBaron(s2) result = [] defs = red2.find_all('def') length = len(defs) for ast_f2 in defs: ast_f1 = red1.find('def', name = ast_f2.name) if ast_f1 is not None: additions, deletions = preprocess_files(ast_f1.dumps(), ast_f2.dumps(), ast_f2.absolute_bounding_box.top_left.line) comments, exceptions = preprocess_comments(ast_f2, additions) for a in additions: for c in comments: line, _ = c.left_bounds distance = line - a score = compute_addition(c, distance, decay_factor) c.setScore(score if score > 0 else 0) for d in deletions: for c in comments: line, _ = c.left_bounds line = line + 1 if line >= d else line distance = line - d score = compute_deletion(c, distance, decay_factor) c.setScore(score if score > 0 else 0) result.extend(comments) result.extend(exceptions) else: comments, _ = preprocess_comments(ast_f2, []) result.extend(comments) print_to_log('Result: ' + str(result)) return result except Exception as e: err = 'CommentHealth compare error: ' + str(e) return []
def test_rendering_iter(): red = RedBaron("a + 2") assert_red = RedBaron("assert a == 5") assert list(red._generate_nodes_in_rendering_order()) == \ [red[0], red.name, red[0].first_formatting[0], red[0], red[0].second_formatting[0], red.int] assert list(red[0]._generate_nodes_in_rendering_order()) == \ [red[0], red.name, red[0].first_formatting[0], red[0], red[0].second_formatting[0], red.int] assert list(assert_red._generate_nodes_in_rendering_order()) == \ [assert_red[0], assert_red[0].first_formatting[0], # SpaceNode in AssertNode assert_red[0].value, # ComparisonNode assert_red.name, assert_red[0].value.first_formatting[0], # SpaceNode in ComparisonNode assert_red[0].value.value, # ComparisonOperatorNode assert_red[0].value.second_formatting[0], # SpaceNode in ComparisonNode assert_red.int] assert list(assert_red[0]._generate_nodes_in_rendering_order()) == \ [assert_red[0], assert_red[0].first_formatting[0], # SpaceNode in AssertNode assert_red[0].value, # ComparisonNode assert_red.name, assert_red[0].value.first_formatting[0], # SpaceNode in ComparisonNode assert_red[0].value.value, # ComparisonOperatorNode assert_red[0].value.second_formatting[0], # SpaceNode in ComparisonNode assert_red.int]
def test_node_else_elseelseblock_previous_generator(): red = RedBaron("if a:\n pass\nelse:\n pass") assert len(list(red.else_.previous_generator())) == 1 red = RedBaron("chocolat\nif a:\n pass\nelse:\n pass\n") assert len(list(red.else_.previous_generator())) == 3 red = RedBaron("chocolat\nif a:\n pass\nelse:\n pass\n") assert list(red.else_.previous_generator())[0] is red.if_ red = RedBaron("chocolat\nif a:\n pass\nelse:\n pass\n") assert list(red.else_.previous_generator()) == [red.find("name", "chocolat"), red.find("endl"), red.if_][::-1]
def handle(self, *args, **options): call_command('migrate', interactive = False) try: company = Entity.objects.get(owner=True) self.stdout.write('Already configured') except Entity.DoesNotExist: entity = Entity() entity.name = 'Your company' entity.description = 'Your company description' entity.endpoint = 'http://*****:*****@test.test' liaison.phone = '123456789' liaison.address = 'Testing Road' liaison.zip = '123456' liaison.city = 'Testicity' liaison.provider = entity liaison.save() base = getattr(settings, 'BASE_DIR') settings_path = os.path.join(base, 'Exchange', 'settings.py') with open(settings_path, 'r+') as f: read_data = f.read() f.seek(0) red = RedBaron(read_data) red.find("assignment", target=lambda x: x.dumps() == "SENDER").value.replace("'" + str(entity.id) + "'") secret_key = ''.join([choice('abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)') for i in range(50)]) red.find("assignment", target=lambda x: x.dumps() == "SECRET_KEY").value.replace("'" + secret_key + "'") f.truncate() code = red.dumps() f.write(code) f.closed print('Database content created') print('Provider configured') print('New secret key generated') self.stdout.write('Setup complete')
def test_comma_proxy_list_indented_delslice(): red = RedBaron("[\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n]") comma_proxy_list = red[0].value del comma_proxy_list[1:4] assert red.dumps() == "[\n 1,\n 5,\n 6,\n]"
def test_import_multi(): red = RedBaron("from m import a, b") assert red[0].targets.dumps() == "a, b"
#!/usr/bin/python # -*- coding:Utf-8 -*- """ Tests the position feature """ import pytest import redbaron # pylint: disable=redefined-outer-name from redbaron import RedBaron, Path redbaron.DEBUG = True fst = RedBaron("""\ @deco def a(c, d): b = c + d e = 1 """) positions = [ (fst.def_.decorators[0], [(1, 1)]), (fst.def_.decorators[0].value.value[0], [(1, 2), (1, 3), (1, 4), (1, 5)]), # How to get this one ? (2, 0) and (2, 1) does not work, see out of scope #(fst.def_.decorators[1], [(?, ?)]), (fst.def_, [(3, 1), (3, 2), (3, 3)]), (fst.def_.first_formatting[0], [(3, 4)]), (fst.def_, [(3, 5), (3, 6)]), (fst.def_.arguments.node_list[0].target, [(3, 7)]), (fst.def_.arguments.node_list[1], [(3, 8)]), (fst.def_.arguments.node_list[1].second_formatting[0], [(3, 9)]), (fst.def_.arguments.node_list[2].target, [(3, 10)]),
def test_empty(): RedBaron("")
def test_kwargs_only_marker_node(): RedBaron("def a(*): pass")
def test_is_list(): assert list(RedBaron("")) == []
def autoformat(filename, abort=False): # All the complexity in one place, pylint: disable=too-many-branches,too-many-statements print("Consider", filename, end=": ") old_code = open(filename, 'r').read() try: red = RedBaron(old_code) # red = RedBaron(old_code.rstrip()+'\n') except ParsingError: if abort: raise print("PARSING ERROR.") return 2 def updateCall(call_node): max_len = 0 for argument in call_node: if argument.type == "argument_generator_comprehension": return if hasattr(argument, "target") and argument.target is not None: key = argument.target.value else: key = None if key is not None: max_len = max(max_len, len(key)) if '\n' not in call_node.second_formatting.dumps(): del call_node.second_formatting[:] del call_node.third_formatting[:] for argument in call_node: if hasattr(argument, "target") and argument.target is not None: key = argument.target.value else: key = None if key is not None: if not argument.second_formatting: argument.second_formatting = ' ' if '\n' in str(call_node.second_formatting): if argument.first_formatting: spacing = argument.first_formatting[0].value else: spacing = "" if len(key) + len(spacing) != max_len + 1: argument.first_formatting = ' ' * (max_len - len(key) + 1) else: argument.first_formatting = ' ' else: if '\n' not in str(call_node.second_formatting): if argument.value.type in ("string", "binary_string", "raw_string"): argument.value.second_formatting = "" def updateTuple(tuple_node): if '\n' not in str(tuple_node.dumps()): tuple_node.second_formatting = "" tuple_node.third_formatting = "" if tuple_node.type == "tuple" and tuple_node.with_parenthesis: if tuple_node.value.node_list: if tuple_node.value.node_list[-1].type not in ( "yield_atom", ): tuple_node.value.node_list[-1].second_formatting = "" for argument in tuple_node.value: if argument.type in ("string", "binary_string", "raw_string"): argument.second_formatting = "" def updateString(string_node): # Skip doc strings for now. if not hasattr(node.parent, "type") or \ string_node.parent.type in ("class", "def", None): return value = string_node.value def isQuotedWith(quote): return value.startswith(quote) and value.endswith(quote) quote = None # For PyLint. for quote in "'''", '"""', "'", '"': if isQuotedWith(quote): break else: sys.exit("Error, quote not understood.") real_value = value[len(quote):-len(quote)] assert quote + real_value + quote == value if '\n' not in real_value: # Single characters, should be quoted with "'" if len(eval(value)) == 1: # pylint: disable=eval-used if real_value != "'": string_node.value = "'" + real_value + "'" else: if '"' not in real_value: string_node.value = '"' + real_value + '"' def updateDefNode(def_node): # This is between "def" and function name. def_node.first_formatting = ' ' # This is after the opening/closing brace, we don't want it there. def_node.third_formatting = "" def_node.fourth_formatting = "" # This is to insert/remove spaces or new lines, depending on line length # so far, but is not functional at all. for argument_node in def_node.arguments: argument_node.first_formatting = ' ' argument_node.second_formatting = ' ' def updateCommentNode(comment_node): if "pylint:" in str(comment_node.value): def replacer(part): def renamer(pylint_token): # pylint: disable=too-many-return-statements if pylint_token == "E0602": return "undefined-variable" elif pylint_token in ("E0401", "F0401"): return "import-error" elif pylint_token == "E1102": return "not-callable" elif pylint_token == "E1133": return " not-an-iterable" elif pylint_token == "E1128": return "assignment-from-none" # Save line length for this until isort is better at long lines. elif pylint_token == "useless-suppression": return "I0021" # elif pylint_token == "I0021": # return "useless-suppression" elif pylint_token == "R0911": return "too-many-return-statements" elif pylint_token == "R0201": return "no-self-use" elif pylint_token == "R0902": return "too-many-instance-attributes" elif pylint_token == "R0912": return "too-many-branches" elif pylint_token == "R0914": return "too-many-locals" elif pylint_token == "R0915": return "too-many-statements" elif pylint_token == "W0123": return "eval-used" elif pylint_token == "W0603": return "global-statement" elif pylint_token == "W0613": return "unused-argument" elif pylint_token == "W0622": return "redefined-builtin" elif pylint_token == "W0703": return "broad-except" else: return pylint_token return part.group(1) + ','.join( sorted( renamer(token) for token in part.group(2).split(','))) new_value = re.sub(r"(pylint\: disable=)(.*)", replacer, str(comment_node.value), flags=re.M) comment_node.value = new_value for node in red.find_all("CallNode"): try: updateCall(node) except Exception: print("Problem with", node) node.help(deep=True, with_formatting=True) raise for node in red.find_all("TupleNode"): try: updateTuple(node) except Exception: print("Problem with", node) node.help(deep=True, with_formatting=True) raise for node in red.find_all("ListNode"): try: updateTuple(node) except Exception: print("Problem with", node) node.help(deep=True, with_formatting=True) raise for node in red.find_all("SetNode"): try: updateTuple(node) except Exception: print("Problem with", node) node.help(deep=True, with_formatting=True) raise for node in red.find_all("StringNode"): try: updateString(node) except Exception: print("Problem with", node) node.help(deep=True, with_formatting=True) raise for node in red.find_all("DefNode"): try: updateDefNode(node) except Exception: print("Problem with", node) node.help(deep=True, with_formatting=True) raise for node in red.find_all("CommentNode"): try: updateCommentNode(node) except Exception: print("Problem with", node) node.help(deep=True, with_formatting=True) raise new_code = red.dumps() if new_code != old_code: new_name = filename + ".new" with open(new_name, 'w') as source_code: source_code.write(red.dumps()) # There is no way to safely replace a file on Windows, but lets try on Linux # at least. old_stat = os.stat(filename) try: os.rename(new_name, filename) except OSError: shutil.copy(new_name, filename) os.chmod(filename, old_stat.st_mode) print("updated.") changed = 1 else: print("OK.") changed = 0 return changed
def test_import_on_new_line(): red = RedBaron("from m import (\n" " a)") assert red[0].targets.dumps() == "(\n a)"
def test_double_separator(): red = RedBaron("fun(a,,)") assert red[0].dumps() == "fun(a,)"
def test_import_multiline(): red = RedBaron("from m import (a,\n b)") assert red[0].targets.dumps() == "(a,\n b)"
def test_comment_in_args(): red = RedBaron("fun(\n" "# comment\n" "a)") assert red[0].dumps() == "fun(\n# comment\na)"
def test_mixmatch_with_redbaron_base_node_and_proxy_list_on_parent(): red = RedBaron("foo = 42\nprint('bar')\n") red.insert(0, "baz") assert red[0].on_attribute == "root" assert red[0].parent is red
def test_class_inline(): code = """ class C: pass """ red = RedBaron(code) assert red.dumps() == code
def test_import(): red = RedBaron("from m import a") assert red[0].targets.dumps() == "a"
def test_def_inline(): code = """ def fun(): pass """ red = RedBaron(code) assert red.dumps() == code
def test_name(): red = RedBaron("a\n") assert len(red.value.node_list) == 2 assert isinstance(red.value.node_list[0], NameNode) assert isinstance(red.value.node_list[1], EndlNode) assert red[0].value == "a"
def test_path_str(): red = RedBaron("name") assert str(Path(red[0]))
import copy import sys from redbaron import RedBaron in_file = out_file = sys.argv[1] code = open(in_file).read() red_baron = RedBaron(code) super_nodes = red_baron.find_all('AtomtrailersNode') for super_node in super_nodes: node = copy.copy(super_node) class_name = node.find_all('name')[1].name.dumps() while node.parent: node = node.parent if node.name == class_name: super_node.value[1] = '()' with open(out_file, "w") as fh: fh.write(red_baron.dumps())
def test_ternary_dict(): code = """ {'scheme': 'https' if condition else 'http'} """ red = RedBaron(code) assert red.dumps() == code
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # from __future__ import print_function import sys, os, shutil from redbaron import RedBaron # @UnresolvedImport print("Consider", sys.argv[1], end = ": ") old_code = open(sys.argv[1], "r").read() red = RedBaron(old_code.rstrip()+"\n") def updateCall(call_node): max_len = 0 for argument in call_node: if argument.type == "argument_generator_comprehension": return if argument.target is not None: key = argument.target.value else: key = None if key is not None: max_len = max(max_len, len(key))
def _parse(python_file): with open(python_file) as fp: # NB: RedBaron is used instead of ``ast`` since it can round-trip from source code without # losing formatting. See: https://github.com/PyCQA/redbaron return RedBaron(fp.read())