pocketutils.tools.filesys_tools

Complexity

Total Complexity

162

Size/Duplication

Total Lines	724
Duplicated Lines	8.29 %

Importance

Changes

0

32 Methods

Rating	Name	Duplication	Size	Complexity
A	FilesysTools.get_encoding_errors()	0	20	3
B	FilesysTools.tmp_file()	0	17	6
B	FilesysTools.prep_dir()	0	18	6
A	FilesysTools.dt_for_filesys()	0	5	2
A	FilesysTools.dump_error_as_dict()	0	9	2
A	FilesysTools.dump_error()	0	15	3
A	FilesysTools._expire_warning_info()	0	12	2
C	FilesysTools.verify_can_read_files()	30	30	10
B	FilesysTools.open_file()	0	21	7
A	FilesysTools.delete_surefire()	0	31	4
C	FilesysTools.verify_can_write_files()	30	30	10
A	FilesysTools._warn_expired()	0	36	4
B	FilesysTools.write_compressed_text()	0	17	6
A	FilesysTools.trash()	0	14	2
A	FilesysTools.tmp_dir()	0	4	2
D	FilesysTools.read_any()	0	55	12
B	FilesysTools.read_properties_file()	0	31	7
A	FilesysTools.replace_in_file()	0	10	2
A	FilesysTools.write_lines()	0	21	3
A	FilesysTools.__stat_raw()	0	8	4
A	FilesysTools.read_compressed_text()	0	12	5
B	FilesysTools.check_expired()	0	52	8
C	FilesysTools.write_properties_file()	0	31	9
B	FilesysTools.get_encoding()	0	21	8
A	FilesysTools.try_cleanup()	0	11	2
A	FilesysTools.load_json()	0	3	1
A	FilesysTools.save_json()	0	7	3
A	FilesysTools.prep_file()	0	12	4
B	FilesysTools.verify_can_write_dirs()	0	22	8
B	FilesysTools.read_lines_file()	0	13	6
C	FilesysTools.get_info()	0	40	9
A	FilesysTools.tmp_path()	0	12	2

import bz2

Missing module docstring

import csv
import gzip
import logging
import os
import pathlib
import shutil
import stat
import sys
import tempfile
from collections.abc import Callable, Generator, Iterable, Mapping, Sequence
from contextlib import contextmanager
from datetime import datetime, timedelta
from pathlib import Path, PurePath
from typing import Any

import orjson

Unable to import 'orjson'

import regex

Unable to import 'regex'

from defusedxml import ElementTree

Unable to import 'defusedxml'

from pocketutils.core.chars import Chars

The name core does not seem to exist in module pocketutils.

from pocketutils.core.exceptions import (

The name core does not seem to exist in module pocketutils.

    AlreadyUsedError,
    DirDoesNotExistError,
    FileDoesNotExistError,
    ParsingError,
    ReadPermissionsError,
    WritePermissionsError,
)
from pocketutils.core.input_output import OpenMode, PathLike, Writeable

The name core does not seem to exist in module pocketutils.

from pocketutils.tools.path_info import PathInfo
from pocketutils.tools.path_tools import PathTools
from pocketutils.tools.sys_tools import SystemTools
from pocketutils.tools.unit_tools import UnitTools

logger = logging.getLogger("pocketutils")
COMPRESS_LEVEL = 9


class FilesysTools:

Too many public methods (29/20)

    """
    Tools for file/directory creation, etc.

    .. caution::
        Some functions may be insecure.
    """

    def get_encoding(self, encoding: str = "utf-8") -> str:

This method could be written as a function/class method.

        """
        Returns a text encoding from a more flexible string.
        Ignores hyphens and lowercases the string.
        Permits these nonstandard shorthands:

          - ``"platform"``: use ``sys.getdefaultencoding()`` on the fly
          - ``"utf8(bom)"``: use ``"utf-8-sig"`` on Windows; ``"utf-8"`` otherwise
          - ``"utf16(bom)"``: use ``"utf-16-sig"`` on Windows; ``"utf-16"`` otherwise
          - ``"utf32(bom)"``: use ``"utf-32-sig"`` on Windows; ``"utf-32"`` otherwise
        """
        encoding = encoding.lower().replace("-", "")
        if encoding == "platform":
            encoding = sys.getdefaultencoding()
        if encoding == "utf8(bom)":
            encoding = "utf-8-sig" if os.name == "nt" else "utf-8"
        if encoding == "utf16(bom)":
            encoding = "utf-16-sig" if os.name == "nt" else "utf-16"
        if encoding == "utf32(bom)":
            encoding = "utf-32-sig" if os.name == "nt" else "utf-32"
        return encoding

    def get_encoding_errors(self, errors: str | None) -> str | None:

This method could be written as a function/class method.

        """
        Returns the value passed as``errors=`` in ``open``.
        Raises:
            ValueError: If invalid
        """
        if errors is None:
            return "strict"
        if errors in (
            "strict",

Wrong hanging indentation before block (add 4 spaces).

            "ignore",

Wrong hanging indentation before block (add 4 spaces).

            "replace",

Wrong hanging indentation before block (add 4 spaces).

            "xmlcharrefreplace",

Wrong hanging indentation before block (add 4 spaces).

            "backslashreplace",

Wrong hanging indentation before block (add 4 spaces).

            "namereplace",

Wrong hanging indentation before block (add 4 spaces).

            "surrogateescape",

Wrong hanging indentation before block (add 4 spaces).

            "surrogatepass",

Wrong hanging indentation before block (add 4 spaces).

        ):
            return errors
        raise ValueError(f"Invalid value {errors} for errors")

    @classmethod
    def read_compressed_text(cls, path: PathLike) -> str:
        """
        Reads text from a text file, optionally gzipped or bz2-ed.
        Recognized suffixes for compression are ``.gz``, ``.gzip``, ``.bz2``, and ``.bzip2``.
        """
        path = Path(path)
        if path.name.endswith(".bz2") or path.name.endswith(".bzip2"):
            return bz2.decompress(path.read_bytes()).decode(encoding="utf-8")
        if path.name.endswith(".gz") or path.name.endswith(".gzip"):
            return gzip.decompress(path.read_bytes()).decode(encoding="utf-8")
        return Path(path).read_text(encoding="utf-8")

    @classmethod
    def write_compressed_text(cls, txt: str, path: PathLike, *, mkdirs: bool = False) -> None:
        """
        Writes text to a text file, optionally gzipped or bz2-ed.
        Recognized suffixes for compression are ``.gz``, ``.gzip``, ``.bz2``, and ``.bzip2``.
        """
        path = Path(path)
        if mkdirs:
            path.parent.mkdir(parents=True, exist_ok=True)
        if path.name.endswith(".bz2") or path.name.endswith(".bzip2"):
            data = bz2.compress(txt.encode(encoding="utf-8"))
            path.write_bytes(data)
        elif path.name.endswith(".gz") or path.name.endswith(".gzip"):
            data = gzip.compress(txt.encode(encoding="utf-8"))
            path.write_bytes(data)
        else:
            path.write_text(txt)

    @classmethod
    def get_info(

Missing function or method docstring

        cls, path: PathLike, *, expand_user: bool = False, strict: bool = False

Wrong hanging indentation before block (add 4 spaces).

    ) -> PathInfo:
        path = Path(path)
        has_ignore_error = hasattr(pathlib, "_ignore_error")
        if not has_ignore_error:
            logger.debug("No _ignore_error found; some OSErrors may be suppressed")
        resolved = None
        real_stat = None
        has_access = False
        has_read = False
        has_write = False
        link_stat = None
        as_of = datetime.now().astimezone()
        if has_ignore_error or path.is_symlink() or path.exists():
            link_stat = cls.__stat_raw(path)
        if link_stat is not None:
            if expand_user:
                resolved = path.expanduser().resolve(strict=strict)
            else:
                resolved = path.resolve(strict=strict)
            if stat.S_ISLNK(link_stat.st_mode):
                real_stat = cls.__stat_raw(resolved)
            else:
                real_stat = link_stat
            has_access = os.access(path, os.X_OK, follow_symlinks=True)
            has_read = os.access(path, os.R_OK, follow_symlinks=True)
            has_write = os.access(path, os.W_OK, follow_symlinks=True)
            if not stat.S_ISLNK(link_stat.st_mode):
                link_stat = None
        return PathInfo(
            source=path,
            resolved=resolved,
            as_of=as_of,
            real_stat=real_stat,
            link_stat=link_stat,
            has_access=has_access,
            has_read=has_read,
            has_write=has_write,
        )

    @classmethod
    def prep_dir(cls, path: PathLike, *, exist_ok: bool = True) -> bool:
        """
        Prepares a directory by making it if it doesn't exist.
        If exist_ok is False, calls ``logger.warning`` if ``path`` already exists
        """
        path = Path(path)
        exists = path.exists()
        # On some platforms we get generic exceptions like permissions errors,
        # so these are better
        if exists and not path.is_dir():
            raise DirDoesNotExistError(f"Path {path} exists but is not a file")
        if exists and not exist_ok:
            logger.warning(f"Directory {path} already exists")

