pypathdub 0.2.3__tar.gz

pypathdub-0.2.3/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

pypathdub-0.2.3/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: pypathdub
+Version: 0.2.3
+Summary: Project path strings between Windows, WSL, MSYS2/Mingw, and POSIX conventions.
+Author: warrentc3
+License-Expression: Unlicense
+Keywords: path,windows,wsl,msys2,mingw
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Utilities
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# pypathdub
+
+`pypathdub` projects path strings between Windows, WSL, MSYS2/Mingw, and POSIX conventions.
+
+It is for the common cross-shell case where the producer shell's path shape is not the shape a consumer binary expects.
+
+```powershell
+pypathdub 'C:\work\project\data.local' --fmt python-wsl
+# /mnt/c/work/project/data.local
+
+pypathdub 'C:\work\project\data.local' --fmt python-mingw
+# /c/work/project/data.local
+```
+
+## Python
+
+```python
+from pypathdub import normalizePathString
+
+print(normalizePathString(r"C:\work\project\data.local", "python-mingw"))
+```
+
+`normalize_path_string` is also exported as a Python-style alias.
+
+From a source checkout, the compatibility script is:
+
+```powershell
+python .\scripts\normalize_path_string.py 'C:\work\project\data.local' --fmt python-mingw
+```
+
+## Formats
+
+- `python-win`
+- `python-winabsolute`
+- `python-nix`
+- `python-mingw`
+- `python-wsl`
+- `osnative-win`
+- `osnative-winabsolute`
+- `osnative-nix`
+- `osnative-mingw`
+- `osnative-wsl`
+
+The `python-*` formats use Python-literal-safe separators. The `osnative-*` formats use the native path style for that convention.
+
+Drive-backed Windows paths cannot be projected to plain `nix`; use Mingw or WSL when the drive mount is part of the target convention.
+
+The `winabsolute` formats require a Windows drive or UNC authority. Relative paths and plain POSIX absolute paths are rejected instead of resolved against the current working directory.

pypathdub-0.2.3/README.md

@@ -0,0 +1,48 @@
+# pypathdub
+
+`pypathdub` projects path strings between Windows, WSL, MSYS2/Mingw, and POSIX conventions.
+
+It is for the common cross-shell case where the producer shell's path shape is not the shape a consumer binary expects.
+
+```powershell
+pypathdub 'C:\work\project\data.local' --fmt python-wsl
+# /mnt/c/work/project/data.local
+
+pypathdub 'C:\work\project\data.local' --fmt python-mingw
+# /c/work/project/data.local
+```
+
+## Python
+
+```python
+from pypathdub import normalizePathString
+
+print(normalizePathString(r"C:\work\project\data.local", "python-mingw"))
+```
+
+`normalize_path_string` is also exported as a Python-style alias.
+
+From a source checkout, the compatibility script is:
+
+```powershell
+python .\scripts\normalize_path_string.py 'C:\work\project\data.local' --fmt python-mingw
+```
+
+## Formats
+
+- `python-win`
+- `python-winabsolute`
+- `python-nix`
+- `python-mingw`
+- `python-wsl`
+- `osnative-win`
+- `osnative-winabsolute`
+- `osnative-nix`
+- `osnative-mingw`
+- `osnative-wsl`
+
+The `python-*` formats use Python-literal-safe separators. The `osnative-*` formats use the native path style for that convention.
+
+Drive-backed Windows paths cannot be projected to plain `nix`; use Mingw or WSL when the drive mount is part of the target convention.
+
+The `winabsolute` formats require a Windows drive or UNC authority. Relative paths and plain POSIX absolute paths are rejected instead of resolved against the current working directory.

pypathdub-0.2.3/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pypathdub"
+version = "0.2.3"
+description = "Project path strings between Windows, WSL, MSYS2/Mingw, and POSIX conventions."
+readme = "README.md"
+requires-python = ">=3.7"
+license = "Unlicense"
+license-files = ["LICENSE"]
+authors = [
+  { name = "warrentc3" }
+]
+keywords = ["path", "windows", "wsl", "msys2", "mingw"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Topic :: Software Development :: Build Tools",
+  "Topic :: Utilities",
+]
+
+[project.scripts]
+pypathdub = "pypathdub.cli:main"
+normalize-path-string = "pypathdub.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

pypathdub-0.2.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pypathdub-0.2.3/src/pypathdub/__init__.py

