Use single quotes for formatting

Author: albertas

deadcode/actions/find_python_filenames.py

@@ -16,21 +16,21 @@ def find_python_filenames(args: Args) -> List[str]:
 
         if _match(path, args.exclude):
             if args.verbose:
-                logger.info(f"Ignoring: {path}")
+                logger.info(f'Ignoring: {path}')
             continue
 
-        if path.is_file() and path.suffix == ".py":
+        if path.is_file() and path.suffix == '.py':
             filenames.append(str(path))
         elif path.is_dir():
-            paths += list([str(p) for p in path.glob("*")])
+            paths += list([str(p) for p in path.glob('*')])
         elif not path.exists():
             # TODO: unify error logging and reporting
             # Maybe a cli flag could be added to stop on error
-            logger.error(f"Error: {path} could not be found.")
+            logger.error(f'Error: {path} could not be found.')
 
     if args.verbose:
-        sep = "\n  - "
-        logger.info(f"Files to be checked for dead code: {sep.join(filenames)}")
+        sep = '\n  - '
+        logger.info(f'Files to be checked for dead code: {sep.join(filenames)}')
     return filenames
 
 

deadcode/actions/fix_or_show_unused_code.py

@@ -36,28 +36,28 @@ def fix_or_show_unused_code(unused_items: Iterable[CodeItem], args: Args) -> str
             file_content_lines = f.readlines()
 
         updated_file_content_lines = remove_file_parts_from_content(file_content_lines, unused_file_parts)
-        updated_file_content = "".join(updated_file_content_lines)
+        updated_file_content = ''.join(updated_file_content_lines)
         if updated_file_content.strip():
-            if args.dry and ("__all_files__" in args.dry or _match(filename, args.dry)):
-                with open(filename, "r") as f:
+            if args.dry and ('__all_files__' in args.dry or _match(filename, args.dry)):
+                with open(filename, 'r') as f:
                     diff = unified_diff(f.readlines(), updated_file_content_lines, fromfile=filename, tofile=filename)
                     # TODO: consider printing result instantly to save memory
-                    diff_str = "".join(diff)
+                    diff_str = ''.join(diff)
                     if args.no_color:
                         result.append(diff_str)
                     else:
                         result.append(add_colors_to_diff(diff_str))
 
             elif args.fix:
-                with open(filename, "w") as f:
+                with open(filename, 'w') as f:
                     # TODO: is there a method writelines?
                     f.write(updated_file_content)
         else:
             os.remove(filename)
 
     if result:
-        return "\n".join(result)
-    return ""
+        return '\n'.join(result)
+    return ''
 
     # TODO: update this one: solution is to use read and write operations.
     #

deadcode/actions/get_unused_names_error_message.py

@@ -11,25 +11,25 @@ def get_unused_names_error_message(unused_names: Iterable[CodeItem], args: Args)
         return None
 
     if args.quiet:
-        return ""
+        return ''
 
     if args.count:
-        return f"{len(unused_names)}"
+        return f'{len(unused_names)}'
 
     messages = []
     for item in unused_names:
-        message = f"{item.filename_with_position} \033[91m{item.error_code}\033[0m "
+        message = f'{item.filename_with_position} \033[91m{item.error_code}\033[0m '
         message += item.message or (
             f"{item.type_.replace('_', ' ').capitalize()} " f"`\033[1m{item.name}\033[0m` " f"is never used"
         )
         if args.no_color:
-            message = message.replace("\033[91m", "").replace("\033[1m", "").replace("\033[0m", "")
+            message = message.replace('\033[91m', '').replace('\033[1m', '').replace('\033[0m', '')
         messages.append(message)
 
     if args.fix:
         message = f"\nRemoved \033[1m{len(unused_names)}\033[0m unused code item{'s' if len(unused_names) > 1 else ''}!"
         if args.no_color:
-            message = message.replace("\x1b[1m", "").replace("\x1b[0m", "")
+            message = message.replace('\x1b[1m', '').replace('\x1b[0m', '')
         messages.append(message)
 
-    return "\n".join(messages)
+    return '\n'.join(messages)

deadcode/actions/parse_abstract_syntax_tree.py

