pathlib is an OO library, not a communication protocol. Just send strings.

Windows can handle paths with forward slashes just fine, and both pathlib and os.path can normalise such paths for you. You probably want to normalise paths in your protocol to use POSIX path separators (forward slashes).

You can convert relative Windows paths to POSIX paths using pathlib.PurePosixPath(), for example:

>>> from pathlib import Path, PurePosixPath
>>> Path('relative\path\on\windows')
WindowsPath('relative\path\on\windows')
>>> PurePosixPath(_)
PurePosixPath('relative/path/on/windows')
>>> str(_)
'relative/path/on/windows'

If your server receives a relative paths using Windows conventions, use PureWindowsPath() to convert it to a pathlib object, then pass that to Path() to convert:

>>> from pathlib import Path, PureWindowsPath
>>> received = 'relative\path\on\windows'
>>> PureWindowsPath(received)
PureWindowsPath('relative/path/on/windows')
>>> Path(_)
PosixPath('relative/path/on/windows')

If you keep paths as strings, then you can use str.replace(os.altsep, os.sep) to achieve the same on the Windows side before sending:

>>> import os
>>> p = 'relative\path\on\windows'
>>> p.replace(os.altsep, os.sep)
'relative/path/on/windows'

and you can always just use relative_path.replace('\\', os.sep) to force the issue.

If you are running your code on a *nix machine, you can use the PureWindowsPath class:

>>> from pathlib import PureWindowsPath, PurePosixPath
>>> path = PureWindowsPath('C:\\Users\\foo\\bar')

>>> path.parts
('c:\\', 'Users', 'foo', 'bar')

>>> PurePosixPath('/usr', *path.parts[2:])
PurePosixPath('/usr/foo/bar')

You can apply the string replace method to every line in a text file as follows:

with open("input.csv", "r") as f_in:
    with open("output.csv", "w") as f_out:
        for line in f_in:
            new_line = line.replace(...)  # magic goes here
            f_out.write("{}\n".format(new_line))

Use os.path.abspath(), and also os.path.expanduser() for files relative to the user's home directory:

print os.path.abspath("/var/lib/blob_files/myfile.blob")
>>> C:\var\lib\blob_files\myfile.blob

print os.path.abspath(os.path.expanduser("~/blob_files/myfile.blob"))
>>> C:\Users\jerry\blob_files\myfile.blob

These will "do the right thing" for both Windows and POSIX paths.

expanduser() won't change the path if it doesn't have a ~ in it, so you can safely use it with all paths. Thus, you can easily write a wrapper function:

import os
def fixpath(path):
    return os.path.abspath(os.path.expanduser(path))

Note that the drive letter used will be the drive specified by the current working directory of the Python process, usually the directory your script is in (if launching from Windows Explorer, and assuming your script doesn't change it). If you want to force it to always be C: you can do something like this:

import os
def fixpath(path):
    path = os.path.normpath(os.path.expanduser(path))
    if path.startswith("\\"): return "C:" + path
    return path

Unless you're using a really early version of Windows: "/blah/whatever/" just works for your OP.

You can use os.path.normpath as shown below. It can adjust to both Linux and Windows as per the system and it also resolves the path into the shortest possible path to the destination. Ex: /home/foo/../A will be resolved to /home/A.

Usage:

import os.path
 
# Path
path = './home//user/Documents'
 
 
# Normalize the specified path
# using os.path.normpath() method
norm_path = os.path.normpath(path)
 
# Print the normalized path 
print(norm_path)
# prints home/user/Documents in Linux
# prints home\user\Documents in Windows

For more info read this article: https://www.geeksforgeeks.org/python-os-path-normpath-method/

You can use os.path.abspath() to convert it:

print(os.path.abspath("P:\python\t\temp.txt"))

>>> P:/python/t/temp.txt

See the documentation of os.path here.

pathlib has an as_posix method to convert from Windows to POSIX paths:

pathlib.path(r'foo\bar').as_posix()

Apart from this, you can generally construct system-specific paths by calling the appropriate constructor. The documentation states that

You cannot instantiate a WindowsPath when running on Unix, but you can instantiate PureWindowsPath. [or vice versa]

So use the Pure* class constructor:

str(pathlib.PurePosixPath(your_posix_path))

However, this won’t do what you want if your_posix_path contains backslashes, since \ (= Windows path separator) is just a regular character as far as POSIX is concerned. So a\b is valid POSIX filename, not a path denoting a file b inside a directory b, and PurePosixPath will preserve this interpretation:

>>> str(pathlib.PurePosixPath(r'a\b'))
'a\\b'

To convert Windows to POSIX paths, use the PureWindowsPath class and convert via as_posix:

>>> pathlib.PureWindowsPath(r'a\b').as_posix()
'a/b'

You can keep it simple by simply by converting it to a "raw" string. This can be used anywhere any other path can be used. (os.path, Pathlib, etc.)

mypath = r'C:\Users\user.name\new_project\data' print( 'mypath is =', mypath )

Output: path is = C:\Users\user.name\new_project\data