@@ -0,0 +1,10 @@
+import sys
+
+if sys.version_info < (3, 7):
+    raise RuntimeError(
+        f"pypathdub requires Python 3.7+; running {sys.version}"
+    )
+
+from .core import normalizePathString, normalize_path_string
+
+__all__ = ["normalizePathString", "normalize_path_string"]

pypathdub-0.2.3/src/pypathdub/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pypathdub-0.2.3/src/pypathdub/cli.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import argparse
+from typing import List, Optional
+
+from .core import FORMATS, normalizePathString
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Project a path string into another path convention.")
+    parser.add_argument("pathstr", help="path string to project")
+    parser.add_argument(
+        "--fmt",
+        choices=FORMATS,
+        default=None,
+        help="target format; default is runtime-native and Python-literal-safe",
+    )
+    return parser
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    args = build_parser().parse_args(argv)
+    print(normalizePathString(args.pathstr, args.fmt))
+    return 0

pypathdub-0.2.3/src/pypathdub/core.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import ntpath
+import os
+import platform
+import re
+import shutil
+import subprocess
+from typing import Dict, List, Optional, Tuple
+
+__all__ = ["FORMATS", "normalizePathString", "normalize_path_string"]
+
+_PYTHON = ("python-win", "python-winabsolute", "python-nix", "python-mingw", "python-wsl")
+_OSNATIVE = ("osnative-win", "osnative-winabsolute", "osnative-nix", "osnative-mingw", "osnative-wsl")
+FORMATS = _PYTHON + _OSNATIVE
+_MINGW_MOUNT_RE = re.compile(r"^/[a-zA-Z]/")
+
+
+def _split_windows_root(pathstr: str) -> Tuple[str, str, str]:
+    drive, tail = ntpath.splitdrive(pathstr)
+    root = ""
+    if tail.startswith(("\\", "/")):
+        root = tail[0]
+        tail = tail[1:]
+    return drive, root, tail
+
+
+def _split_posix_root(pathstr: str) -> Tuple[str, str, str]:
+    if pathstr.startswith("//") and not pathstr.startswith("///"):
+        return "", "//", pathstr[2:]
+    if pathstr.startswith("/"):
+        return "", "/", pathstr[1:]
+    return "", "", pathstr
+
+
+def _is_wsl() -> bool:
+    if platform.system() != "Linux":
+        return False
+    try:
+        with open("/proc/sys/kernel/osrelease", "r", encoding="utf-8") as stream:
+            osrelease = stream.read().lower()
+    except OSError:
+        return False
+    return "microsoft" in osrelease or "wsl" in osrelease
+
+
+def _runtime_convention() -> str:
+    if os.environ.get("MSYSTEM"):
+        return "mingw"
+    if _is_wsl():
+        return "wsl"
+    return {"Windows": "win", "Linux": "nix", "Darwin": "nix"}.get(platform.system(), "nix")
+
+
+def _project_unc_to_nix(unc: str, segments: List[str]) -> str:
+    anchor = "//" + unc.replace("\\", "/").strip("/")
+    if segments:
+        return anchor + "/" + "/".join(segments)
+    return anchor
+
+
+def _decompose(pathstr: str, target_convention: Optional[str] = None) -> Dict[str, object]:
+    win_drive, _ = ntpath.splitdrive(pathstr)
+    if win_drive or "\\" in pathstr:
+        drive, root, tail = _split_windows_root(pathstr)
+        unc = drive if drive[:2] in ("\\\\", "//") else ""
+        segments = [segment for segment in tail.replace("\\", "/").split("/") if segment]
+        return {
+            "convention": "win",
+            "drive": "" if unc else drive.rstrip(":"),
+            "unc": unc,
+            "absolute": bool(root),
+            "segments": segments,
+        }
+
+    _, root, tail = _split_posix_root(pathstr)
+    segments = [segment for segment in tail.split("/") if segment]
+    if root == "/" and len(segments) >= 2 and segments[0] == "mnt" and len(segments[1]) == 1 and segments[1].isalpha():
+        return {
+            "convention": "wsl",
+            "drive": segments[1],
+            "unc": "",
+            "absolute": True,
+            "segments": segments[2:],
+        }
+    if (
+        root == "/"
+        and segments
+        and len(segments[0]) == 1
+        and segments[0].isalpha()
+        and (target_convention in {"win", "winabsolute", "mingw", "wsl"} or _runtime_convention() == "mingw")
+    ):
+        return {
+            "convention": "mingw",
+            "drive": segments[0],
+            "unc": "",
+            "absolute": True,
+            "segments": segments[1:],
+        }
+    return {
+        "convention": "nix",
+        "drive": "",
+        "unc": "",
+        "absolute": bool(root),
+        "segments": segments,
+    }
+
+
+def _project(parts: Dict[str, object], convention: str, python_safe: bool) -> str:
+    segments = parts["segments"]
+    assert isinstance(segments, list)
+    drive = str(parts["drive"])
+    unc = str(parts["unc"])
+    absolute = bool(parts["absolute"])
+
+    if convention in {"win", "winabsolute"}:
+        if convention == "winabsolute" and not ((drive and absolute) or unc):
+            raise ValueError("cannot project path to winabsolute without a Windows drive or UNC authority")
+        separator = "/" if python_safe else "\\"
+        if unc:
+            anchor = (unc.replace("\\", "/") if python_safe else unc.replace("/", "\\")) + separator
+        elif drive:
+            anchor = drive + ":" + (separator if absolute else "")
+        else:
+            anchor = separator if absolute else ""
+        return anchor + separator.join(segments)
+    if convention == "mingw":
+        if unc:
+            raise ValueError("cannot project UNC path to mingw convention")
+        anchor = ("/" + drive.lower() + "/") if drive else ("/" if absolute else "")
+        return anchor + "/".join(segments)
+    if convention == "wsl":
+        if unc:
+            raise ValueError("cannot project UNC path to wsl convention")
+        anchor = ("/mnt/" + drive.lower() + "/") if drive else ("/" if absolute else "")
+        return anchor + "/".join(segments)
+    if drive:
+        raise ValueError(
+            f"cannot project Windows drive '{drive}:' to nix convention; "
+            "use 'python-mingw', 'osnative-mingw', 'python-wsl', or 'osnative-wsl' instead"
+        )
+    if unc:
+        return _project_unc_to_nix(unc, segments)
+    return ("/" if absolute else "") + "/".join(segments)
+
+
+def normalizePathString(pathstr: str, fmt: Optional[str] = None) -> str:
+    if fmt is not None and fmt not in FORMATS:
+        raise ValueError(f"unknown fmt {fmt!r}; expected None or one of {FORMATS}")
+    expanded = os.path.expandvars(os.path.expanduser(pathstr))
+    if (
+        fmt == "osnative-win"
+        and _MINGW_MOUNT_RE.match(expanded)
+        and platform.system() == "Windows"
+        and shutil.which("cygpath")
+    ):
+        completed = subprocess.run(["cygpath", "-w", expanded], capture_output=True, text=True)
+        if completed.returncode == 0 and completed.stdout.strip():
+            return completed.stdout.strip()
+    if fmt is None:
+        convention, python_safe = _runtime_convention(), True
+    else:
+        python_safe, convention = fmt.startswith("python-"), fmt.split("-", 1)[1]
+    return _project(_decompose(expanded, convention), convention, python_safe)
+
+
+def normalize_path_string(pathstr: str, fmt: Optional[str] = None) -> str:
+    return normalizePathString(pathstr, fmt)