@@ -9,5 +9,5 @@ def parse_abstract_syntax_tree(file_content: FileContent, args: Args, filename:
         return ast.parse(file_content, filename=filename, type_comments=True)
     except:  # noqa: E722
         if not args.count and not args.quiet:
-            print(f"Error: Failed to parse {filename} file, ignoring it.")
+            print(f'Error: Failed to parse {filename} file, ignoring it.')
         return ast.Module()

deadcode/actions/parse_arguments.py

@@ -26,173 +26,173 @@ def parse_arguments(args: Optional[List[str]]) -> Args:
 
     # Docs: https://docs.python.org/3/library/argparse.html
     parser = argparse.ArgumentParser()
-    parser.add_argument("paths", help="Paths where to search for python files", nargs="+")
+    parser.add_argument('paths', help='Paths where to search for python files', nargs='+')
     parser.add_argument(
-        "--fix",
-        help="Automatically remove detected unused code expressions from the code base.",
-        action="store_true",
+        '--fix',
+        help='Automatically remove detected unused code expressions from the code base.',
+        action='store_true',
         default=False,
     )
     parser.add_argument(
-        "--dry",
-        help="Show changes which would be made in files with --fix option.",
-        nargs="*",
-        action="append",
-        default=[["__all_files__"]],
+        '--dry',
+        help='Show changes which would be made in files with --fix option.',
+        nargs='*',
+        action='append',
+        default=[['__all_files__']],
         type=str,
     )
     parser.add_argument(
-        "--exclude",
-        help="Filenames (or path expressions), which will be completely skipped without being analysed.",
-        nargs="*",
-        action="append",
+        '--exclude',
+        help='Filenames (or path expressions), which will be completely skipped without being analysed.',
+        nargs='*',
+        action='append',
         default=[],
         type=str,
     )
     parser.add_argument(
-        "--ignore-names",
+        '--ignore-names',
         help=(
-            "Removes provided list of names from the output. "
-            "Regexp expressions to match multiple names can also be provided."
+            'Removes provided list of names from the output. '
+            'Regexp expressions to match multiple names can also be provided.'
         ),
-        nargs="*",
-        action="append",
+        nargs='*',
+        action='append',
         default=[],
         type=str,
     )
     parser.add_argument(
-        "--ignore-bodies-of",
-        help="Ignores body of an expression if its name matches any of the provided names.",
-        nargs="*",
-        action="append",
+        '--ignore-bodies-of',
+        help='Ignores body of an expression if its name matches any of the provided names.',
+        nargs='*',
+        action='append',
         default=[],
         type=str,
     )
     parser.add_argument(
-        "--ignore-bodies-if-decorated-with",
-        help="Ignores body of an expression if its decorated with one of the provided decorator names.",
-        nargs="*",
-        action="append",
+        '--ignore-bodies-if-decorated-with',
+        help='Ignores body of an expression if its decorated with one of the provided decorator names.',
+        nargs='*',
+        action='append',
         default=[],
         type=str,
     )
     parser.add_argument(
-        "--ignore-bodies-if-inherits-from",
-        help="Ignores body of a class if it inherits from any of the provided class names.",
-        nargs="*",
-        action="append",
+        '--ignore-bodies-if-inherits-from',
+        help='Ignores body of a class if it inherits from any of the provided class names.',
+        nargs='*',
+        action='append',
         default=[],
         type=str,
     )
     parser.add_argument(
-        "--ignore-definitions",
+        '--ignore-definitions',
         help=(
-            "Ignores definition (including name and body) if a "
-            "name of an expression matches any of the provided ones."
+            'Ignores definition (including name and body) if a '
+            'name of an expression matches any of the provided ones.'
         ),
-        nargs="*",
-        action="append",
+        nargs='*',
+        action='append',
         default=[],
         type=str,
     )
     parser.add_argument(
-        "--ignore-definitions-if-inherits-from",
+        '--ignore-definitions-if-inherits-from',
         help=(
-            "Ignores definition (including name and body) of a class if "
-            "it inherits from any of the provided class names."
+            'Ignores definition (including name and body) of a class if '
+            'it inherits from any of the provided class names.'
         ),
-        nargs="*",
-        action="append",
+        nargs='*',
+        action='append',
         default=[],
         type=str,
     )
     parser.add_argument(
-        "--ignore-definitions-if-decorated-with",
+        '--ignore-definitions-if-decorated-with',
         help=(
-            "Ignores definition (including name and body) of an expression, "
-            "which is decorated with any of the provided decorator names."
+            'Ignores definition (including name and body) of an expression, '
+            'which is decorated with any of the provided decorator names.'
         ),
-        nargs="*",
-        action="append",
+        nargs='*',
+        action='append',
         default=[],
         type=str,
     )
 
     parser.add_argument(
-        "--ignore-if-decorated-with",
-        help="Ignores both the name and its definition if its decorated with one of the provided decorator names.",
-        nargs="*",
-        action="append",
+        '--ignore-if-decorated-with',
+        help='Ignores both the name and its definition if its decorated with one of the provided decorator names.',
+        nargs='*',
+        action='append',
         default=[],
         type=str,
     )
     parser.add_argument(
-        "--ignore-if-inherits-from",
-        help="Ignores both the name and its definition if the class inerits from the provided class name.",
-        nargs="*",
-        action="append",
+        '--ignore-if-inherits-from',
+        help='Ignores both the name and its definition if the class inerits from the provided class name.',
+        nargs='*',
+        action='append',
         default=[],
         type=str,
     )
 
     parser.add_argument(
-        "--ignore-names-if-inherits-from",
-        help="Ignores names of classes, which inherit from provided class names.",
-        nargs="*",
-        action="append",
+        '--ignore-names-if-inherits-from',
+        help='Ignores names of classes, which inherit from provided class names.',
+        nargs='*',
+        action='append',
         default=[],
         type=str,
     )
     parser.add_argument(
-        "--ignore-names-if-decorated-with",
-        help="Ignores names of an expression, which is decorated with one of the provided decorator names.",
-        nargs="*",
-        action="append",
+        '--ignore-names-if-decorated-with',
+        help='Ignores names of an expression, which is decorated with one of the provided decorator names.',
+        nargs='*',
+        action='append',
         default=[],
         type=str,
     )
 
     parser.add_argument(
-        "--ignore-names-in-files",
-        help="Ignores unused names in files, which filenames match provided path expressions.",
-        nargs="*",
-        action="append",
+        '--ignore-names-in-files',
+        help='Ignores unused names in files, which filenames match provided path expressions.',
+        nargs='*',
+        action='append',
         default=[],
         type=str,
     )
 
     parser.add_argument(
-        "--no-color",
-        help="Turn off colors in the output",
-        action="store_true",
+        '--no-color',
+        help='Turn off colors in the output',
+        action='store_true',
         default=False,
     )
 
     parser.add_argument(
-        "--quiet",
-        help="Does not output anything. Makefile still fails with exit code 1 if unused names are found.",
-        action="store_true",
+        '--quiet',
+        help='Does not output anything. Makefile still fails with exit code 1 if unused names are found.',
+        action='store_true',
         default=False,
     )
 
     parser.add_argument(
-        "--count",
-        help="Provides the count of the detected unused names instead of printing them all out.",
-        action="store_true",
+        '--count',
+        help='Provides the count of the detected unused names instead of printing them all out.',
+        action='store_true',
         default=False,
     )
     parser.add_argument(
-        "-v",
-        "--verbose",
-        help="Shows logs useful for debuging",
-        action="store_true",
+        '-v',
+        '--verbose',
+        help='Shows logs useful for debuging',
+        action='store_true',
         default=False,
     )
 
     parsed_args = parser.parse_args(args).__dict__
 
     for arg_name, arg_value in parsed_args.items():
-        if isinstance(arg_value, list) and arg_name != "paths":
+        if isinstance(arg_value, list) and arg_name != 'paths':
             parsed_args[arg_name] = flatten_lists_of_comma_separated_values(parsed_args.get(arg_name))
 
     # Extend the Args with the values provided in the pyproject.toml
@@ -201,12 +201,12 @@ def parse_arguments(args: Optional[List[str]]) -> Args:
             parsed_args[key].extend(item)
 
     # Show changes for only provided files instead of all
-    if len(parsed_args["dry"]) > 1 or "--dry" not in args:
-        parsed_args["dry"].remove("__all_files__")
+    if len(parsed_args['dry']) > 1 or '--dry' not in args:
+        parsed_args['dry'].remove('__all_files__')
 
     # Do not fix if dry option is provided:
-    if parsed_args["dry"]:
-        parsed_args["fix"] = False
+    if parsed_args['dry']:
+        parsed_args['fix'] = False
 
     return Args(**parsed_args)
 
@@ -217,13 +217,13 @@ def parse_pyproject_toml() -> Dict[str, Any]:
     If parsing fails, will raise a tomllib.TOMLDecodeError.
     Copied from: https://github.com/psf/black/blob/01b8d3d4095ebdb91d0d39012a517931625c63cb/src/black/files.py#LL113C15-L113C15
     """
-    pyproject_toml_filename = "pyproject.toml"
+    pyproject_toml_filename = 'pyproject.toml'
     if not os.path.isfile(pyproject_toml_filename):
         return {}
 
-    with open(pyproject_toml_filename, "rb") as f:
+    with open(pyproject_toml_filename, 'rb') as f:
         pyproject_toml = tomllib.load(f)
 
-    config: Dict[str, Any] = pyproject_toml.get("tool", {}).get("deadcode", {})
-    config = {k.replace("--", "").replace("-", "_"): v for k, v in config.items()}
+    config: Dict[str, Any] = pyproject_toml.get('tool', {}).get('deadcode', {})
+    config = {k.replace('--', '').replace('-', '_'): v for k, v in config.items()}
     return config