pyclean.modern.remove_file() - Code Metrics - Inspection of "[WIP] Fix handling of complex directory names with..." - bittner/pyclean - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — main (#93)

unknown

created 2025-10-15 15:54 UTC

pyclean.modern.remove_file() A

↳ Parent: pyclean.modern

Complexity

Conditions

Size

Total Lines	9
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	8
nop	1
dl	0
loc	9
rs	10
c	0
b	0
f	0

# SPDX-FileCopyrightText: 2020 Peter Bittner <[email protected]>
#
# SPDX-License-Identifier: GPL-3.0-or-later

"""
Modern, cross-platform, pure-Python pyclean implementation.
"""

import logging
import os
from pathlib import Path

BYTECODE_FILES = ['.pyc', '.pyo']
BYTECODE_DIRS = ['__pycache__']
DEBRIS_TOPICS = {
    'cache': [
        '.cache/**/*',
        '.cache/',
    ],
    'coverage': [
        '.coverage',
        'coverage.json',
        'coverage.lcov',
        'coverage.xml',
        'htmlcov/**/*',
        'htmlcov/',
    ],
    'jupyter': [
        '.ipynb_checkpoints/**/*',
        '.ipynb_checkpoints/',
    ],
    'mypy': [
        '.mypy_cache/**/*',
        '.mypy_cache/',
    ],
    'package': [
        'build/bdist.*/**/*',
        'build/bdist.*/',
        'build/lib/**/*',
        'build/lib/',
        'build/',
        'dist/**/*',
        'dist/',
        'sdist/**/*',
        'sdist/',
        '*.egg-info/**/*',
        '*.egg-info/',
    ],
    'pytest': [
        '.pytest_cache/**/*',
        '.pytest_cache/',
        'pytestdebug.log',
    ],
    'ruff': [
        '.ruff_cache/**/*',
        '.ruff_cache/',
    ],
    'tox': [
        '.tox/**/*',
        '.tox/',
    ],
}


class CleanupRunner:
    """Module-level configuration and value store."""

    def __init__(self):
        """Cleanup runner with optional dry-run behavior."""
        self.unlink = None
        self.rmdir = None
        self.ignore = None
        self.unlink_count = None
        self.unlink_failed = None
        self.rmdir_count = None
        self.rmdir_failed = None

    def configure(self, args):
        """Set up runner according to command line options."""
        self.unlink = print_filename if args.dry_run else remove_file
        self.rmdir = print_dirname if args.dry_run else remove_directory
        self.ignore = args.ignore
        self.unlink_count = 0
        self.unlink_failed = 0
        self.rmdir_count = 0
        self.rmdir_failed = 0


log = logging.getLogger(__name__)
Runner = CleanupRunner()


def should_ignore(path, ignore_patterns):
    """
    Check if a path should be ignored based on ignore patterns.
    
    Patterns can be:
    - Simple names like 'bar': matches any directory with that name
    - Paths like 'foo/bar': matches 'bar' directory inside 'foo' directory
    
    Args:
        path: Path object to check
        ignore_patterns: List of ignore patterns
        
    Returns:
        True if the path should be ignored, False otherwise
    """
    if ignore_patterns is None:
        return False
    if not ignore_patterns:
        return False
        
    for pattern in ignore_patterns:
        if '/' in pattern:
            # Pattern contains path separator - match relative path
            # We need to check if the path ends with this pattern
            try:
                # Get parts from the pattern
                pattern_parts = Path(pattern).parts
                # Path must have at least as many parts as the pattern
                if len(path.parts) < len(pattern_parts):
                    continue
                # Get the trailing parts of the path that match the pattern length
                path_parts = path.parts[-len(pattern_parts):]
                if path_parts == pattern_parts:
                    return True
            except (ValueError, IndexError):
                continue
        else:
            # Simple name - match the directory name anywhere
            if path.name == pattern:
                return True
    return False


def remove_file(fileobj):
    """Attempt to delete a file object for real."""
    log.debug('Deleting file: %s', fileobj)
    try:
        fileobj.unlink()
        Runner.unlink_count += 1
    except OSError as err:
        log.debug('File not deleted. %s', err)
        Runner.unlink_failed += 1


def remove_directory(dirobj):
    """Attempt to remove a directory object for real."""
    log.debug('Removing directory: %s', dirobj)
    try:
        dirobj.rmdir()
        Runner.rmdir_count += 1
    except OSError as err:
        log.debug('Directory not removed. %s', err)
        Runner.rmdir_failed += 1


def print_filename(fileobj):
    """Only display the file name, used with --dry-run."""
    log.debug('Would delete file: %s', fileobj)
    Runner.unlink_count += 1


def print_dirname(dirobj):
    """Only display the directory name, used with --dry-run."""
    log.debug('Would delete directory: %s', dirobj)
    Runner.rmdir_count += 1


def pyclean(args):
    """Cross-platform cleaning of Python bytecode."""
    Runner.configure(args)

    for dir_name in args.directory:
        dir_path = Path(dir_name)

        log.info('Cleaning directory %s', dir_path)
        descend_and_clean(dir_path, BYTECODE_FILES, BYTECODE_DIRS)

        for topic in args.debris:
            remove_debris_for(topic, dir_path)

        remove_freeform_targets(args.erase, args.yes, dir_path)

    log.info(
        'Total %d files, %d directories %s.',
        Runner.unlink_count,
        Runner.rmdir_count,
        'would be removed' if args.dry_run else 'removed',
    )

    if Runner.unlink_failed or Runner.rmdir_failed:
        log.debug(
            '%d files, %d directories %s not be removed.',
            Runner.unlink_failed,
            Runner.rmdir_failed,
            'would' if args.dry_run else 'could',
        )


def descend_and_clean(directory, file_types, dir_names):
    """
    Walk and descend a directory tree, cleaning up files of a certain type
    along the way. Only delete directories if they are empty, in the end.
    """
    for child in sorted(directory.iterdir()):
        if child.is_file():
            if child.suffix in file_types:
                Runner.unlink(child)
        elif child.is_dir():
            if should_ignore(child, Runner.ignore):
                log.debug('Skipping %s', child)
            else:
                descend_and_clean(child, file_types, dir_names)

            if child.name in dir_names:
                Runner.rmdir(child)
        else:
            log.debug('Ignoring %s (neither a file nor a folder)', child)


def remove_debris_for(topic, directory):
    """
    Clean up debris for a specific topic.
    """
    log.debug('Scanning for debris of %s ...', topic.title())

    for path_glob in DEBRIS_TOPICS[topic]:
        delete_filesystem_objects(directory, path_glob, recursive=True)


def remove_freeform_targets(glob_patterns, yes, directory):
    """
    Remove free-form targets using globbing.

    This is **potentially dangerous** since users can delete everything
    anywhere in their file system, including the entire project they're
    working on. For this reason, the implementation imposes the following
    (user experience-related) restrictions:

    - Deleting (directories) is not recursive, directory contents must be
      explicitly specified using globbing (e.g. ``dirname/**/*``).
    - The user is responsible for the deletion order, so that a directory
      is empty when it is attempted to be deleted.
    - A confirmation prompt for the deletion of every single file system
      object is shown (unless the ``--yes`` option is used, in addition).
    """
    for path_glob in glob_patterns:
        log.debug('Erase file system objects matching: %s', path_glob)
        delete_filesystem_objects(directory, path_glob, prompt=not yes)


def delete_filesystem_objects(directory, path_glob, prompt=False, recursive=False):
    """
    Identifies all pathnames matching a specific glob pattern, and attempts
    to delete them in the proper order, optionally asking for confirmation.

    Implementation Note: We sort the file system objects in *reverse order*
    and first delete *all files* before removing directories. This way we
    make sure that the directories that are deepest down in the hierarchy
    are empty (for both files & directories) when we attempt to remove them.
    """
    all_names = sorted(directory.glob(path_glob), reverse=True)
    dirs = (name for name in all_names if name.is_dir() and not name.is_symlink())

    files = (name for name in all_names if not name.is_dir() or name.is_symlink())

    for file_object in files:
        file_type = 'symlink' if file_object.is_symlink() else 'file'
        if prompt and not confirm('Delete %s %s' % (file_type, file_object)):
            Runner.unlink_failed += 1
            continue
        Runner.unlink(file_object)

    for dir_object in dirs:
        if prompt and not confirm('Remove empty directory %s' % dir_object):
            Runner.rmdir_failed += 1
            continue
        Runner.rmdir(dir_object)

    if recursive:
        subdirs = (Path(name.path) for name in os.scandir(directory) if name.is_dir())
        for subdir in subdirs:
            if should_ignore(subdir, Runner.ignore):
                log.debug('Skipping %s', subdir)
            else:
                delete_filesystem_objects(subdir, path_glob, prompt, recursive)


def confirm(message):
    """An interactive confirmation prompt."""
    try:
        answer = input('%s? ' % message)
        return answer.strip().lower() in ['y', 'yes']
    except KeyboardInterrupt:
        msg = 'Aborted by user.'
        raise SystemExit(msg)


1			# SPDX-FileCopyrightText: 2020 Peter Bittner <[email protected]>
2			#
3			# SPDX-License-Identifier: GPL-3.0-or-later
4
5			"""
6			Modern, cross-platform, pure-Python pyclean implementation.
7			"""
8
9			import logging
10			import os
11			from pathlib import Path
12
13			BYTECODE_FILES = ['.pyc', '.pyo']
14			BYTECODE_DIRS = ['__pycache__']
15			DEBRIS_TOPICS = {
16			'cache': [
17			'.cache/*/',
18			'.cache/',
19			],
20			'coverage': [
21			'.coverage',
22			'coverage.json',
23			'coverage.lcov',
24			'coverage.xml',
25			'htmlcov/*/',
26			'htmlcov/',
27			],
28			'jupyter': [
29			'.ipynb_checkpoints/*/',
30			'.ipynb_checkpoints/',
31			],
32			'mypy': [
33			'.mypy_cache/*/',
34			'.mypy_cache/',
35			],
36			'package': [
37			'build/bdist.//',
38			'build/bdist.*/',
39			'build/lib/*/',
40			'build/lib/',
41			'build/',
42			'dist/*/',
43			'dist/',
44			'sdist/*/',
45			'sdist/',
46			'.egg-info//',
47			'*.egg-info/',
48			],
49			'pytest': [
50			'.pytest_cache/*/',
51			'.pytest_cache/',
52			'pytestdebug.log',
53			],
54			'ruff': [
55			'.ruff_cache/*/',
56			'.ruff_cache/',
57			],
58			'tox': [
59			'.tox/*/',
60			'.tox/',
61			],
62			}
63
64
65			class CleanupRunner:
66			"""Module-level configuration and value store."""
67
68			def __init__(self):
69			"""Cleanup runner with optional dry-run behavior."""
70			self.unlink = None
71			self.rmdir = None
72			self.ignore = None
73			self.unlink_count = None
74			self.unlink_failed = None
75			self.rmdir_count = None
76			self.rmdir_failed = None
77
78			def configure(self, args):
79			"""Set up runner according to command line options."""
80			self.unlink = print_filename if args.dry_run else remove_file
81			self.rmdir = print_dirname if args.dry_run else remove_directory
82			self.ignore = args.ignore
83			self.unlink_count = 0
84			self.unlink_failed = 0
85			self.rmdir_count = 0
86			self.rmdir_failed = 0
87
88
89			log = logging.getLogger(__name__)
90			Runner = CleanupRunner()
91
92
93			def should_ignore(path, ignore_patterns):
94			"""
95			Check if a path should be ignored based on ignore patterns.
96
97			Patterns can be:
98			- Simple names like 'bar': matches any directory with that name
99			- Paths like 'foo/bar': matches 'bar' directory inside 'foo' directory
100
101			Args:
102			path: Path object to check
103			ignore_patterns: List of ignore patterns
104
105			Returns:
106			True if the path should be ignored, False otherwise
107			"""
108			if ignore_patterns is None:
109			return False
110			if not ignore_patterns:
111			return False
112
113			for pattern in ignore_patterns:
114			if '/' in pattern:
115			# Pattern contains path separator - match relative path
116			# We need to check if the path ends with this pattern
117			try:
118			# Get parts from the pattern
119			pattern_parts = Path(pattern).parts
120			# Path must have at least as many parts as the pattern
121			if len(path.parts) < len(pattern_parts):
122			continue
123			# Get the trailing parts of the path that match the pattern length
124			path_parts = path.parts[-len(pattern_parts):]
125			if path_parts == pattern_parts:
126			return True
127			except (ValueError, IndexError):
128			continue
129			else:
130			# Simple name - match the directory name anywhere
131			if path.name == pattern:
132			return True
133			return False
134
135
136			def remove_file(fileobj):
137			"""Attempt to delete a file object for real."""
138			log.debug('Deleting file: %s', fileobj)
139			try:
140			fileobj.unlink()
141			Runner.unlink_count += 1
142			except OSError as err:
143			log.debug('File not deleted. %s', err)
144			Runner.unlink_failed += 1
145
146
147			def remove_directory(dirobj):
148			"""Attempt to remove a directory object for real."""
149			log.debug('Removing directory: %s', dirobj)
150			try:
151			dirobj.rmdir()
152			Runner.rmdir_count += 1
153			except OSError as err:
154			log.debug('Directory not removed. %s', err)
155			Runner.rmdir_failed += 1
156
157
158			def print_filename(fileobj):
159			"""Only display the file name, used with --dry-run."""
160			log.debug('Would delete file: %s', fileobj)
161			Runner.unlink_count += 1
162
163
164			def print_dirname(dirobj):
165			"""Only display the directory name, used with --dry-run."""
166			log.debug('Would delete directory: %s', dirobj)
167			Runner.rmdir_count += 1
168
169
170			def pyclean(args):
171			"""Cross-platform cleaning of Python bytecode."""
172			Runner.configure(args)
173
174			for dir_name in args.directory:
175			dir_path = Path(dir_name)
176
177			log.info('Cleaning directory %s', dir_path)
178			descend_and_clean(dir_path, BYTECODE_FILES, BYTECODE_DIRS)
179
180			for topic in args.debris:
181			remove_debris_for(topic, dir_path)
182
183			remove_freeform_targets(args.erase, args.yes, dir_path)
184
185			log.info(
186			'Total %d files, %d directories %s.',
187			Runner.unlink_count,
188			Runner.rmdir_count,
189			'would be removed' if args.dry_run else 'removed',
190			)
191
192			if Runner.unlink_failed or Runner.rmdir_failed:
193			log.debug(
194			'%d files, %d directories %s not be removed.',
195			Runner.unlink_failed,
196			Runner.rmdir_failed,
197			'would' if args.dry_run else 'could',
198			)
199
200
201			def descend_and_clean(directory, file_types, dir_names):
202			"""
203			Walk and descend a directory tree, cleaning up files of a certain type
204			along the way. Only delete directories if they are empty, in the end.
205			"""
206			for child in sorted(directory.iterdir()):
207			if child.is_file():
208			if child.suffix in file_types:
209			Runner.unlink(child)
210			elif child.is_dir():
211			if should_ignore(child, Runner.ignore):
212			log.debug('Skipping %s', child)
213			else:
214			descend_and_clean(child, file_types, dir_names)
215
216			if child.name in dir_names:
217			Runner.rmdir(child)
218			else:
219			log.debug('Ignoring %s (neither a file nor a folder)', child)
220
221
222			def remove_debris_for(topic, directory):
223			"""
224			Clean up debris for a specific topic.
225			"""
226			log.debug('Scanning for debris of %s ...', topic.title())
227
228			for path_glob in DEBRIS_TOPICS[topic]:
229			delete_filesystem_objects(directory, path_glob, recursive=True)
230
231
232			def remove_freeform_targets(glob_patterns, yes, directory):
233			"""
234			Remove free-form targets using globbing.
235
236			This is potentially dangerous since users can delete everything
237			anywhere in their file system, including the entire project they're
238			working on. For this reason, the implementation imposes the following
239			(user experience-related) restrictions:
240
241			- Deleting (directories) is not recursive, directory contents must be
242			explicitly specified using globbing (e.g. ``dirname/*/``).
243			- The user is responsible for the deletion order, so that a directory
244			is empty when it is attempted to be deleted.
245			- A confirmation prompt for the deletion of every single file system
246			object is shown (unless the ``--yes`` option is used, in addition).
247			"""
248			for path_glob in glob_patterns:
249			log.debug('Erase file system objects matching: %s', path_glob)
250			delete_filesystem_objects(directory, path_glob, prompt=not yes)
251
252
253			def delete_filesystem_objects(directory, path_glob, prompt=False, recursive=False):
254			"""
255			Identifies all pathnames matching a specific glob pattern, and attempts
256			to delete them in the proper order, optionally asking for confirmation.
257
258			Implementation Note: We sort the file system objects in reverse order
259			and first delete all files before removing directories. This way we
260			make sure that the directories that are deepest down in the hierarchy
261			are empty (for both files & directories) when we attempt to remove them.
262			"""
263			all_names = sorted(directory.glob(path_glob), reverse=True)
264			dirs = (name for name in all_names if name.is_dir() and not name.is_symlink())
			0 ignored issues – show Comprehensibility Best Practice introduced 2023-01-27 09:22 UTC by Report Bug Copy Issue Report The variable `name` does not seem to be defined. Loading history...
265			files = (name for name in all_names if not name.is_dir() or name.is_symlink())
266
267			for file_object in files:
268			file_type = 'symlink' if file_object.is_symlink() else 'file'
269			if prompt and not confirm('Delete %s %s' % (file_type, file_object)):
270			Runner.unlink_failed += 1
271			continue
272			Runner.unlink(file_object)
273
274			for dir_object in dirs:
275			if prompt and not confirm('Remove empty directory %s' % dir_object):
276			Runner.rmdir_failed += 1
277			continue
278			Runner.rmdir(dir_object)
279
280			if recursive:
281			subdirs = (Path(name.path) for name in os.scandir(directory) if name.is_dir())
282			for subdir in subdirs:
283			if should_ignore(subdir, Runner.ignore):
284			log.debug('Skipping %s', subdir)
285			else:
286			delete_filesystem_objects(subdir, path_glob, prompt, recursive)
287
288
289			def confirm(message):
290			"""An interactive confirmation prompt."""
291			try:
292			answer = input('%s? ' % message)
293			return answer.strip().lower() in ['y', 'yes']
294			except KeyboardInterrupt:
295			msg = 'Aborted by user.'
296			raise SystemExit(msg)
297

bittner / pyclean

Pull Request — main (#93)

pyclean.modern.remove_file() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like