pypathdub-0.2.3/src/pypathdub.egg-info/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: pypathdub
+Version: 0.2.3
+Summary: Project path strings between Windows, WSL, MSYS2/Mingw, and POSIX conventions.
+Author: warrentc3
+License-Expression: Unlicense
+Keywords: path,windows,wsl,msys2,mingw
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Utilities
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# pypathdub
+
+`pypathdub` projects path strings between Windows, WSL, MSYS2/Mingw, and POSIX conventions.
+
+It is for the common cross-shell case where the producer shell's path shape is not the shape a consumer binary expects.
+
+```powershell
+pypathdub 'C:\work\project\data.local' --fmt python-wsl
+# /mnt/c/work/project/data.local
+
+pypathdub 'C:\work\project\data.local' --fmt python-mingw
+# /c/work/project/data.local
+```
+
+## Python
+
+```python
+from pypathdub import normalizePathString
+
+print(normalizePathString(r"C:\work\project\data.local", "python-mingw"))
+```
+
+`normalize_path_string` is also exported as a Python-style alias.
+
+From a source checkout, the compatibility script is:
+
+```powershell
+python .\scripts\normalize_path_string.py 'C:\work\project\data.local' --fmt python-mingw
+```
+
+## Formats
+
+- `python-win`
+- `python-winabsolute`
+- `python-nix`
+- `python-mingw`
+- `python-wsl`
+- `osnative-win`
+- `osnative-winabsolute`
+- `osnative-nix`
+- `osnative-mingw`
+- `osnative-wsl`
+
+The `python-*` formats use Python-literal-safe separators. The `osnative-*` formats use the native path style for that convention.
+
+Drive-backed Windows paths cannot be projected to plain `nix`; use Mingw or WSL when the drive mount is part of the target convention.
+
+The `winabsolute` formats require a Windows drive or UNC authority. Relative paths and plain POSIX absolute paths are rejected instead of resolved against the current working directory.