Use lazy % formatting in logging functions

        if not exists:
            # NOTE! exist_ok in mkdir throws an error on Windows
            path.mkdir(parents=True)
        return exists

    @classmethod
    def prep_file(cls, path: PathLike, *, exist_ok: bool = True) -> None:
        """
        Prepares a file path by making its parent directory.
        Same as ``pathlib.Path.mkdir`` but makes sure ``path`` is a file if it exists.
        """
        # On some platforms we get generic exceptions like permissions errors, so these are better
        path = Path(path)
        # check for errors first; don't make the dirs and then fail
        if path.exists() and not path.is_file() and not path.is_symlink():
            raise FileDoesNotExistError(f"Path {path} exists but is not a file")
        Path(path.parent).mkdir(parents=True, exist_ok=exist_ok)

    @classmethod
    def dump_error(cls, e: BaseException | None, path: PathLike | datetime | None = None) -> Path:

Argument name "e" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

No space allowed around keyword argument assignment

        """
        Writes a .json file containing the error message, stack trace, and sys info.
        System info is from :meth:`get_env_info`.
        """
        if path is None:
            path = f"err-dump-{cls.dt_for_filesys()}.json"
        elif isinstance(path, datetime):
            path = f"err-dump-{cls.dt_for_filesys(path)}.json"
        path = Path(path)
        data = cls.dump_error_as_dict(e)
        data = orjson.dumps(data, option=orjson.OPT_INDENT_2)
        path.write_bytes(data)
        return path

    @classmethod
    def dump_error_as_dict(cls, e: BaseException | None) -> Mapping[str, Any]:

Argument name "e" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

Missing function or method docstring

Value 'Mapping' is unsubscriptable

        try:
            system = SystemTools.get_env_info()
        except BaseException as e2:

Catching very general exceptions such as BaseException is usually not recommended.

Variable name "e2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

            system = f"UNKNOWN << {e2} >>"
        msg, tb = SystemTools.serialize_exception(e)

Variable name "tb" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

        tb = [t.as_dict() for t in tb]

Variable name "tb" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

        return dict(message=msg, stacktrace=tb, system=system)

    @classmethod
    def dt_for_filesys(cls, dt: datetime | None = None) -> str:

Argument name "dt" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

Missing function or method docstring

No space allowed around keyword argument assignment

        if dt is None:
            dt = datetime.now()
        return dt.strftime("%Y-%m-%d_%H-%M-%S")

    @classmethod

