unctools 0.2.0__tar.gz → 0.2.2__tar.gz

unctools-0.2.2/PKG-INFO

@@ -0,0 +1,226 @@
+Metadata-Version: 2.4
+Name: unctools
+Version: 0.2.2
+Summary: A comprehensive toolkit for handling UNC paths, network drives, and substituted drives
+Home-page: https://github.com/djdacy/unctools
+Author: Dustin Darcy
+Author-email: Dustin Darcy <your.email@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/djdarcy/unctools
+Project-URL: Bug Reports, https://github.com/djdarcy/unctools/issues
+Project-URL: Source, https://github.com/djdarcy/unctools
+Project-URL: Documentation, https://github.com/djdarcy/unctools#readme
+Keywords: unc,network,windows,path,file,share,subst
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Topic :: System :: Filesystems
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pathlib; python_version < "3.4"
+Provides-Extra: windows
+Requires-Dist: pywin32>=223; extra == "windows"
+Requires-Dist: pypiwin32>=223; extra == "windows"
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.10.0; extra == "dev"
+Requires-Dist: flake8>=3.8.0; extra == "dev"
+Requires-Dist: black>=20.8b1; extra == "dev"
+Requires-Dist: tox>=3.20.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=4.0.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=0.5.0; extra == "docs"
+Requires-Dist: myst-parser>=0.15.0; extra == "docs"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# UNCtools
+
+[![PyPI](https://img.shields.io/pypi/v/unctools?color=green)](https://pypi.org/project/unctools/)
+[![Release Date](https://img.shields.io/github/release-date/DazzleLib/UNCtools?color=green)](https://github.com/DazzleLib/UNCtools/releases)
+[![Python 3.6+](https://img.shields.io/badge/python-3.6+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux%20%7C%20macOS-lightgrey.svg)](#platform-compatibility)
+
+**Windows UNC path handling and network drive utilities: convert between `\\server\share` and mapped drives, classify where paths come from, and probe what's actually reachable.**
+
+## The Problem
+
+On Windows, the same file often has two names: the UNC form (`\\server\share\folder\file.txt`) and a mapped-drive form (`Z:\folder\file.txt`). Tools break when handed the one they didn't expect -- network drives disconnect, `subst` drives masquerade as real ones, security zones silently block UNC access, and scripts that worked on one machine fail on another because the drive mappings differ.
+
+**UNCtools** answers the identity questions: *is this path UNC / network / subst / local -- and what is its other name?* It converts between path forms using the system's live mappings, classifies path origins, probes accessibility across both name variants, and (on Windows) manages the security zones and drive mappings themselves.
+
+> [!NOTE]
+> UNCtools is the **L0 path-identity layer** of the [DazzleLib stack](https://github.com/DazzleLib/.github/blob/main/docs/STACK-MAP.md): it may probe the filesystem read-only to answer identity questions; it never mutates or transfers content (file operations live in [dazzle-filekit](https://github.com/DazzleLib/dazzle-filekit)). The public surface is locked and machine-checked -- see [docs/api-stability.md](docs/api-stability.md).
+
+## Quick Start
+
+```bash
+pip install unctools          # or equivalently: dazzle-unctools
+```
+
+```python
+from unctools import convert_to_local, classify_path_origin
+
+local = convert_to_local(r"\\server\share\project")   # -> Z:\project (if mapped)
+origin = classify_path_origin(local)                  # -> "network"
+```
+
+## Features
+
+- **Path conversion**: UNC ↔ mapped-drive translation from the system's live network mappings (win32net with `net use` fallback)
+- **Origin classification**: `classify_path_origin` -- `unc` / `network` / `subst` / `local` / `removable` / `cdrom` / `ramdisk`
+- **Identity probes**: existence and accessibility checks that try *both* name variants of a path
+- **UNC path algebra**: parse and build `\\server\share\rest` components
+- **Issue detection**: MAX_PATH violations, broken mappings, servers missing from the Intranet security zone
+- **Windows management** (optional extra): security zones, share enumeration, drive mapping create/remove
+- **Cross-platform safe**: imports everywhere; Windows-specific features degrade gracefully on Unix
+
+## Installation
+
+```bash
+pip install unctools              # standard (or: dazzle-unctools)
+pip install unctools[windows]     # + pywin32 for the rich Windows APIs
+```
+
+```bash
+# Development
+git clone https://github.com/DazzleLib/UNCtools.git
+cd UNCtools
+pip install -e .[dev]
+```
+
+## Usage
+
+### Basic Path Conversion
+
+```python
+from unctools import convert_to_local, convert_to_unc
+
+# Convert UNC path to local drive path
+local_path = convert_to_local("\\\\server\\share\\folder\\file.txt")
+# Result (if mapped): "Z:\\folder\\file.txt"
+
+# Convert local drive path back to UNC
+unc_path = convert_to_unc("Z:\\folder\\file.txt")
+# Result: "\\\\server\\share\\folder\\file.txt"
+```
+
+### Path Detection
+
+```python
+from unctools import is_unc_path, is_network_drive, is_subst_drive, classify_path_origin
+
+# Check if a path is a UNC path
+if is_unc_path("\\\\server\\share\\file.txt"):
+    print("This is a UNC path")
+
+# Check if a drive is a network drive
+if is_network_drive("Z:"):
+    print("Z: is a network drive")
+
+# Classify WHERE a path comes from
+origin = classify_path_origin("C:\\Users\\")
+# Result: "local", "network", "subst", "unc", etc.
+```
+
+### Identity Probes & Batch Conversion
+
+```python
+from unctools import file_exists, find_accessible_path, batch_convert
+
+# Does the file exist under EITHER of its names (UNC or mapped)?
+if file_exists("\\\\server\\share\\file.txt"):
+    print("Reachable under at least one name")
+
+# Which name variant actually works right now?
+usable = find_accessible_path("\\\\server\\share\\file.txt")
+# Result: Path("Z:\\file.txt"), Path("\\\\server\\share\\file.txt"), or None
+
+# Convert multiple paths at once
+paths = ["\\\\server\\share\\file1.txt", "\\\\server\\share\\file2.txt"]
+converted = batch_convert(paths, to_unc=False)
+```
+
+### UNC Path Algebra
+
+```python
+from unctools import get_unc_path_elements, build_unc_path
+
+server, share, rest = get_unc_path_elements("\\\\server\\share\\folder\\file.txt")
+# Result: ("server", "share", "folder\\file.txt")
+
+unc = build_unc_path("server", "share", "folder/file.txt")
+# Result: "\\\\server\\share\\folder/file.txt"
+```
+
+### Windows Security Zones
+
+```python
+from unctools.windows import fix_security_zone, add_to_intranet_zone
+
+# Fix security zone issues for a server
+fix_security_zone("server")
+
+# Add a server to the Local Intranet zone
+add_to_intranet_zone("server")
+```
+
+### Network Drive Management
+
+```python
+from unctools.windows import create_network_mapping, remove_network_mapping
+
+# Create a network drive mapping
+success, drive = create_network_mapping("\\\\server\\share", "Z:")
+
+# Remove a network drive mapping
+remove_network_mapping("Z:")
+```
+
+## Platform Compatibility
+
+| Platform | Status |
+|----------|--------|
+| Windows | Full functionality: conversion, classification, probes, security zones, drive management |
+| Linux / macOS | Path algebra and syntax checks work; mapping-dependent features degrade gracefully (no-ops / passthrough) |
+
+## Requirements
+
+- **Python 3.6+** (3.9-3.13 tested in CI)
+- **pywin32** (optional, via `unctools[windows]`) for the rich Windows APIs -- core features fall back to `net use` parsing without it
+
+## Development
+
+```bash
+python -m pytest tests/   # 50+ tests; includes the api-stability import canary
+black unctools
+flake8 unctools
+```
+
+The public API surface is locked: see **[docs/api-stability.md](docs/api-stability.md)** for the policy, the active deprecation shims (`get_path_type` -> `classify_path_origin`, removed in 0.3.0), and known consumers. Changes follow the [stack's](https://github.com/DazzleLib/.github/blob/main/docs/STACK-MAP.md) noisy-shim deprecation policy -- never silent.
+
+## Contributing
+
+Contributions welcome! Please open an issue or submit a pull request.
+
+Like the project?
+
+[!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/djdarcy)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

unctools-0.2.2/README.md

@@ -0,0 +1,177 @@
+# UNCtools
+
+[![PyPI](https://img.shields.io/pypi/v/unctools?color=green)](https://pypi.org/project/unctools/)
+[![Release Date](https://img.shields.io/github/release-date/DazzleLib/UNCtools?color=green)](https://github.com/DazzleLib/UNCtools/releases)
+[![Python 3.6+](https://img.shields.io/badge/python-3.6+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux%20%7C%20macOS-lightgrey.svg)](#platform-compatibility)
+
+**Windows UNC path handling and network drive utilities: convert between `\\server\share` and mapped drives, classify where paths come from, and probe what's actually reachable.**
+
+## The Problem
+
+On Windows, the same file often has two names: the UNC form (`\\server\share\folder\file.txt`) and a mapped-drive form (`Z:\folder\file.txt`). Tools break when handed the one they didn't expect -- network drives disconnect, `subst` drives masquerade as real ones, security zones silently block UNC access, and scripts that worked on one machine fail on another because the drive mappings differ.
+
+**UNCtools** answers the identity questions: *is this path UNC / network / subst / local -- and what is its other name?* It converts between path forms using the system's live mappings, classifies path origins, probes accessibility across both name variants, and (on Windows) manages the security zones and drive mappings themselves.
+
+> [!NOTE]
+> UNCtools is the **L0 path-identity layer** of the [DazzleLib stack](https://github.com/DazzleLib/.github/blob/main/docs/STACK-MAP.md): it may probe the filesystem read-only to answer identity questions; it never mutates or transfers content (file operations live in [dazzle-filekit](https://github.com/DazzleLib/dazzle-filekit)). The public surface is locked and machine-checked -- see [docs/api-stability.md](docs/api-stability.md).
+
+## Quick Start
+
+```bash
+pip install unctools          # or equivalently: dazzle-unctools
+```
+
+```python
+from unctools import convert_to_local, classify_path_origin
+
+local = convert_to_local(r"\\server\share\project")   # -> Z:\project (if mapped)
+origin = classify_path_origin(local)                  # -> "network"
+```
+
+## Features
+
+- **Path conversion**: UNC ↔ mapped-drive translation from the system's live network mappings (win32net with `net use` fallback)
+- **Origin classification**: `classify_path_origin` -- `unc` / `network` / `subst` / `local` / `removable` / `cdrom` / `ramdisk`
+- **Identity probes**: existence and accessibility checks that try *both* name variants of a path
+- **UNC path algebra**: parse and build `\\server\share\rest` components
+- **Issue detection**: MAX_PATH violations, broken mappings, servers missing from the Intranet security zone
+- **Windows management** (optional extra): security zones, share enumeration, drive mapping create/remove
+- **Cross-platform safe**: imports everywhere; Windows-specific features degrade gracefully on Unix
+
+## Installation
+
+```bash
+pip install unctools              # standard (or: dazzle-unctools)
+pip install unctools[windows]     # + pywin32 for the rich Windows APIs
+```
+
+```bash
+# Development
+git clone https://github.com/DazzleLib/UNCtools.git
+cd UNCtools
+pip install -e .[dev]
+```
+
+## Usage
+
+### Basic Path Conversion
+
+```python
+from unctools import convert_to_local, convert_to_unc
+
+# Convert UNC path to local drive path
+local_path = convert_to_local("\\\\server\\share\\folder\\file.txt")
+# Result (if mapped): "Z:\\folder\\file.txt"
+
+# Convert local drive path back to UNC
+unc_path = convert_to_unc("Z:\\folder\\file.txt")
+# Result: "\\\\server\\share\\folder\\file.txt"
+```
+
+### Path Detection
+
+```python
+from unctools import is_unc_path, is_network_drive, is_subst_drive, classify_path_origin
+
+# Check if a path is a UNC path
+if is_unc_path("\\\\server\\share\\file.txt"):
+    print("This is a UNC path")
+
+# Check if a drive is a network drive
+if is_network_drive("Z:"):
+    print("Z: is a network drive")
+
+# Classify WHERE a path comes from
+origin = classify_path_origin("C:\\Users\\")
+# Result: "local", "network", "subst", "unc", etc.
+```
+
+### Identity Probes & Batch Conversion
+
+```python
+from unctools import file_exists, find_accessible_path, batch_convert
+
+# Does the file exist under EITHER of its names (UNC or mapped)?
+if file_exists("\\\\server\\share\\file.txt"):
+    print("Reachable under at least one name")
+
+# Which name variant actually works right now?
+usable = find_accessible_path("\\\\server\\share\\file.txt")
+# Result: Path("Z:\\file.txt"), Path("\\\\server\\share\\file.txt"), or None
+
+# Convert multiple paths at once
+paths = ["\\\\server\\share\\file1.txt", "\\\\server\\share\\file2.txt"]
+converted = batch_convert(paths, to_unc=False)
+```
+
+### UNC Path Algebra
+
+```python
+from unctools import get_unc_path_elements, build_unc_path
+
+server, share, rest = get_unc_path_elements("\\\\server\\share\\folder\\file.txt")
+# Result: ("server", "share", "folder\\file.txt")
+
+unc = build_unc_path("server", "share", "folder/file.txt")
+# Result: "\\\\server\\share\\folder/file.txt"
+```
+
+### Windows Security Zones
+
+```python
+from unctools.windows import fix_security_zone, add_to_intranet_zone
+
+# Fix security zone issues for a server
+fix_security_zone("server")
+
+# Add a server to the Local Intranet zone
+add_to_intranet_zone("server")
+```
+
+### Network Drive Management
+
+```python
+from unctools.windows import create_network_mapping, remove_network_mapping
+
+# Create a network drive mapping
+success, drive = create_network_mapping("\\\\server\\share", "Z:")
+
+# Remove a network drive mapping
+remove_network_mapping("Z:")
+```
+
+## Platform Compatibility
+
+| Platform | Status |
+|----------|--------|
+| Windows | Full functionality: conversion, classification, probes, security zones, drive management |
+| Linux / macOS | Path algebra and syntax checks work; mapping-dependent features degrade gracefully (no-ops / passthrough) |
+
+## Requirements
+
+- **Python 3.6+** (3.9-3.13 tested in CI)
+- **pywin32** (optional, via `unctools[windows]`) for the rich Windows APIs -- core features fall back to `net use` parsing without it
+
+## Development
+
+```bash
+python -m pytest tests/   # 50+ tests; includes the api-stability import canary
+black unctools
+flake8 unctools
+```
+
+The public API surface is locked: see **[docs/api-stability.md](docs/api-stability.md)** for the policy, the active deprecation shims (`get_path_type` -> `classify_path_origin`, removed in 0.3.0), and known consumers. Changes follow the [stack's](https://github.com/DazzleLib/.github/blob/main/docs/STACK-MAP.md) noisy-shim deprecation policy -- never silent.
+
+## Contributing
+
+Contributions welcome! Please open an issue or submit a pull request.
+
+Like the project?
+
+[!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/djdarcy)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

{unctools-0.2.0 → unctools-0.2.2}/examples/basic_usage.py

@@ -17,9 +17,9 @@ logging.basicConfig(level=logging.INFO,
 # Import UNCtools
 import unctools
 from unctools import (
-    convert_to_local, convert_to_unc, normalize_path,
-    is_unc_path, is_network_drive, is_subst_drive, get_path_type,
-    safe_open, safe_copy, batch_convert, process_files
+    convert_to_local, convert_to_unc,
+    is_unc_path, is_network_drive, is_subst_drive, classify_path_origin,
+    file_exists, find_accessible_path, batch_convert
 )
 
 def print_section(title):
@@ -43,7 +43,8 @@ def demonstrate_path_conversion():
     # Show network mappings if on Windows
     if os.name == 'nt':
         print("\nNetwork Mappings:")
-        mappings = unctools.get_mappings()
+        from unctools.converter import get_mappings
+        mappings = get_mappings()
         for unc, drive in mappings.items():
             print(f"  {unc} -> {drive}")
     
@@ -52,10 +53,11 @@ def demonstrate_path_conversion():
     print(f"  UNC -> Local: {unc_path} -> {convert_to_local(unc_path)}")
     print(f"  Local -> UNC: {local_path} -> {convert_to_unc(local_path)}")
     
-    # Normalize paths
-    print("\nPath Normalization:")
-    print(f"  Normalize (prefer local): {normalize_path(unc_path, prefer_unc=False)}")
-    print(f"  Normalize (prefer UNC): {normalize_path(local_path, prefer_unc=True)}")
+    # Round-trip explicitly (normalize_path was removed in 0.2.0 -- the
+    # explicit converts ARE the API)
+    print("\nExplicit round-trip:")
+    print(f"  To local: {convert_to_local(unc_path)}")
+    print(f"  To UNC:   {convert_to_unc(local_path)}")
 
 def demonstrate_path_detection():
     """Demonstrate path detection functionality."""
@@ -72,7 +74,7 @@ def demonstrate_path_detection():
     
     print("Path Type Detection:")
     for path in paths:
-        path_type = get_path_type(path)
+        path_type = classify_path_origin(path)
         is_unc = is_unc_path(path)
         print(f"  {path}:")
         print(f"    Type: {path_type}")
@@ -112,14 +114,11 @@ def demonstrate_file_operations():
     with open(temp_file, "w") as f:
         f.write("Hello, UNCtools!")
     
-    # Safe open
-    print("\nSafe Open:")
-    try:
-        with safe_open(temp_file, "r") as f:
-            content = f.read()
-            print(f"  Content: {content}")
-    except Exception as e:
-        print(f"  Error: {e}")
+    # Identity probes (safe_open was removed in 0.2.0 -- I/O lives in
+    # dazzle-filekit; unctools answers identity questions)
+    print("\nIdentity probes:")
+    print(f"  file_exists: {file_exists(temp_file)}")
+    print(f"  accessible variant: {find_accessible_path(temp_file)}")
     
     # Batch operations
     print("\nBatch Operations:")
@@ -129,15 +128,6 @@ def demonstrate_file_operations():
         with open(os.path.join(temp_dir, f"temp_file_{i}.txt"), "w") as f:
             f.write(f"Test file {i}")
     
-    # Process files
-    print("  Processing files:")
-    def process_callback(path):
-        return path.stat().st_size
-    
-    results = process_files(temp_dir, process_callback, pattern="temp_file*.txt")
-    for path, size in results.items():
-        print(f"    {path}: {size} bytes")
-    
     # Batch convert
     print("\n  Batch conversion:")
     paths = [os.path.join(temp_dir, f"temp_file_{i}.txt") for i in range(3)]

{unctools-0.2.0 → unctools-0.2.2}/pyproject.toml

@@ -63,7 +63,11 @@ include = ["unctools*"]
 exclude = ["tests*"]
 
 [tool.setuptools.dynamic]
-version = {attr = "unctools.__version__"}
+version = {attr = "unctools._version.PIP_VERSION"}
+
+[tool.repokit-common]
+version-source = "unctools/_version.py"
+repo-url = "https://github.com/DazzleLib/UNCtools"
 
 [tool.setuptools.package-data]
 unctools = ["py.typed"]

{unctools-0.2.0 → unctools-0.2.2}/tests/test_detector.py

@@ -26,7 +26,7 @@ from tests.test_framework import (
 import unctools
 from unctools.detector import (
     is_unc_path, is_network_drive, is_subst_drive, 
-    get_path_type, detect_path_issues, get_network_mappings,
+    classify_path_origin, detect_path_issues, get_network_mappings,
     get_subst_target, get_network_target, is_server_in_intranet_zone,
     PATH_TYPE_UNC, PATH_TYPE_NETWORK, PATH_TYPE_SUBST, 
     PATH_TYPE_LOCAL, PATH_TYPE_UNKNOWN, PATH_TYPE_REMOVABLE,
@@ -177,8 +177,8 @@ def test_get_network_target():
         assert_is_none(get_network_target("Q:"), 
                       "Non-existent drive should return None")
 
-def test_get_path_type():
-    """Test get_path_type function."""
+def test_classify_path_origin():
+    """Test classify_path_origin function."""
     # Mock the underlying functions
     def mock_is_unc_path(path):
         return str(path).startswith("\\\\") or str(path).startswith("//")
@@ -204,37 +204,37 @@ def test_get_path_type():
          mock.patch('unctools.detector.get_drive_type', side_effect=mock_get_drive_type):
         
         # Test with UNC path
-        assert_equal(get_path_type(TEST_UNC_PATH), PATH_TYPE_UNC, 
+        assert_equal(classify_path_origin(TEST_UNC_PATH), PATH_TYPE_UNC, 
                     "UNC path should be detected as UNC type")
         
         # Test with local path
-        assert_equal(get_path_type(TEST_LOCAL_PATH), PATH_TYPE_LOCAL, 
+        assert_equal(classify_path_origin(TEST_LOCAL_PATH), PATH_TYPE_LOCAL, 
                     "Local path should be detected as local type")
         
         # Test with network drive path
-        assert_equal(get_path_type(TEST_NETWORK_PATH), PATH_TYPE_NETWORK, 
+        assert_equal(classify_path_origin(TEST_NETWORK_PATH), PATH_TYPE_NETWORK, 
                     "Network drive path should be detected as network type")
         
         # Test with subst drive path
-        assert_equal(get_path_type(TEST_SUBST_PATH), PATH_TYPE_SUBST, 
+        assert_equal(classify_path_origin(TEST_SUBST_PATH), PATH_TYPE_SUBST, 
                     "Subst drive path should be detected as subst type")
         
         # Test with removable drive path
-        assert_equal(get_path_type("E:\\file.txt"), PATH_TYPE_REMOVABLE, 
+        assert_equal(classify_path_origin("E:\\file.txt"), PATH_TYPE_REMOVABLE, 
                     "Removable drive path should be detected as removable type")
         
         # Test with CD-ROM drive path
-        assert_equal(get_path_type("D:\\file.txt"), PATH_TYPE_CDROM, 
+        assert_equal(classify_path_origin("D:\\file.txt"), PATH_TYPE_CDROM, 
                     "CD-ROM drive path should be detected as cdrom type")
         
         # Test with RAM disk path
-        assert_equal(get_path_type("R:\\file.txt"), PATH_TYPE_RAMDISK, 
+        assert_equal(classify_path_origin("R:\\file.txt"), PATH_TYPE_RAMDISK, 
                     "RAM disk path should be detected as ramdisk type")
         
         # Test with invalid path
-        assert_equal(get_path_type(""), PATH_TYPE_UNKNOWN, 
+        assert_equal(classify_path_origin(""), PATH_TYPE_UNKNOWN, 
                     "Empty string should be detected as unknown type")
-        assert_equal(get_path_type(None), PATH_TYPE_UNKNOWN, 
+        assert_equal(classify_path_origin(None), PATH_TYPE_UNKNOWN, 
                     "None should be detected as unknown type")
 
 @pytest.mark.skipif(os.name != 'nt', reason="Windows-specific test - tests security zone functionality")
@@ -244,7 +244,7 @@ def test_detect_path_issues():
     def mock_is_unc_path(path):
         return str(path).startswith("\\\\") or str(path).startswith("//")
     
-    def mock_get_path_type(path):
+    def mock_classify_path_origin(path):
         if mock_is_unc_path(path):
             return PATH_TYPE_UNC
         elif str(path).startswith("Z:"):
@@ -268,7 +268,7 @@ def test_detect_path_issues():
         return None
     
     with mock.patch('unctools.detector.is_unc_path', side_effect=mock_is_unc_path), \
-         mock.patch('unctools.detector.get_path_type', side_effect=mock_get_path_type), \
+         mock.patch('unctools.detector.classify_path_origin', side_effect=mock_classify_path_origin), \
          mock.patch('unctools.detector.is_server_in_intranet_zone', side_effect=mock_is_server_in_intranet_zone), \
          mock.patch('unctools.detector.get_network_target', side_effect=mock_get_network_target), \
          mock.patch('unctools.detector.get_subst_target', side_effect=mock_get_subst_target), \
@@ -373,7 +373,7 @@ def run_tests():
     suite.add_test(test_is_subst_drive)
     suite.add_test(test_get_subst_target)
     suite.add_test(test_get_network_target)
-    suite.add_test(test_get_path_type)
+    suite.add_test(test_classify_path_origin)
     suite.add_test(test_detect_path_issues)
     suite.add_test(test_is_server_in_intranet_zone)
     suite.add_test(test_get_network_mappings)

{unctools-0.2.0 → unctools-0.2.2}/tests/test_framework.py

@@ -16,6 +16,8 @@ logging.basicConfig(level=logging.INFO,
 
 class TestResult:
     """Container for test results."""
+
+    __test__ = False  # custom-runner container, not a pytest test class
     
     def __init__(self):
         self.passed = []
@@ -59,6 +61,8 @@ class TestResult:
 
 class TestSuite:
     """A suite of tests."""
+
+    __test__ = False  # custom standalone runner, not a pytest test class
     
     def __init__(self, name: str):
         self.name = name

{unctools-0.2.0 → unctools-0.2.2}/tests/test_import_stability.py

@@ -92,6 +92,19 @@ def test_operations_facade_warns_on_import():
         import unctools.operations  # noqa: F401
 
 
-def test_version_is_0_2_0():
+def test_version_is_wired_and_consistent():
+    # Version plumbing is correct WITHOUT pinning a literal version -- a bump
+    # (editing MAJOR/MINOR/PATCH in _version.py) never requires touching this
+    # test. We assert the constants drive a well-formed base and that every
+    # derived value agrees with it. This still catches a DESYNCED __version__
+    # (e.g. constants bumped but the autobump hook hasn't regenerated the
+    # string), which is the real failure mode worth guarding.
     import unctools
-    assert unctools.__version__ == "0.2.0"
+    from unctools import _version
+    assert isinstance(_version.MAJOR, int)
+    assert isinstance(_version.MINOR, int)
+    assert isinstance(_version.PATCH, int)
+    base = f"{_version.MAJOR}.{_version.MINOR}.{_version.PATCH}"
+    assert _version.get_base_version().startswith(base)
+    assert _version.PIP_VERSION.startswith(base)
+    assert unctools.__version__.startswith(base)

{unctools-0.2.0 → unctools-0.2.2}/tests/test_operations.py

@@ -44,6 +44,8 @@ TEST_LOCAL_PATH = "C:\\Users\\username\\Documents\\file.txt"
 
 class TestEnvironment:
     """Manages a temporary test environment with files."""
+
+    __test__ = False  # fixture helper (see conftest `env`), not a pytest test class
     
     def __init__(self):
         """Initialize the test environment."""