def test_cases(path: Path, refactor_path: Path, analyzer_path: Path, logger): case_path = f"{path.parent.name}/{path.name}" analyzer_path_ = analyzer_path / case_path refactor_path_ = refactor_path / case_path logger.debug(f"Source path: {path}") logger.debug(f"Analyzer path: {analyzer_path_}") logger.debug(f"Refactor path: {refactor_path_}") # analyzer tests analyzer_import_path = ".".join(analyzer_path_.parts[:-1]) analyzer_import_path += f".{path.stem}" analyzer = importlib.import_module(analyzer_import_path) source = path.read_text() skip = re.search( "# skip; condition: (?P<condition>.*), reason: (?P<reason>.*)", source, re.IGNORECASE, ) if skip: condition = skip.group("condition") if condition in ["not PY38_PLUS"] and eval(condition): reason = skip.group("reason") pytest.skip(reason, allow_module_level=True) with Analyzer(source=source, include_star_import=True): assert Name.names == analyzer.NAMES assert Import.imports == analyzer.IMPORTS assert list(Import.get_unused_imports()) == analyzer.UNUSED_IMPORTS # refactor tests refactor = refactor_string(source, analyzer.UNUSED_IMPORTS) refactor_path_.write_text(refactor) assert refactor_path_.read_text() == refactor
def refactor(path: Path) -> str: source = utils.read(path)[0] with Analyzer(source=source) as analyzer: return refactor_string( source=analyzer.source, unused_imports=list(Import.get_unused_imports()), )
def refactor(self, source: str) -> str: self.scanner.run_visit(source) refactor = refactor_string( source=source, unused_imports=list(self.scanner.get_unused_imports()), ) self.scanner.clear() return refactor
def refactor(self, source: str) -> str: self.scanner.scan(source) refactor = refactor_string( source=source, unused_imports=self.scanner.unused_imports, ) self.scanner.clear() return refactor
def refactor(self, source: str) -> str: self.scanner.run_visit(source) refactor = refactor_string( source=source, unused_imports=self.scanner.unused_imports, show_error=self.show_error, ) self.scanner.clear() return refactor
def refactor(self, path: Path) -> str: source = utils.read(path)[0] analyzer = Analyzer(source=source, include_star_import=self.include_star_import) analyzer.traverse() refactor_result = refactor_string( source=analyzer.source, unused_imports=list(analyzer.get_unused_imports()), ) return refactor_result
def refactor(self, action: str) -> str: scanner = Scanner( source=textwrap.dedent(action), include_star_import=self.include_star_import, ) scanner.traverse() refactor_result = refactor_string( source=scanner.source, unused_imports=list(scanner.get_unused_imports()), ) return refactor_result
def main(argv: Optional[Sequence[str]] = None) -> int: parser = argparse.ArgumentParser( prog="unimport", description=C.DESCRIPTION, epilog="Get rid of all unused imports 🥳", ) exclusive_group = parser.add_mutually_exclusive_group(required=False) parser.add_argument( "sources", default=default_config.sources, nargs="*", help="Files and folders to find the unused imports.", action="store", type=Path, ) parser.add_argument( "--check", action="store_true", help="Prints which file the unused imports are in.", default=default_config.check, ) parser.add_argument( "-c", "--config", default=".", help="Read configuration from PATH.", metavar="PATH", action="store", type=Path, ) parser.add_argument( "--include", help="File include pattern.", metavar="include", action="store", default=default_config.include, type=str, ) parser.add_argument( "--exclude", help="File exclude pattern.", metavar="exclude", action="store", default=default_config.exclude, type=str, ) parser.add_argument( "--gitignore", action="store_true", help="Exclude .gitignore patterns. if present.", default=default_config.gitignore, ) parser.add_argument( "--ignore-init", action="store_true", help="Ignore the __init__.py file.", default=default_config.ignore_init, ) parser.add_argument( "--include-star-import", action="store_true", help="Include star imports during scanning and refactor.", default=default_config.include_star_import, ) parser.add_argument( "-d", "--diff", action="store_true", help="Prints a diff of all the changes unimport would make to a file.", default=default_config.diff, ) exclusive_group.add_argument( "-r", "--remove", action="store_true", help="Remove unused imports automatically.", default=default_config.remove, ) exclusive_group.add_argument( "-p", "--permission", action="store_true", help="Refactor permission after see diff.", default=default_config.permission, ) parser.add_argument( "--requirements", action="store_true", help= "Include requirements.txt file, You can use it with all other arguments", default=default_config.requirements, ) parser.add_argument( "-v", "--version", action="version", version=f"Unimport {C.VERSION}", help="Prints version of unimport", ) argv = argv if argv is not None else sys.argv[1:] args = parser.parse_args(argv) config = (Config(args.config).parse() if args.config and args.config.name in CONFIG_FILES else default_config) config = config.merge(**vars(args)) unused_modules = set() used_packages: Set[str] = set() for source_path in config.sources: for py_path in utils.list_paths(source_path, config.include, config.exclude): source, encoding = utils.read(py_path) analyzer = Analyzer( source=source, path=py_path, include_star_import=config.include_star_import, ) analyzer.traverse() unused_imports = list(analyzer.get_unused_imports()) unused_modules.update({imp.name for imp in unused_imports}) used_packages.update( utils.get_used_packages(analyzer.imports, unused_imports)) if config.check: for imp in unused_imports: if (isinstance(imp, ImportFrom) and imp.star and imp.suggestions): context = (color.paint( f"from {imp.name} import *", color.RED ) + " -> " + color.paint( f"from {imp.name} import {', '.join(imp.suggestions)}", color.GREEN, )) else: context = color.paint(imp.name, color.YELLOW) print(context + " at " + color.paint(py_path.as_posix(), color.GREEN) + ":" + color.paint(str(imp.lineno), color.GREEN)) if any((config.diff, config.remove)): refactor_result = refactor_string( source=source, unused_imports=unused_imports, ) if config.diff: diff = utils.diff( source=source, refactor_result=refactor_result, fromfile=py_path, ) exists_diff = bool(diff) if exists_diff: print(color.difference(diff)) if config.permission and exists_diff: action = input( f"Apply suggested changes to '{color.paint(str(py_path), color.YELLOW)}' [Y/n/q] ? >" ).lower() if action == "q": return 1 elif utils.actiontobool(action): config = config._replace(remove=True) if config.remove and source != refactor_result: py_path.write_text(refactor_result, encoding=encoding) print( f"Refactoring '{color.paint(str(py_path), color.GREEN)}'") analyzer.clear() if not unused_modules and config.check: print( color.paint( "✨ Congratulations there is no unused import in your project. ✨", color.GREEN, )) if config.requirements: for requirements in Path(".").glob("requirements*.txt"): source = requirements.read_text() copy_source = source.splitlines().copy() for index, requirement in enumerate(source.splitlines()): module_name = utils.package_name_from_metadata( requirement.split("==")[0]) if module_name is None: print(color.paint(requirement + " not found", color.RED)) continue if module_name not in used_packages: copy_source.remove(requirement) if config.check: print( f"{color.paint(requirement, color.CYAN)} at " f"{color.paint(requirements.as_posix(), color.CYAN)}:{color.paint(str(index + 1), color.CYAN)}" ) refactor_result = "\n".join(copy_source) if config.diff: diff = utils.diff( source=source, refactor_result=refactor_result, fromfile=requirements, ) exists_diff = bool(diff) if exists_diff: print(color.difference(diff)) if config.permission and exists_diff: action = input( f"Apply suggested changes to '{color.paint(requirements.as_posix(), color.CYAN)}' [Y/n/q] ? >" ).lower() if action == "q": return 1 if utils.actiontobool(action): config = config._replace(remove=True) if config.remove: requirements.write_text(refactor_result) print( f"Refactoring '{color.paint(requirements.as_posix(), color.CYAN)}'" ) if unused_modules: return 1 else: return 0
def main(argv: Optional[Sequence[str]] = None) -> int: parser = argparse.ArgumentParser( prog="unimport", description=C.DESCRIPTION, epilog=f"Get rid of all unused imports {emoji.PARTYING_FACE}", ) exclusive_group = parser.add_mutually_exclusive_group(required=False) options.add_sources_option(parser) options.add_check_option(parser) options.add_config_option(parser) color.add_color_option(parser) options.add_include_option(parser) options.add_exclude_option(parser) options.add_gitignore_option(parser) options.add_ignore_init_option(parser) options.add_include_star_import_option(parser) options.add_diff_option(parser) options.add_remove_option(exclusive_group) options.add_permission_option(exclusive_group) options.add_requirements_option(parser) options.add_version_option(parser) argv = argv if argv is not None else sys.argv[1:] args = parser.parse_args(argv) config = Config.get_config(args) unused_modules = set() used_packages: Set[str] = set() for path in config.get_paths(): source, encoding, newline = utils.read(path) with Analyzer( source=source, path=path, include_star_import=config.include_star_import, ): unused_imports = list( Import.get_unused_imports(config.include_star_import) ) unused_modules.update({imp.name for imp in unused_imports}) used_packages.update( utils.get_used_packages(Import.imports, unused_imports) ) if config.check: commands.check(path, unused_imports, args.color) if any((config.diff, config.remove)): refactor_result = refactor_string( source=source, unused_imports=unused_imports, ) if config.diff: exists_diff = commands.diff(path, source, refactor_result) if config.permission and exists_diff: commands.permission( path, encoding, newline, refactor_result, args.color ) if config.remove and source != refactor_result: commands.remove( path, encoding, newline, refactor_result, args.color ) if not unused_modules and config.check: print( color.paint( f"{emoji.STAR} Congratulations there is no unused import in your project. {emoji.STAR}", color.GREEN, args.color, ) ) if config.requirements: for path in config.get_requirements(): source = path.read_text() copy_source = source.splitlines().copy() for index, requirement in enumerate(source.splitlines()): module_name = utils.package_name_from_metadata( requirement.split("==")[0] ) if module_name is None: print( color.paint( requirement + " not found", color.RED, args.color ) ) continue if module_name not in used_packages: copy_source.remove(requirement) if config.check: commands.requirements_check( path, index, requirement, args.color ) refactor_result = "\n".join(copy_source) if config.diff: exists_diff = commands.diff(path, source, refactor_result) if config.permission and exists_diff: commands.requirements_permission( path, refactor_result, args.color ) if config.remove and source != refactor_result: commands.requirements_remove( path, refactor_result, args.color ) if unused_modules: return 1 else: return 0