This code seems to be duplicated in your project.

    def verify_can_read_files(
        cls,

Wrong hanging indentation before block (add 4 spaces).

        *paths: str | Path,

Wrong hanging indentation before block (add 4 spaces).

        missing_ok: bool = False,

Wrong hanging indentation before block (add 4 spaces).

        attempt: bool = False,

Wrong hanging indentation before block (add 4 spaces).

    ) -> None:
        """
        Checks that all files can be written to, to ensure atomicity before operations.

        Args:
            *paths: The files
            missing_ok: Don't raise an error if a path doesn't exist
            attempt: Actually try opening

        Returns:
            ReadPermissionsError: If a path is not a file (modulo existence) or doesn't have 'W' set
        """
        paths = [Path(p) for p in paths]
        for path in paths:
            if path.exists() and not path.is_file():
                raise ReadPermissionsError(f"Path {path} is not a file", path=path)
            if (not missing_ok or path.exists()) and not os.access(path, os.R_OK):
                raise ReadPermissionsError(f"Cannot read from {path}", path=path)
            if attempt:
                try:
                    with open(path):
                        pass
                except OSError:
                    raise WritePermissionsError(f"Failed to open {path} for read", key=str(path))

    @classmethod

This code seems to be duplicated in your project.

    def verify_can_write_files(
        cls,

Wrong hanging indentation before block (add 4 spaces).

        *paths: str | Path,

Wrong hanging indentation before block (add 4 spaces).

        missing_ok: bool = False,

Wrong hanging indentation before block (add 4 spaces).

        attempt: bool = False,

Wrong hanging indentation before block (add 4 spaces).

    ) -> None:
        """
        Checks that all files can be written to, to ensure atomicity before operations.

        Args:
            *paths: The files
            missing_ok: Don't raise an error if a path doesn't exist
            attempt: Actually try opening

        Returns:
            WritePermissionsError: If a path is not a file (modulo existence) or doesn't have 'W' set

This line is too long as per the coding-style (101/100).

        """
        paths = [Path(p) for p in paths]
        for path in paths:
            if path.exists() and not path.is_file():
                raise WritePermissionsError(f"Path {path} is not a file", path=path)
            if (not missing_ok or path.exists()) and not os.access(path, os.W_OK):
                raise WritePermissionsError(f"Cannot write to {path}", path=path)
            if attempt:
                try:
                    with open(path, "a"):  # or w
                        pass
                except OSError:
                    raise WritePermissionsError(f"Failed to open {path} for write", path=path)

    @classmethod
    def verify_can_write_dirs(cls, *paths: str | Path, missing_ok: bool = False) -> None:
        """
        Checks that all directories can be written to, to ensure atomicity before operations.

        Args:
            *paths: The directories
            missing_ok: Don't raise an error if a path doesn't exist

        Returns:
            WritePermissionsError: If a path is not a directory (modulo existence) or doesn't have 'W' set

This line is too long as per the coding-style (106/100).

        """
        paths = [Path(p) for p in paths]
        for path in paths:
            if path.exists() and not path.is_dir():
                raise WritePermissionsError(f"Path {path} is not a dir", path=(path))
            if missing_ok and not path.exists():
                continue
            if not os.access(path, os.W_OK):
                raise WritePermissionsError(f"{path} lacks write permission", path=path)
            if not os.access(path, os.X_OK):
                raise WritePermissionsError(f"{path} lacks access permission", path=path)

    @classmethod
    def delete_surefire(cls, path: PathLike) -> Exception | None:
        """
        Deletes files or directories cross-platform, but working around multiple issues in Windows.

        Returns:
            None, or an Exception for minor warnings

        Raises:
            IOError: If it can't delete
        """
        # we need this because of Windows
        path = Path(path)
        logger.debug(f"Permanently deleting {path} ...")

Use lazy % formatting in logging functions

        chmod_err = None
        try:
            os.chmod(str(path), stat.S_IRWXU)
        except Exception as e:

Catching very general exceptions such as Exception is usually not recommended.

Variable name "e" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

            chmod_err = e
        # another reason for returning exception:
        # We don't want to interrupt the current line being printed like in slow_delete
        if path.is_dir():
            shutil.rmtree(str(path), ignore_errors=True)  # ignore_errors because of Windows
            try:
                path.unlink(missing_ok=True)  # again, because of Windows
            except OSError:
                pass  # almost definitely because it doesn't exist
        else:
            path.unlink(missing_ok=True)
        logger.debug(f"Permanently deleted {path}")

