def format_file(path): ''' The function, using 'for' loop scans all the directories as well as sub-directories of the folder for python file and checks for pep8 format. ''' p = "" for dirpath, _, filenames in os.walk(path): if(os.path.exists(os.path.join(dirpath, 'bin/activate'))): p = dirpath for f in filenames: if f.endswith('.py'): filename = os.path.abspath(os.path.join(dirpath, f)) if (not bool(p)): if os.access(filename, os.W_OK): try: file1 = open(filename, 'r') source_code = file1.read() file1.seek(0) file1 = open(filename, 'w') file1.truncate() file1.write(autopep8.fix_code(source_code)) file1.close() except: print(filename) print(sys.exc_info()[0])
def fix_code(code): """Formats Python code to conform to the PEP 8 style guide. """ if not autopep8: raise Fault('autopep8 not installed, cannot fix code.', code=400) return autopep8.fix_code(code, apply_config=True)
def generate_file(target_path, filename, template_name, context=None, raw=False): """ Generates a new file using Jinja2 template :param dirname: :param template_name: :param context: :return: """ filename = os.path.join(target_path, filename) dirname = os.path.dirname(filename) if len(dirname) and not os.path.exists(dirname): os.makedirs(dirname) with open(filename, 'w') as f: if not raw: rendered = render_template(template_name, context=context) else: rendered = render_file(template_name) if not NO_PEP and filename.endswith('.py'): rendered = autopep8.fix_code(rendered) f.write(rendered)
def format_file(target_path, filename): filename = os.path.join(target_path, filename) with open(filename, 'r') as f: code = f.read() with open(filename, 'w') as f: f.write(autopep8.fix_code(code))
def gen(path, method=None, query_params=None, data=None, content_type=None): # generates python code representing a call via django client. # useful for use in testing method = method.lower() t = jinja2.Template(template) if method == 'get': r = t.render(path=path, data=query_params, lower_case_method=method, content_type=content_type) else: if query_params: query_params = _encode_query_params(query_params) path += query_params if is_str_typ(data): data = "'%s'" % data r = t.render(path=path, data=data, lower_case_method=method, query_params=query_params, content_type=content_type) return autopep8.fix_code( r, options=autopep8.parse_args(['--aggressive', '']) )
def build_code(): imports = list(aug_dict.keys()) res_imports = build_code_substring(imports) composes = build_code_substring(apply_changes(aug_dict)) pytorch2tensor = '' if st.sidebar.checkbox('add ToTensorv2()'): pytorch2tensor = 'from albumentations.pytorch import ToTensorV2' composes += '\nToTensorV2(),' result = """{pytorch2tensor} from albumentations import ( Compose, {imports} ) transformations = Compose([ {tf} ])""".format( pytorch2tensor=pytorch2tensor, imports=res_imports, tf=composes, ) return autopep8.fix_code(result, options={ 'max_line_length': 80, })
def run(self, filename, file, max_line_length: int=80, tab_width: int=SpacingHelper.DEFAULT_TAB_WIDTH, pep_ignore: typed_list(str)=(), pep_select: typed_list(str)=(), local_pep8_config: bool=False): """ Detects and fixes PEP8 incompliant code. This bear will not change functionality of the code in any way. :param max_line_length: Maximum number of characters for a line. :param tab_width: Number of spaces per indent level. :param pep_ignore: A list of errors/warnings to ignore. :param pep_select: A list of errors/warnings to exclusively apply. :param local_pep8_config: Set to true if autopep8 should use a config file as if run normally from this directory. """ options = {"ignore": pep_ignore, "select": pep_select, "max_line_length": max_line_length, "indent_size": tab_width} corrected = autopep8.fix_code(''.join(file), apply_config=local_pep8_config, options=options).splitlines(True) diffs = Diff.from_string_arrays(file, corrected).split_diff() for diff in diffs: yield Result(self, "The code does not comply to PEP8.", affected_code=(diff.range(filename),), diffs={filename: diff})
def format_code(): old_code = request.args.get('code') # TODO: add an option which allows users to select autoformat provider (yapf or autopep8) new_code = autopep8.fix_code(old_code, options=read_options()) new_code = new_code.strip() return jsonify(code=new_code)
def code_for_builder(builder, var_name=None): ''' Returns code that can be executed to construct the given builder, including import statements. :param builder: :class:`~tda.orders.generic.OrderBuilder` to generate. :param var_name: If set, emit code that assigns the builder to a variable with this name. ''' ast = construct_order_ast(builder) imports = defaultdict(set) lines = [] ast.render(imports, lines) import_lines = [] for module, names in imports.items(): line = 'from {} import {}'.format(module, ', '.join(names)) if len(line) > 80: line = 'from {} import (\n{}\n)'.format(module, ',\n'.join(names)) import_lines.append(line) if var_name: var_prefix = f'{var_name} = ' else: var_prefix = '' return autopep8.fix_code('\n'.join(import_lines) + '\n\n' + var_prefix + '\n'.join(lines))
def fix_line_range(source_code, start, end, options): """Apply autopep8 (and docformatter) between the lines start and end of source.""" # TODO confirm behaviour outside range (indexing starts at 1) start = max(start, 1) options.line_range = [start, end] from autopep8 import fix_code fixed = fix_code(source_code, options) try: if options.docformatter: from docformatter import format_code fixed = format_code( fixed, summary_wrap_length=options.max_line_length - 1, description_wrap_length=(options.max_line_length - 2 * options.indent_size), pre_summary_newline=options.pre_summary_newline, post_description_blank=options.post_description_blank, force_wrap=options.force_wrap, line_range=[start, end]) except AttributeError: # e.g. using autopep8.parse_args, pragma: no cover pass return fixed
def translate(self, command): """ translates one command to pseudo command(s) :param command: pseudo code string :return: python code """ original_command = command try: # remove tabs from the beginning of the first line and counts them tabs = count_on_start(command, TAB) command = command[tabs*4:] command_parts = self.split_by_strings(command) tokens = sum([self.tokenize(part) for part in command_parts], []) # produce list of tokens if not tokens: # empty line return "" replacements = self.pos_model.evaluate(tokens) generic_pseudo = [replacements[t] if t in replacements.keys() else t for t in tokens] generic_python = self.g2g_model.evaluate(generic_pseudo) python_tokens = [replacements.inverse[t] if t in replacements.values() else t for t in generic_python] python_code = self.join_tokens(python_tokens) if not self.is_valid(python_code): raise TranslationException("wrong syntax for generated python code") return self.add_tabs(autopep8.fix_code(python_code), tabs) except TranslationException: return original_command
def generate_lightweight_component(template, step_name, step_data, nb_path, metadata): """Use the function template to generate Python code.""" step_source_raw = step_data.get('source', []) def _encode_source(s): # Encode line by line a multiline string return "\n".join([line.encode("unicode_escape").decode("utf-8") for line in s.splitlines()]) # Since the code will be wrapped in triple quotes inside the template, # we need to escape triple quotes as they will not be escaped by # encode("unicode_escape"). step_source = [re.sub(r"'''", "\\'\\'\\'", _encode_source(s)) for s in step_source_raw] step_marshal_in = step_data.get('ins', []) step_marshal_out = step_data.get('outs', []) step_parameters = get_args(step_data.get('parameters', {})) fn_code = template.render( step_name=step_name, function_body=step_source, in_variables=step_marshal_in, out_variables=step_marshal_out, parameters=step_parameters, nb_path=nb_path, # step_parameters overrides the parameters fields of metadata **{**metadata, **step_parameters} ) # fix code style using pep8 guidelines return autopep8.fix_code(fn_code)
def _format(config, document, line_range=None): options = _autopep8_config(config, document) if line_range: options['line_range'] = list(line_range) # Temporarily re-monkey-patch the continued_indentation checker - #771 del pycodestyle._checks['logical_line'][pycodestyle.continued_indentation] pycodestyle.register_check(autopep8_c_i) new_source = fix_code(document.source, options=options) # Switch it back del pycodestyle._checks['logical_line'][autopep8_c_i] pycodestyle.register_check(pycodestyle.continued_indentation) if new_source == document.source: return [] # I'm too lazy at the moment to parse diffs into TextEdit items # So let's just return the entire file... return [{ 'range': { 'start': { 'line': 0, 'character': 0 }, # End char 0 of the line after our document 'end': { 'line': len(document.lines), 'character': 0 } }, 'newText': new_source }]
def run_test(self, func_body): # This is only will be used by function unit test implementation unit_file = self.parent.unit_file exec_import_path = "\nfrom importlib import reload\n" # import_path += "import {}".format(self.parent.module_name) import_path = self.parent.import_path import_path += " import " # print("node module") # print(self.parent.parent.node_module) import_path += ",".join(self.parent.node_module) exec_import_path += "import {}\n".format(unit_file.getRoot()) unit_file = self.parent.unit_file # print("===>{}==>{}".format(unit_file.getModule(), unit_file.getRoot())) # print(import_path) exec_import_path += "\nreload({})\n".format( unit_file.getReloadPath()) code_str = import_path + exec_import_path + "\n"+func_body func_body_format = (autopep8.fix_code(code_str)) # print(func_body_format) codeObejct = compile(func_body_format, 'test', "exec") Vars = {} exec(codeObejct, globals(), Vars) return Vars
def main(): readme_path = 'README.rst' before_key = 'Before running autopep8.\n\n.. code-block:: python' after_key = 'After running autopep8.\n\n.. code-block:: python' options_key = 'Options::' (top, before, bottom) = split_readme(readme_path, before_key=before_key, after_key=after_key, options_key=options_key, end_key='Features\n========') input_code = textwrap.dedent(before) output_code = autopep8.fix_code( input_code, options=autopep8.parse_args(['', '--aggressive'])[0]) compile(output_code, '<string>', 'exec', dont_inherit=True) new_readme = '\n\n'.join([ top, before_key, before, after_key, indent(output_code), options_key, indent(help_message()), bottom]) with open(readme_path, 'w') as output_file: output_file.write(new_readme)
def on_source_autopep8_mi(self, mi): try: import autopep8 except: logging.exception("Can't use autopep8") else: buff = self.main_window.current_buffer if buff is not None: b = buff.get_buffer() t = b.get_text(b.get_start_iter(), b.get_end_iter(), False) buff.save_state() t = autopep8.fix_code( t, options=autopep8.parse_args([ '--aggressive', '--ignore', 'E123,E721', #'--ignore', '', '' ])) b.set_text(t) buff.restore_state() return
def level(self, level): # check this is a valid level assert level in sf_api.GM_LEVELNAMES ret = self.run(cmd=sf_api.GM_LEVELNAMES[level]) if ret[0] != 0: return -1, ret[1] # get the level path level_path = os.path.join(LIBSFPATH, 'level%i' % level) # store the instructions if 'instructions' in ret[1]: instructions_filename = os.path.join(level_path, INSTRUCTIONS_FILENAME) with open(instructions_filename, 'w') as f: for k, v in ret[1]['instructions'].iteritems(): f.write('\n== %s\n\n%s\n' % (k, v)) del ret[1]['instructions'] # store the rest if not ret[1]['ok']: return -1, 'error: checking client: %r' % ret[1] del ret[1]['ok'] keys_filename = os.path.join(level_path, KEYS_FILENAME) with open(keys_filename, 'w') as f: f.write(PYTHON_HEADER) f.write(autopep8.fix_code('kwargs = %s' % ret[1], options={'aggressive': 1})) print 'keys filename: %s' % keys_filename return 0, ''
def format_file(path): ''' The function, using 'for' loop scans all the directories as well as sub-directories of the folder for python file and checks for pep8 format. ''' p = "" for dirpath, _, filenames in os.walk(path): if os.path.exists(os.path.join(dirpath, 'bin/activate')): p = dirpath for file_ in filenames: if file_.endswith('.py'): file_ = os.path.abspath(os.path.join(dirpath, file_)) if (not bool(p)) and os.access(file_, os.W_OK): try: temp_file = open(file_, 'r') source_code = temp_file.read() temp_file.seek(0) temp_file = open(file_, 'w') temp_file.truncate() temp_file.write(autopep8.fix_code(source_code)) temp_file.close() except: print(file_) print(sys.exc_info()[0])
def analyze_repo(repo): global number for file_text in get_files_text(repo, ".py"): origin = file_text.decoded_content.decode() new = autopep8.fix_code(origin) if new != origin: print("COMMIT fix to file", file_text.path)
def burn_disc(self): """Burn the disc with songs.""" self.ensure_one() content = self.dj_render_template() # make sure PEP8 is safe content = autopep8.fix_code(content) return self.disc_full_path(), to_str(content)
def generate_fuzzer(self, grammars, *, encoding='utf-8', lib_dir=None, actions=True, pep8=False): """ Generates fuzzers from grammars. :param grammars: List of grammar files to generate from. :param encoding: Grammar file encoding. :param lib_dir: Alternative directory to look for imports. :param actions: Boolean to enable or disable grammar actions. :param pep8: Boolean to enable pep8 to beautify the generated fuzzer source. """ lexer_root, parser_root = None, None for grammar in grammars: root = self._parse(grammar, encoding, lib_dir) # Lexer and/or combined grammars are processed first to evaluate TOKEN_REF-s. if root.grammarType().LEXER() or not root.grammarType().PARSER(): lexer_root = root else: parser_root = root fuzzer_generator = FuzzerGenerator(self.antlr_parser_cls, actions) for name, src in fuzzer_generator.generate(lexer_root, parser_root): with open(join(self.work_dir, name + '.py'), 'w') as f: if pep8: src = autopep8.fix_code(src) f.write(src)
def main(): readme_path = 'README.rst' before_key = 'Before running autopep8.\n\n.. code-block:: python' after_key = 'After running autopep8.\n\n.. code-block:: python' options_key = 'Options::' (top, before, bottom) = split_readme(readme_path, before_key=before_key, after_key=after_key, options_key=options_key, end_key='Features\n========') input_code = textwrap.dedent(before) output_code = autopep8.fix_code(input_code, options={'aggressive': 2}) check(output_code) new_readme = '\n\n'.join([ top, before_key, before, after_key, indent(output_code).rstrip(), options_key, indent(help_message()), bottom ]) with open(readme_path, 'w') as output_file: output_file.write(new_readme)
def normalize_python(code): # TODO: we should really be comparing the tree between a, b but this # works for now if code is None: return None code = _delete_python_comments(code) if not autopep8 or not parso: raise ImportError('autopep8 and parso are required for normalizing ' 'Python code: pip install autopep8 parso') node = parso.parse(code).children[0] if node.type == 'decorated': node = node.children[-1] try: doc_node = node.get_doc_node() except Exception: # function without docstring... doc_node = None if doc_node is not None: code = code.replace('\n' + doc_node.get_code(), '') code = autopep8.fix_code(code) return code
def generate_fuzzer(self, grammars, *, options=None, encoding='utf-8', lib_dir=None, actions=True, pep8=False): """ Generates fuzzers from grammars. :param grammars: List of grammar files to generate from. :param options: Dictionary of options that override/extend those set in the grammar. :param encoding: Grammar file encoding. :param lib_dir: Alternative directory to look for imports. :param actions: Boolean to enable or disable grammar actions. :param pep8: Boolean to enable pep8 to beautify the generated fuzzer source. """ lexer_root, parser_root = None, None for grammar in grammars: root = self._parse(grammar, encoding, lib_dir) # Lexer and/or combined grammars are processed first to evaluate TOKEN_REF-s. if root.grammarType().LEXER() or not root.grammarType().PARSER(): lexer_root = root else: parser_root = root graph = build_graph(self.antlr_parser_cls, actions, lexer_root, parser_root) graph.options.update(options or {}) src = self.template.render(graph=graph, version=__version__).lstrip() with open(join(self.work_dir, graph.name + '.' + self.lang), 'w') as f: if pep8: src = autopep8.fix_code(src) f.write(src)
def _format(config, document, line_range=None): options = _autopep8_config(config) if line_range: options['line_range'] = list(line_range) new_source = fix_code(document.source, options=options) if new_source == document.source: return [] # I'm too lazy at the moment to parse diffs into TextEdit items # So let's just return the entire file... return [{ 'range': { 'start': { 'line': 0, 'character': 0 }, # End char 0 of the line after our document 'end': { 'line': len(document.lines), 'character': 0 } }, 'newText': new_source }]
def fix_code(code): """Formats Python code to conform to the PEP 8 style guide. """ if not autopep8: raise Fault("autopep8 not installed, cannot fix code.", code=400) return autopep8.fix_code(code, apply_config=True)
def run(self, filename, file, max_line_length: int=79, indent_size: int=SpacingHelper.DEFAULT_TAB_WIDTH, pep_ignore: typed_list(str)=(), pep_select: typed_list(str)=(), local_pep8_config: bool=False): """ Detects and fixes PEP8 incompliant code. This bear will not change functionality of the code in any way. :param max_line_length: Maximum number of characters for a line. :param indent_size: Number of spaces per indentation level. :param pep_ignore: A list of errors/warnings to ignore. :param pep_select: A list of errors/warnings to exclusively apply. :param local_pep8_config: Set to true if autopep8 should use a config file as if run normally from this directory. """ options = {'ignore': pep_ignore, 'select': pep_select, 'max_line_length': max_line_length, 'indent_size': indent_size} corrected = autopep8.fix_code(''.join(file), apply_config=local_pep8_config, options=options).splitlines(True) diffs = Diff.from_string_arrays(file, corrected).split_diff() for diff in diffs: yield Result(self, 'The code does not comply to PEP8.', affected_code=(diff.range(filename),), diffs={filename: diff})
def init_forms(self, section_name): forms_text = autopep8.fix_code( self.forms_string(self.sections[section_name].resources)) forms_path = os.path.join(self.app_directory, self.app_name, section_name, "forms.py") with open(forms_path, "w") as forms_file: forms_file.write(forms_text)
def normalize_python(code): # TODO: we should really be comparing the tree between a, b but this # works for now if code is None: return None code = _delete_python_comments(code) if not autopep8 or not parso: raise ImportError('autopep8 and parso are required for normalizing ' 'Python code: pip install autopep8 parso') try: doc_node = parso.parse(code).children[0].get_doc_node() except Exception as e: warnings.warn( 'Could not remove docstring from Python code: {}'.format(e)) else: if doc_node is not None: code = code.replace(doc_node.get_code(), '') code = autopep8.fix_code(code) return code
def create_plugin_code(code, name, category=None, menu=False, toolbar=False, icon=None): """Create a plugin with an action that will execute 'code' when triggered. If 'menu' and/or 'toolbar' is True, the corresponding items will be added for the action. """ if category is None: category = name safe_name = string.capwords(name).replace(" ", "") plugin_code = header.format(safe_name, name) if icon is None: plugin_code += action_noicon.format() else: plugin_code += action_icon.format(icon) if menu: plugin_code += menu_def.format(category) if toolbar: plugin_code += toolbar_def.format(category) # Indent code by two levels code = indent(code, 2 * 4) plugin_code += default.format(code) try: import autopep8 plugin_code = autopep8.fix_code(plugin_code, options=autopep8.parse_args( ['--aggressive', '--aggressive', ''])) except ImportError: pass return plugin_code
def main(): readme_path = 'README.rst' before_key = 'Before running autopep8.\n\n.. code-block:: python' after_key = 'After running autopep8.\n\n.. code-block:: python' options_key = 'Options::' (top, before, bottom) = split_readme(readme_path, before_key=before_key, after_key=after_key, options_key=options_key, end_key='Features\n========') input_code = textwrap.dedent(before) output_code = autopep8.fix_code( input_code, options={'aggressive': 2}) check(output_code) new_readme = '\n\n'.join([ top, before_key, before, after_key, indent(output_code).rstrip(), options_key, indent(help_message()), bottom]) with open(readme_path, 'w') as output_file: output_file.write(new_readme)
def do_show(self, line): """Show me the code! """ code = autopep8.fix_code("".join(self._generate_workflow_code())) if self.options.no_highlight: print code else: print highlight(code, PythonLexer(), TerminalFormatter())
def do_gen(self, line): if os.path.exists(self.file_name): prompt = u"确定要生成代码?之前的代码文件 '{}' 将被覆盖(y/n)".format( self.file_name).encode("utf-8") if raw_input(prompt) != 'y': return with open(self.file_name, "w") as f: f.write(autopep8.fix_code("".join(self._generate_workflow_code())))
def init_init(self): init_text = autopep8.fix_code(self.init_string(), options={"ignore": ["E402"] }) # fixing code will break init_path = os.path.join(self.app_directory, self.app_name, "__init__.py") with open(init_path, "w") as init_file: init_file.write(init_text)
def export_code(self): action_code = "from imgaug import augmenters as iaa\n\n" action_code += 'seq=' + self.sequential.to_code() action_code = autopep8.fix_code(action_code) save_code_path = QFileDialog.getSaveFileName(self, "保存为", r'D:\\', '*.py')[0] if save_code_path != '': with codecs.open(save_code_path, 'wb', encoding='utf-8') as save_file: save_file.write(action_code)
def validate_code(self): try: validated_code = pep8.fix_code(self, options={'verbose': 1}) return validated_code except AttributeError: print("The input " + self + " is not a valid attribute") except Exception as e: (print(e))
def tree_to_str(tree: AST) -> str: fix_missing_locations(tree) return autopep8.fix_code(ast.unparse(tree), options={ "aggressive": 1, "max_line_length": 120 })
def save_code(): if request.method == "POST": code_text = request.form["orig_code"] code_file = gen_text_file(autopep8.fix_code(code_text)) attachment_filename = ''.join(('code_', '.py')) return send_file(code_file, mimetype="application/x-python", as_attachment=True, attachment_filename=attachment_filename)
def _to_pep8(dd): # dir_backup = Dir_Root("__backup") for fn in dd.filenames(): if fn.endswith(".py"): try: content = autopep8.fix_code(to_unicode(dd.get(fn))) dd.set(fn, to_utf8(to_unicode(content))) except Exception as e: print e dd.set(fn, DIR_MAIN.get(fn))
def formatters(aggressive): """Return list of code formatters.""" if aggressive: yield autoflake.fix_code autopep8_options = autopep8.parse_args( [''] + int(aggressive) * ['--aggressive']) else: autopep8_options = None yield lambda code: autopep8.fix_code(code, options=autopep8_options) yield docformatter.format_code yield unify.format_code
def formatted(self): now = datetime.datetime.now() history = "# {}\n# version: {}\n\n".format(now.isoformat(), Env.hc().version) history += "from hail import *\n\n" for stmt in self.statements: history += (stmt + "\n\n") history += ("(" + self.expr + ")") try: import autopep8 return autopep8.fix_code(history) except ImportError: return history
def create_network_py(config): context = { "meta": config["meta"], "data": config["data"], "network": config["network"], "loss": config["loss"], } with open(os.path.join(config["path"], config["name"]), 'w') as f: py = render_template('network.tpl', context) py = autopep8.fix_code(py, options={'aggressive': 1}) f.write(py)
def run(self, edit): syntax = self.view.settings().get('syntax') if syntax.lower().find('python') == -1: return replace_region = self.view.line( sublime.Region(0, self.view.size())) source = self.view.substr(replace_region) fixed = autopep8.fix_code(source, options=PPA.get_options()) is_dirty, err = MergeUtils.merge_code(self.view, edit, source, fixed) if err: sublime.error_message( "%s: Merge failure: '%s'" % (PLUGIN_NAME, err)) raise
def run_autopep(file, pep_ignore, pep_select, max_line_length, indent_size): new_file = autopep8.fix_code( ''.join(file), options={'ignore': pep_ignore, 'select': pep_select, 'max_line_length': max_line_length, 'indent_size': indent_size}) return new_file.splitlines(True), []
def fix_code(code, directory): """Formats Python code to conform to the PEP 8 style guide. """ if not autopep8: raise Fault('autopep8 not installed, cannot fix code.', code=400) old_dir = os.getcwd() try: os.chdir(directory) return autopep8.fix_code(code, apply_config=True) finally: os.chdir(old_dir)
def create_trainer_py(config): context = { "meta": config["meta"], "data": config["data"], "network": config["network"], "loss": config["loss"], "optimizer": config["loss"] } with open(os.path.join(config["path"], "trainer.py"), 'w') as f: py = render_template('trainer.tpl', context) py = autopep8.fix_code(py, options={'aggressive': 1}) f.write(py)
def build_pants_target(file_info): def _wrap_quotes(string): return "'%s'" % string name = _wrap_quotes(file_info['name']) sources = ", ".join([_wrap_quotes(source) for source in file_info['sources']]) dependencies = "\n".join(file_info['dependencies']) return autopep8.fix_code(PANTS_TARGET_TEMPLATE.substitute( name=name, sources=sources, dependencies=dependencies ))
def main(argv=None): argv = argv if argv is not None else sys.argv[1:] args = autopep8.parse_args(argv, apply_config=True) retv = 0 for filename in args.files: original_contents = io.open(filename).read() new_contents = autopep8.fix_code(original_contents, args) if original_contents != new_contents: print('Fixing {0}'.format(filename)) retv = 1 with io.open(filename, 'w') as output_file: output_file.write(new_contents) return retv
def create_file(fname, group, objs): source_files = [] for obj in objs: class_source = generate_class(obj) if tidy: class_source = autopep8.fix_code( class_source, options=autopep8.parse_args(["--aggressive", "--aggressive", "--aggressive", ""]) ) class_source = format_code(class_source) source_files.append(class_source) source = generate_group(group, source_files) with open("../pyidf/{}.py".format(fname), "w") as f: f.write(source)
def beautify_with_autopep8_yapf_isort(path): contents = get_file_contents(path) autopep8ed_contents = autopep8.fix_code(contents, apply_config=True) try: yapfed_contents, _ = FormatCode( autopep8ed_contents, filename=path, style_config='setup.cfg') except SyntaxError as e: print(e) return False isorted_contents = SortImports(file_contents=yapfed_contents).output if contents == isorted_contents: return False put_file_contents(path, isorted_contents) return True
def on_autopep8_activate(self): doc = self.window.get_active_document() if not doc: return try: encoding = doc.get_encoding().get_charset() except Exception as err: encoding = 'utf-8' print('Encoding err', err) start, end = doc.get_bounds() doc.set_text(autopep8.fix_code( doc.get_text(start, end, include_hidden_chars=True).encode(encoding), encoding=encoding))
def to_pep8(dir_path=CUR_PATH): import autopep8 for root, dirs, files in os.walk(dir_path): for filename in files: if filename.endswith(".py") and "Utils_" not in filename: filepath = PATH_JOIN(root, filename) try: with open(filepath, "r") as F: content = autopep8.fix_code(to_unicode(F.read())) with open(filepath, "w") as F: F.write(to_utf8(to_unicode(content))) except Exception as e: print e
def generate_code(self, app_list, **options): t = loader.get_template( 'django_extension_commands/view/{0}/{1}.tpl'.format( 'fbv' if self.function_based else 'cbv', self.view_type )) if not isinstance(t, Template) and not (hasattr(t, 'template') and isinstance(t.template, Template)): raise Exception("Default Django template loader isn't used. " "This can lead to the incorrect template rendering. " "Please, check the settings.") c = Context({ 'app_list': app_list, }) code = t.render(c) code = autopep8.fix_code(code) return code
def autopep8_line_range(self, f, start, end): """Apply autopep8 between start and end of file f xcasxz.""" self.options.line_range = [start, end] fixed = autopep8.fix_code(f, self.options) if self.options.docformatter: fixed = docformatter.format_code( fixed, summary_wrap_length=self.options.max_line_length - 1, description_wrap_length=(self.options.max_line_length - 2 * self.options.indent_size), pre_summary_newline=self.options.pre_summary_newline, post_description_blank=self.options.post_description_blank, force_wrap=self.options.force_wrap, line_range=[start, end]) return fixed
def create_spiders(spiders, schemas, extractors, items, selector='css'): """Create all spiders from slybot spiders.""" item_classes = '' if items: item_classes = '\nfrom ..items import {}'.format( ', '.join((v().__class__.__name__ for v in items.values())) ) spider_data = [] for name, (spider, spec) in spiders.items(): log.info('Creating spider "%s"' % spider.name) spider = create_spider(name, spider, spec, schemas, extractors, items, selector) cleaned_name = _clean(name) filename = 'spiders/{}.py'.format(cleaned_name) data = '\n'.join((SPIDER_FILE(item_classes=item_classes), spider.strip())) code = fix_code(to_unicode(data), OPTIONS) spider_data.append((filename, code)) return spider_data
def run(self, filename, file, max_line_length: int = 79, indent_size: int = SpacingHelper.DEFAULT_TAB_WIDTH, pep_ignore: typed_list(str) = (), pep_select: typed_list(str) = (), local_pep8_config: bool = False, ): """ Detects and fixes PEP8 incompliant code. This bear will not change functionality of the code in any way. :param max_line_length: Maximum number of characters for a line. When set to 0 allows infinite line length. :param indent_size: Number of spaces per indentation level. :param pep_ignore: A list of errors/warnings to ignore. :param pep_select: A list of errors/warnings to exclusively apply. :param local_pep8_config: Set to true if autopep8 should use a config file as if run normally from this directory. """ if not max_line_length: max_line_length = sys.maxsize options = {'ignore': pep_ignore, 'select': pep_select, 'max_line_length': max_line_length, 'indent_size': indent_size} corrected = autopep8.fix_code(''.join(file), apply_config=local_pep8_config, options=options).splitlines(True) diffs = Diff.from_string_arrays(file, corrected).split_diff() for diff in diffs: yield Result(self, 'The code does not comply to PEP8.', affected_code=(diff.range(filename),), diffs={filename: diff})