dmyersturnbull /
pocketutils
| Total Complexity | 41 |
| Total Lines | 251 |
| Duplicated Lines | 0 % |
| Changes | 0 | ||
Complex classes like pocketutils.tools.path_tools often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
| 1 | import sys |
||
|
introduced
by
|
|||
| 2 | from typing import Callable, Optional, Sequence |
||
| 3 | |||
| 4 | import regex |
||
| 5 | |||
| 6 | from pocketutils.core.exceptions import * |
||
|
|
|||
| 7 | from pocketutils.tools.base_tools import BaseTools |
||
| 8 | |||
| 9 | logger = logging.getLogger("pocketutils") |
||
| 10 | |||
| 11 | |||
| 12 | class PathTools(BaseTools): |
||
| 13 | @classmethod |
||
| 14 | def updir(cls, n: int, *parts) -> Path: |
||
| 15 | """ |
||
| 16 | Get an absolute path ``n`` parents from ``os.getcwd()``. |
||
| 17 | Does not sanitize. |
||
| 18 | |||
| 19 | Ex: In dir '/home/john/dir_a/dir_b': |
||
| 20 | updir(2, 'dir1', 'dir2') # returns Path('/home/john/dir1/dir2') |
||
| 21 | """ |
||
| 22 | base = Path(os.getcwd()) |
||
| 23 | for _ in range(n): |
||
| 24 | base = base.parent |
||
| 25 | for part in parts: |
||
| 26 | base = base / part |
||
| 27 | return base.resolve() |
||
| 28 | |||
| 29 | @classmethod |
||
| 30 | def guess_trash(cls) -> Path: |
||
| 31 | """ |
||
| 32 | Chooses a reasonable path for trash based on the OS. |
||
| 33 | This is not reliable. For a more sophisticated solution, |
||
| 34 | see https://github.com/hsoft/send2trash |
||
| 35 | However, even that can fail. |
||
| 36 | """ |
||
| 37 | plat = sys.platform.lower() |
||
| 38 | if "darwin" in plat: |
||
| 39 | return Path.home() / ".Trash" |
||
| 40 | elif "win" in plat: |
||
| 41 | return Path(Path.home().root) / "$Recycle.Bin" |
||
| 42 | else: |
||
| 43 | return Path.home() / ".trash" |
||
| 44 | |||
| 45 | @classmethod |
||
| 46 | def sanitize_path( |
||
| 47 | cls, |
||
| 48 | path: PathLike, |
||
| 49 | *, |
||
| 50 | is_file: Optional[bool] = None, |
||
| 51 | fat: bool = False, |
||
| 52 | trim: bool = False, |
||
| 53 | warn: Union[bool, Callable[[str], Any]] = True, |
||
| 54 | ) -> Path: |
||
| 55 | r""" |
||
| 56 | Sanitizes a path for major OSes and filesystems. |
||
| 57 | Also see sanitize_path_nodes and sanitize_path_node. |
||
| 58 | Mostly platform-independent. |
||
| 59 | |||
| 60 | The idea is to sanitize for both Windows and Posix, regardless of the platform in use. |
||
| 61 | The sanitization should be as uniform as possible for both platforms. |
||
| 62 | This works for at least Windows+NTFS. |
||
| 63 | Tilde substitution for long filenames in Windows is unsupported. |
||
| 64 | |||
| 65 | A corner case is drive letters in Linux: |
||
| 66 | "C:\\Users\\john" is converted to '/C:/users/john' if os.name=='posix' |
||
| 67 | """ |
||
| 68 | w = {True: logger.warning, False: lambda _: None}.get(warn, warn) |
||
| 69 | path = str(path) |
||
| 70 | if path.startswith("\\\\?"): |
||
| 71 | raise IllegalPathError( |
||
| 72 | f"Long UNC Windows paths (\\\\? prefix) are not supported (path '{path}')" |
||
| 73 | ) |
||
| 74 | bits = str(path).strip().replace("\\", "/").split("/") |
||
| 75 | new_nodes = list(cls.sanitize_nodes(bits, is_file=is_file, fat=fat, trim=trim)) |
||
| 76 | # unfortunately POSIX turns Path('C:\', '5') into C:\/5 |
||
| 77 | # this isn't an ideal way to fix it, but it works |
||
| 78 | pat = regex.compile(r"^([A-Z]:)(?:\\)?$", flags=regex.V1) |
||
| 79 | if os.name == "posix" and len(new_nodes) > 0 and pat.fullmatch(new_nodes[0]): |
||
| 80 | new_nodes[0] = new_nodes[0].rstrip("\\") |
||
| 81 | new_nodes.insert(0, "/") |
||
| 82 | new_path = Path(*new_nodes) |
||
| 83 | if new_path != path: |
||
| 84 | w(f"Sanitized filename {path} → {new_path}") |
||
| 85 | return Path(new_path) |
||
| 86 | |||
| 87 | @classmethod |
||
| 88 | def sanitize_nodes( |
||
| 89 | cls, |
||
| 90 | bits: Sequence[PathLike], |
||
| 91 | *, |
||
| 92 | is_file: Optional[bool] = None, |
||
| 93 | fat: bool = False, |
||
| 94 | trim: bool = False, |
||
| 95 | ) -> Sequence[str]: |
||
| 96 | fixed_bits = [ |
||
| 97 | bit + os.sep |
||
| 98 | if i == 0 and bit.strip() in ["", ".", ".."] |
||
| 99 | else cls.sanitize_node( |
||
| 100 | bit, |
||
| 101 | is_file=(False if i < len(bits) - 1 else is_file), |
||
| 102 | trim=trim, |
||
| 103 | fat=fat, |
||
| 104 | is_root_or_drive=(None if i == 0 else False), |
||
| 105 | ) |
||
| 106 | for i, bit in enumerate(bits) |
||
| 107 | if bit.strip() not in ["", "."] |
||
| 108 | or i == 0 # ignore // (empty) just like Path does (but fail on sanitize_path_node(' ')) |
||
| 109 | ] |
||
| 110 | return [bit for i, bit in enumerate(fixed_bits) if i == 0 or bit not in ["", "."]] |
||
| 111 | |||
| 112 | @classmethod |
||
| 113 | def sanitize_node( |
||
| 114 | cls, |
||
| 115 | bit: PathLike, |
||
| 116 | *, |
||
| 117 | is_file: Optional[bool] = None, |
||
| 118 | is_root_or_drive: Optional[bool] = None, |
||
| 119 | fat: bool = False, |
||
| 120 | trim: bool = False, |
||
| 121 | ) -> str: |
||
| 122 | r""" |
||
| 123 | Sanitizes a path node such that it will be fine for major OSes and filesystems. |
||
| 124 | For example: |
||
| 125 | - 'plums;and/or;apples' becomes 'plums_and_or_apples' (escaped ; and /) |
||
| 126 | - 'null.txt' becomes '_null_.txt' ('null' is forbidden in Windows) |
||
| 127 | - 'abc ' becomes 'abc' (no trailing spaces) |
||
| 128 | The behavior is platform-independent -- os, sys, and pathlib are not used. |
||
| 129 | For ex, calling sanitize_path_node(r'C:\') returns r'C:\' on both Windows and Linux |
||
| 130 | If you want to sanitize a whole path, see sanitize_path instead. |
||
| 131 | |||
| 132 | Args: |
||
| 133 | bit: The node |
||
| 134 | is_file: False for directories, True otherwise, None if unknown |
||
| 135 | is_root_or_drive: True if known to be the root ('/') or a drive ('C:\'), None if unknown |
||
| 136 | fat: Also make compatible with FAT filesystems |
||
| 137 | trim: Truncate to 254 chars (otherwise fails) |
||
| 138 | |||
| 139 | Returns: |
||
| 140 | A string |
||
| 141 | """ |
||
| 142 | # since is_file and is_root_or_drive are both Optional[bool], let's be explicit and use 'is' for clarity |
||
| 143 | if is_file is True and is_root_or_drive is True: |
||
| 144 | raise ContradictoryRequestError("is_file and is_root_or_drive are both true") |
||
| 145 | if is_file is True and is_root_or_drive is None: |
||
| 146 | is_root_or_drive = False |
||
| 147 | if is_root_or_drive is True and is_file is None: |
||
| 148 | is_file = False |
||
| 149 | source_bit = copy(str(bit)) |
||
| 150 | bit = str(bit).strip() |
||
| 151 | # first, catch root or drive as long as is_root_or_drive is not false |
||
| 152 | # if is_root_or_drive is True (which is a weird call), then fail if it's not |
||
| 153 | # otherwise, it's not a root or drive letter, so keep going |
||
| 154 | if is_root_or_drive is not False: |
||
| 155 | # \ is allowed in Windows |
||
| 156 | if bit in ["/", "\\"]: |
||
| 157 | return bit |
||
| 158 | m = regex.compile(r"^([A-Z]:)(?:\\)?$", flags=regex.V1).fullmatch(bit) |
||
| 159 | # this is interesting |
||
| 160 | # for bit=='C:' and is_root_or_drive=None, |
||
| 161 | # it could be either a drive letter |
||
| 162 | # or a file path that should be corrected to 'C_' |
||
| 163 | # I guess here we're going with a drive letter |
||
| 164 | if m is not None: |
||
| 165 | # we need C:\ and not C: because: |
||
| 166 | # Path('C:\\', '5').is_absolute() is True |
||
| 167 | # but Path('C:', '5').is_absolute() is False |
||
| 168 | # unfortunately, doing Path('C:\\', '5') on Linux gives 'C:\\/5' |
||
| 169 | # I can't handle that here, but sanitize_path() will account for it |
||
| 170 | return m.group(1) + "\\" |
||
| 171 | if is_root_or_drive is True: |
||
| 172 | raise IllegalPathError(f"Node '{bit}' is not the root or a drive letter") |
||
| 173 | # note that we can't call WindowsPath.is_reserved because it can't be instantiated on non-Linux |
||
| 174 | # also, these appear to be different from the ones defined there |
||
| 175 | bad_chars = { |
||
| 176 | "<", |
||
| 177 | ">", |
||
| 178 | ":", |
||
| 179 | '"', |
||
| 180 | "|", |
||
| 181 | "?", |
||
| 182 | "*", |
||
| 183 | "\\", |
||
| 184 | "/", |
||
| 185 | *{chr(c) for c in range(128, 128 + 33)}, |
||
| 186 | *{chr(c) for c in range(0, 32)}, |
||
| 187 | "\t", |
||
| 188 | } |
||
| 189 | # don't handle Long UNC paths |
||
| 190 | # also cannot be blank or whitespace |
||
| 191 | # the $ suffixed ones are for FAT |
||
| 192 | # no CLOCK$, even with an ext |
||
| 193 | # also no SCREEN$ |
||
| 194 | bad_strs = { |
||
| 195 | "CON", |
||
| 196 | "PRN", |
||
| 197 | "AUX", |
||
| 198 | "NUL", |
||
| 199 | "COM1", |
||
| 200 | "COM2", |
||
| 201 | "COM3", |
||
| 202 | "COM4", |
||
| 203 | "COM5", |
||
| 204 | "COM6", |
||
| 205 | "COM7", |
||
| 206 | "COM8", |
||
| 207 | "COM9", |
||
| 208 | "LPT1", |
||
| 209 | "LPT2", |
||
| 210 | "LPT3", |
||
| 211 | "LPT4", |
||
| 212 | "LPT5", |
||
| 213 | "LPT6", |
||
| 214 | "LPT7", |
||
| 215 | "LPT8", |
||
| 216 | "LPT9", |
||
| 217 | } |
||
| 218 | if fat: |
||
| 219 | bad_strs += {"$IDLE$", "CONFIG$", "KEYBD$", "SCREEN$", "CLOCK$", "LST"} |
||
| 220 | # just dots is invalid |
||
| 221 | if set(bit.replace(" ", "")) == "." and bit not in ["..", "."]: |
||
| 222 | bit = "_" + bit + "_" |
||
| 223 | # raise IllegalPathError(f"Node '{source_bit}' is invalid") |
||
| 224 | for q in bad_chars: |
||
| 225 | bit = bit.replace(q, "_") |
||
| 226 | if bit.upper() in bad_strs: |
||
| 227 | # arbitrary decision |
||
| 228 | bit = "_" + bit + "_" |
||
| 229 | else: |
||
| 230 | stub, ext = os.path.splitext(bit) |
||
| 231 | if stub.upper() in bad_strs: |
||
| 232 | bit = "_" + stub + "_" + ext |
||
| 233 | if bit.strip() == "": |
||
| 234 | bit = "_" + bit + "_" |
||
| 235 | # raise IllegalPathError(f"Node '{source_bit}' is empty or contains only whitespace") |
||
| 236 | # "." cannot end a node |
||
| 237 | bit = bit.rstrip() |
||
| 238 | if is_file is not True and (bit == "." or bit == ".."): |
||
| 239 | return bit |
||
| 240 | # never allow '.' or ' ' to end a filename |
||
| 241 | bit = bit.rstrip(". ") |
||
| 242 | # do this after |
||
| 243 | if len(bit) > 254 and trim: |
||
| 244 | bit = bit[:254] |
||
| 245 | elif len(bit) > 254: |
||
| 246 | raise IllegalPathError(f"Node '{source_bit}' has more than 254 characters") |
||
| 247 | return bit |
||
| 248 | |||
| 249 | |||
| 250 | __all__ = ["PathTools"] |
||
| 251 |
Loading history...