Use lazy % formatting in logging functions

        return chmod_err

    @classmethod
    def trash(cls, path: PathLike, trash_dir: PathLike | None = None) -> None:

No space allowed around keyword argument assignment

        """
        Trash a file or directory.

        Args:
            path: The path to move to the trash
            trash_dir: If None, uses :meth:`pocketutils.tools.path_tools.PathTools.guess_trash`
        """
        if trash_dir is None:
            trash_dir = PathTools.guess_trash()
        logger.debug(f"Trashing {path} to {trash_dir} ...")

Use lazy % formatting in logging functions

        shutil.move(str(path), str(trash_dir))
        logger.debug(f"Trashed {path} to {trash_dir}")

Use lazy % formatting in logging functions

    @classmethod
    def try_cleanup(cls, path: Path, *, bound: type[Exception] = PermissionError) -> None:

Value 'type' is unsubscriptable

        """
        Try to delete a file (probably temp file), if it exists, and log any ``PermissionError``.
        """
        path = Path(path)
        # noinspection PyBroadException
        try:
            path.unlink(missing_ok=True)
        except bound:
            logger.error(f"Permission error preventing deleting {path}")

Use lazy % formatting in logging functions

    @classmethod
    def read_lines_file(cls, path: PathLike, *, ignore_comments: bool = False) -> Sequence[str]:

Value 'Sequence' is unsubscriptable

        """
        Returns a list of lines in the file.
        Optionally skips lines starting with ``#`` or that only contain whitespace.
        """
        lines = []
        with cls.open_file(path, "r") as f:

Variable name "f" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

            for line in f.readlines():
                line = line.strip()
                if not ignore_comments or not line.startswith("#") and not len(line.strip()) == 0:
                    lines.append(line)
        return lines

    @classmethod
    def read_properties_file(cls, path: PathLike) -> Mapping[str, str]:

Value 'Mapping' is unsubscriptable

        """
        Reads a .properties file.
        A list of lines with key=value pairs (with an equals sign).
        Lines beginning with # are ignored.
        Each line must contain exactly 1 equals sign.

        .. caution::
            The escaping is not compliant with the standard

        Args:
            path: Read the file at this local path

        Returns:
            A dict mapping keys to values, both with surrounding whitespace stripped
        """
        dct = {}
        with cls.open_file(path, "r") as f:

Variable name "f" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

            for i, line in enumerate(f.readlines()):
                line = line.strip()
                if len(line) == 0 or line.startswith("#"):
                    continue
                if line.count("=") != 1:
                    raise ParsingError(f"Bad line {i} in {path}", resource=path)
                k, v = line.split("=")

Variable name "v" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

                k, v = k.strip(), v.strip()

Variable name "v" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

                if k in dct:
                    raise AlreadyUsedError(f"Duplicate property {k} (line {i})", key=k)
                dct[k] = v
        return dct

    @classmethod
    def write_properties_file(
        cls, properties: Mapping[Any, Any], path: str | PurePath, mode: str = "o"

Wrong hanging indentation before block (add 4 spaces).

Value 'Mapping' is unsubscriptable

    ) -> None:
        """
        Writes a .properties file.

        .. caution::
            The escaping is not compliant with the standard
        """
        with FilesysTools.open_file(path, mode) as f:

Variable name "f" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

            bad_keys = []
            bad_values = []
            for k, v in properties.items():

Variable name "v" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

                if "=" in k or "\n" in k:
                    bad_keys.append(k)
                if "=" in v or "\n" in v:
                    bad_values.append(k)
                f.write(
                    str(k).replace("=", "--").replace("\n", "\\n")
                    + "="
                    + str(v).replace("=", "--").replace("\n", "\\n")
                    + "\n"
                )
            if len(bad_keys) > 0:
                logger.warning(

Use lazy % formatting in logging functions

                    f"These keys containing '=' or \\n were escaped: {', '.join(bad_keys)}"
                )
            if len(bad_values) > 0:
                logger.warning(

Use lazy % formatting in logging functions

                    f"These keys containing '=' or \\n were escaped: {', '.join(bad_values)}"
                )

    @classmethod
    def save_json(cls, data: Any, path: PathLike, mode: str = "w") -> None:

Missing function or method docstring

        mode = mode.replace("t", "")
        if "b" not in mode:
            mode += "b"
        with cls.open_file(path, mode) as f:

Variable name "f" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

            f.write(orjson.dumps(data))

    @classmethod
    def load_json(cls, path: PathLike) -> dict | list:

Missing function or method docstring

        return orjson.loads(Path(path).read_text(encoding="utf-8"))

    @classmethod
    def read_any(

Too many return statements (9/6)

        cls, path: PathLike

Wrong hanging indentation before block (add 4 spaces).

    ) -> (
        str
        | bytes
        | Sequence[str]

Value 'Sequence' is unsubscriptable

        | Sequence[int]

Value 'Sequence' is unsubscriptable

        | Sequence[float]

Value 'Sequence' is unsubscriptable

        | Sequence[str]

Value 'Sequence' is unsubscriptable

        | Mapping[str, str]

Value 'Mapping' is unsubscriptable

    ):
        """
        Reads a variety of simple formats based on filename extension.
        Includes '.txt', 'csv', .xml', '.properties', '.json'.
        Also reads '.data' (binary), '.lines' (text lines).
        And formatted lists: '.strings', '.floats', and '.ints' (ex: "[1, 2, 3]").
        """
        path = Path(path)
        ext = path.suffix.lstrip(".")

        def load_list(dtype):
            return [
                dtype(s)
                for s in FilesysTools.read_lines_file(path)[0]
                .replace(" ", "")
                .replace("[", "")
                .replace("]", "")
                .split(",")
            ]

        if ext == "lines":

Unnecessary "elif" after "return"

            return cls.read_lines_file(path)
        elif ext == "txt":
            return path.read_text(encoding="utf-8")
        elif ext == "bytes":
            return path.read_bytes()
        elif ext == "json":
            return cls.load_json(path)
        elif ext == "properties":
            return cls.read_properties_file(path)
        elif ext == "csv":
            with path.open(encoding="utf-8") as f:

Variable name "f" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

                reader = csv.DictReader(f)
                return list(reader)
        elif ext == "ints":
            return load_list(int)
        elif ext == "floats":
            return load_list(float)
        elif ext == "strings":
            return load_list(str)
        elif ext == "xml":
            ElementTree.parse(path).getroot()
        else:
            raise TypeError(f"Did not recognize resource file type for file {path}")

    @classmethod
    @contextmanager
    def open_file(cls, path: PathLike, mode: OpenMode | str, *, mkdir: bool = False):
        """
        Opens a text file, always using utf-8, optionally gzipped.

        See Also:
            :class:`pocketutils.core.input_output.OpenMode`
        """
        path = Path(path)
        mode = OpenMode(mode)
        if mode.write and mkdir:
            path.parent.mkdir(exist_ok=True, parents=True)
        if not mode.read:
            cls.prep_file(path, exist_ok=mode.overwrite or mode.append)
        if path.suffix == ".gz" or path.suffix == ".gzip":
            yield gzip.open(path, mode, compresslevel=COMPRESS_LEVEL, encoding="utf-8")
        elif mode.binary:
            yield open(path, mode, encoding="utf-8")
        else:
            yield open(path, mode, encoding="utf-8")

    @classmethod
    def write_lines(cls, iterable: Iterable[Any], path: PathLike, mode: str = "w") -> int:

Value 'Iterable' is unsubscriptable

        r"""
        Just writes an iterable line-by-line to a file, using '\n'.

        Makes the parent directory if needed.
        Checks that the iterable is a "true iterable" (not a string or bytes).

        Returns:
            The number of lines written (the same as len(iterable) if iterable has a length)

        Raises:
            FileExistsError: If the path exists and append is False
            PathIsNotFileError: If append is True, and the path exists but is not a file
        """
        n = 0

