Should you be using Pathlib?

They won't because there are just as many people who don't want to use pathlib, and prefer to use strings.

I prefer strings over pathlib for two main reasons:

(1) There is a philosophical argument about what paths should be. POSIX for instance takes a very liberal attitude towards what can be in a filename (anything that isn't "NUL" or "/").

Windows is arguably a lot more sane in that it restricts more ascii characters, but then they got their damn folder separator backwards, and used UTF-16... sigh!!

Despite the rules (or lack thereof) there are numerous norms of behavior that are generally followed. For example:

• Unix uses "_" instead of " "
• Everyone uses file extensions on files, but not directories
• Core code should stick to ascii
• Follow the windows restrictions on punctuation, but be more restrictive if you can...
• etc...

Pathlib could have encoded those rules in some way, but they chose not to. You can create paths like Path("foo.txt\\bar baz; rm -rf ~") on linux systems and there will be not a hint of any concern by pathlib.

However simultaneously they make it impossible (without using os again) to actually access all files on a POSIX system by their insistence that the filename be a UTF-8 string: https://jod.al/2019/12/10/pathlib-and-paths-with-arbitrary-bytes/

My view is that this is just an untenable middle ground. They should have established two libraries with pathlib. Path and RawPath.

RawPath should be a bytes object with minimal restrictions and no checking of norms.

Path would then accept strings, and enforce best practices. You would always be able to convert from Path to RawPath, but not always from RawPath to Path.

Instead we have a broken implementation where you can't even describe every file, but you can still fill your filesystem with garbage that will break other programs. YEAH!!

---

(2) I don't find it that helpful for my usecases, in particular I often find myself building paths from templates, or manipulating pre-existing path components.

In other words I might want to loop through and access paths like:

{client_name}/{delivery_date}/run_{run_number}/output/{filename} which you can do with pathlib, but for me its easy enough to just use string replace and carry the template around.

We also sometimes need to navigate up to a files parent or grandparent folder, and append some string to the filename so as to compare: foobar/baz/run_01/output/result.txt against foobar/baz/run_01_debug/output/result.txt

None of this seems easier with pathlib... so I just don't see the value in it.

If someone wants to come up with a TemplatedPath then we can talk, otherwise I'm just marshalling in and out of a string and having to build and rebuild "the same" path in multiple places in the code.

p=Path("foobar/baz/run_01/output/result.txt")
np = Path("/".join(p.parts).replace("run_01", "run_01_debug"))

def sanitize_directory(dirname: str) -> str:
    """Replace special characters with roman letter equivalence."""
    replace_map = {
        ('<=', '_le_'),
        ('>=', '_ge_'),
        #('=', '_eq_'),  # cat=dog.txt is valid on Windows/Linux
        ('/', '_slash_'),
        ('|', '_bar_'),
        ('*', '_star_'),
        ('?', '_question_'),
        (':', '_colon_'),
        ('"', '_quote_'),
    }
    assert isinstance(dirname, str), dirname
    dirname2 = dirname
    for base, replace in replace_map:
        dirname2 = dirname2.replace(base, replace)
    return dirname2