pypathdub-0.2.3/src/pypathdub.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/pypathdub/__init__.py
+src/pypathdub/__main__.py
+src/pypathdub/cli.py
+src/pypathdub/core.py
+src/pypathdub.egg-info/PKG-INFO
+src/pypathdub.egg-info/SOURCES.txt
+src/pypathdub.egg-info/dependency_links.txt
+src/pypathdub.egg-info/entry_points.txt
+src/pypathdub.egg-info/top_level.txt
+tests/test_normalize_path_string.py

pypathdub-0.2.3/src/pypathdub.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pypathdub-0.2.3/src/pypathdub.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+normalize-path-string = pypathdub.cli:main
+pypathdub = pypathdub.cli:main

pypathdub-0.2.3/src/pypathdub.egg-info/top_level.txt

@@ -0,0 +1 @@
+pypathdub

pypathdub-0.2.3/tests/test_normalize_path_string.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import sys
+import unittest
+from importlib.util import module_from_spec, spec_from_file_location
+from pathlib import Path
+from unittest import mock
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "src"))
+
+from pypathdub import normalizePathString, normalize_path_string  # noqa: E402
+
+
+class NormalizePathStringTests(unittest.TestCase):
+    def test_package_guard_rejects_unsupported_python(self) -> None:
+        spec = spec_from_file_location("pypathdub_py36_guard_probe", ROOT / "src" / "pypathdub" / "__init__.py")
+        assert spec is not None
+        assert spec.loader is not None
+        module = module_from_spec(spec)
+        with mock.patch.object(sys, "version_info", (3, 6, 0)):
+            with self.assertRaisesRegex(RuntimeError, "requires Python 3.7\\+"):
+                spec.loader.exec_module(module)
+
+    def test_windows_drive_projects_to_wsl(self) -> None:
+        self.assertEqual(
+            "/mnt/c/work/project/data.local",
+            normalizePathString(r"C:\work\project\data.local", "python-wsl"),
+        )
+
+    def test_windows_drive_projects_to_lowercase_mingw_drive(self) -> None:
+        self.assertEqual(
+            "/c/work/project/data.local",
+            normalizePathString(r"C:\work\project\data.local", "python-mingw"),
+        )
+
+    def test_mingw_drive_projects_to_python_win(self) -> None:
+        self.assertEqual(
+            "c:/work/project/data.local",
+            normalizePathString("/c/work/project/data.local", "python-win"),
+        )
+
+    def test_wsl_drive_projects_to_osnative_win(self) -> None:
+        self.assertEqual(
+            r"c:\work\project\data.local",
+            normalizePathString("/mnt/c/work/project/data.local", "osnative-win"),
+        )
+
+    def test_wsl_drive_projects_to_python_winabsolute(self) -> None:
+        self.assertEqual(
+            "c:/work/project/data.local",
+            normalizePathString("/mnt/c/work/project/data.local", "python-winabsolute"),
+        )
+
+    def test_unc_share_projects_to_python_nix_authority(self) -> None:
+        self.assertEqual(
+            "//192.168.1.2/digitalmedia",
+            normalizePathString(r"\\192.168.1.2\digitalmedia", "python-nix"),
+        )
+
+    def test_unc_nested_path_projects_to_python_nix_authority(self) -> None:
+        self.assertEqual(
+            "//192.168.1.2/digitalmedia/movies",
+            normalizePathString(r"\\192.168.1.2\digitalmedia\movies", "python-nix"),
+        )
+
+    def test_relative_path_cannot_project_to_winabsolute(self) -> None:
+        with self.assertRaises(ValueError):
+            normalizePathString(r"work\project\data.local", "python-winabsolute")
+
+    def test_plain_posix_path_cannot_project_to_winabsolute(self) -> None:
+        with self.assertRaises(ValueError):
+            normalizePathString("/work/project/data.local", "python-winabsolute")
+
+    def test_windows_drive_cannot_project_to_nix(self) -> None:
+        with self.assertRaises(ValueError):
+            normalizePathString(r"C:\work\project\data.local", "python-nix")
+
+    def test_python_style_alias(self) -> None:
+        self.assertEqual(
+            "/c/work/project/data.local",
+            normalize_path_string(r"C:\work\project\data.local", "python-mingw"),
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()