Variable name "n" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

        with cls.open_file(path, mode) as f:

Variable name "f" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

            for x in iterable:

Variable name "x" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

                f.write(str(x) + "\n")
            n += 1

Variable name "n" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

        return n

    @classmethod
    def replace_in_file(cls, path: PathLike, changes: Mapping[str, str]) -> None:

Value 'Mapping' is unsubscriptable

        """
        Uses ``regex.sub`` repeatedly to modify (AND REPLACE) a file's content.
        """
        path = Path(path)
        data = path.read_text(encoding="utf-8")
        for key, value in changes.items():
            data = regex.sub(key, value, data, flags=regex.V1 | regex.MULTILINE | regex.DOTALL)
        path.write_text(data, encoding="utf-8")

    @classmethod
    def tmp_path(cls, path: PathLike | None = None, **kwargs) -> Generator[Path, None, None]:

No space allowed around keyword argument assignment

Value 'Generator' is unsubscriptable

        """
        Makes a temporary Path. Won't create ``path`` but will delete it at the end.
        If ``path`` is None, will use ``tempfile.mkstemp``.
        """
        if path is None:
            _, path = tempfile.mkstemp()
        try:
            yield Path(path, **kwargs)
        finally:
            Path(path).unlink()

    @classmethod
    def tmp_file(
        cls, path: PathLike | None = None, *, spooled: bool = False, **kwargs

Wrong hanging indentation before block (add 4 spaces).

No space allowed around keyword argument assignment

    ) -> Generator[Writeable, None, None]:

Value 'Generator' is unsubscriptable

        """
        Simple wrapper around tempfile functions.
        Wraps ``TemporaryFile``, ``NamedTemporaryFile``, and ``SpooledTemporaryFile``.
        """
        if spooled:
            with tempfile.SpooledTemporaryFile(**kwargs) as x:

Variable name "x" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

                yield x
        elif path is None:
            with tempfile.TemporaryFile(**kwargs) as x:

Variable name "x" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

                yield x
        else:
            with tempfile.NamedTemporaryFile(str(path), **kwargs) as x:

Variable name "x" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

                yield x

    @classmethod
    def tmp_dir(cls, **kwargs) -> Generator[Path, None, None]:

Missing function or method docstring

Value 'Generator' is unsubscriptable

        with tempfile.TemporaryDirectory(**kwargs) as x:

Variable name "x" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

            yield Path(x)

    @classmethod
    def check_expired(
        cls,

Wrong hanging indentation before block (add 4 spaces).

        path: PathLike,

Wrong hanging indentation before block (add 4 spaces).

        max_sec: timedelta | float,

Wrong hanging indentation before block (add 4 spaces).

        *,

Wrong hanging indentation before block (add 4 spaces).

        parent: PathLike | None = None,

No space allowed around keyword argument assignment

Wrong hanging indentation before block (add 4 spaces).

        warn_expired_fmt: str = "{path_rel} is {delta} out of date [{mod_rel}]",

Wrong hanging indentation before block (add 4 spaces).

        warn_unknown_fmt: str = "{path_rel} mod date is unknown [created: {create_rel}]",

Wrong hanging indentation before block (add 4 spaces).

        log: Callable[[str], Any] | None = logger.warning,

Wrong hanging indentation before block (add 4 spaces).

No space allowed around keyword argument assignment

Value 'Callable' is unsubscriptable

    ) -> bool | None:
        """
        Warns and returns True if ``path`` mod date is more than ``max_sec`` in the past.
        Returns None if it could not be determined.

        The formatting strings can refer to any of these (will be empty if unknown):
            - path: Full path
            - name: File/dir name
            - path_rel: Path relative to ``self._dir``, or full path if not under
            - now: formatted current datetime
            - [mod/create]_dt: Formatted mod/creation datetime
            - [mod/create]_rel: Mod/create datetime in terms of offset from now
            - [mod/create]_delta: Formatted timedelta from now
            - [mod/create]_delta_sec: Number of seconds from now (negative if now < mod/create dt)

        Args:
            path: A specific path to check
            max_sec: Max seconds, or a timedelta
            parent: If provided, path_rel is relative to this directory (to simplify warnings)
            warn_expired_fmt: Formatting string in terms of the variables listed above
            warn_unknown_fmt: Formatting string in terms of the variables listed above
            log: Log about problems

        Returns:
            Whether it is expired, or None if it could not be determined
        """
        path = Path(path)
        if log is None:

            def log(_):
                return None

        limit = max_sec if isinstance(max_sec, timedelta) else timedelta(seconds=max_sec)
        now = datetime.now().astimezone()
        info = FilesysTools.get_info(path)
        if info.mod_dt and now - info.mod_dt > limit:

Unnecessary "elif" after "return"

            cls._warn_expired(now, info.mod_dt, info.create_dt, path, parent, warn_expired_fmt, log)
            return True
        elif not info.mod_dt and (not info.create_dt or (now - info.create_dt) > limit):
            cls._warn_expired(now, info.mod_dt, info.create_dt, path, parent, warn_unknown_fmt, log)
            return None
        return False

    @classmethod
    def _warn_expired(

Too many arguments (8/5)

This function exceeds the maximum number of variables (20/15).

        cls,

Wrong hanging indentation before block (add 4 spaces).

        now: datetime,

Wrong hanging indentation before block (add 4 spaces).

        mod: datetime | None,

Wrong hanging indentation before block (add 4 spaces).

        created: datetime | None,

Wrong hanging indentation before block (add 4 spaces).

        path: Path,

Wrong hanging indentation before block (add 4 spaces).

        parent: Path | None,

Wrong hanging indentation before block (add 4 spaces).

        fmt: str | None,

Wrong hanging indentation before block (add 4 spaces).

        log: Callable[[str], Any],

Wrong hanging indentation before block (add 4 spaces).

Value 'Callable' is unsubscriptable

    ):
        if isinstance(fmt, str):
            fmt = fmt.format
        if parent is not None and path.is_relative_to(parent):
            path_rel = str(path.relative_to(parent))
        else:
            path_rel = str(path)
        now_str, mod_str, mod_rel, mod_delta, mod_delta_sec = cls._expire_warning_info(now, mod)
        _, create_str, create_rel, create_delta, create_delta_sec = cls._expire_warning_info(
            now, created
        )
        msg = fmt(
            path=path,
            path_rel=path_rel,
            name=path.name,
            now=now_str,
            mod_dt=mod_str,
            mod_rel=mod_rel,
            mod_delta=mod_delta,
            mod_sec=mod_delta_sec,
            create_dt=create_str,
            create_rel=create_rel,
            create_delta=create_delta,
            create_sec=create_delta_sec,
        )
        log(msg)

    @classmethod
    def _expire_warning_info(
        cls, now: datetime, then: datetime | None

Wrong hanging indentation before block (add 4 spaces).

    ) -> tuple[str, str, str, str, str]:

Value 'tuple' is unsubscriptable

        now_str = now.strftime("%Y-%m-%d %H:%M:%S")
        if then is None:
            return now_str, "", "", "", ""
        delta = now - then
        then_str = then.strftime("%Y-%m-%d %H:%M:%S")
        then_rel = UnitTools.approx_time_wrt(now, then)
        delta_str = UnitTools.delta_time_to_str(delta, space=Chars.narrownbsp)
        return now_str, then_str, then_rel, delta_str, str(delta.total_seconds())

    @classmethod
    def __stat_raw(cls, path: Path) -> os.stat_result | None:
        try:
            return path.lstat()
        except OSError as e:

Variable name "e" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

            if hasattr(pathlib, "_ignore_error") and not pathlib._ignore_error(e):

The Module pathlib does not seem to have a member named _ignore_error.

It seems like _ignore_error was declared protected and should not be accessed from this context.

                raise
        return None


__all__ = ["FilesysTools", "PathInfo"]