unctools 0.1.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.2/docs/api-stability.md

@@ -0,0 +1,51 @@
+# API Stability
+
+UNCtools is the L0 path-identity layer of the
+[DazzleLib stack](https://github.com/DazzleLib/.github/blob/main/docs/STACK-MAP.md).
+Its public surface is locked and machine-checked by
+`tests/test_import_stability.py` -- if that canary fails, a consumer somewhere
+breaks: follow the policy below, never silently fix the test.
+
+## Policy
+
+1. **Locked symbols never vanish silently.** Removal/rename ships a NOISY
+   `DeprecationWarning` shim naming the new home and removal version,
+   registered in the stack's alias register, removed on schedule.
+2. **The layer charter is not negotiable** (STACK-MAP rule 3a): this library
+   may probe the filesystem read-only to answer identity questions; it never
+   mutates or transfers content. Functions that do are rejected, not deprecated.
+3. **Name hygiene** (STACK-MAP rule 7): before exporting a public symbol,
+   grep the stack -- same-name-different-semantics requires a layer-teaching
+   rename (that is how `classify_path_origin` got its name).
+
+## Locked surface (0.2.0)
+
+| Module | Symbols |
+|---|---|
+| `unctools` (top level) | `convert_to_local`, `convert_to_unc`, `batch_convert`, `get_unc_path_elements`, `build_unc_path`, `is_unc_path`, `is_network_drive`, `is_subst_drive`, `classify_path_origin`, `get_network_mappings`, `detect_path_issues`, `file_exists`, `is_path_accessible`, `find_accessible_path`, `configure_logging`, `get_version` |
+| `unctools.converter` | `UNCConverter`, `convert_to_local`, `convert_to_unc`, `batch_convert`, `get_unc_path_elements`, `build_unc_path`, `refresh_mappings`, `get_mappings`, `parse_unc_path`, `join_unc_path` |
+| `unctools.detector` | the origin classifiers + probes listed above, plus `get_drive_type`, `get_subst_target`, `get_network_target`, `is_server_in_intranet_zone` |
+| `unctools.windows.*` | Windows-only security/network/registry surface (unchanged in 0.2.0) |
+
+## Active deprecations
+
+| Symbol | Replacement | Warns since | Removed in |
+|---|---|---|---|
+| `get_path_type` | `classify_path_origin` | 0.2.0 | 0.3.0 |
+| `unctools.operations` (module facade) | top-level imports / `converter` / `detector` | 0.2.0 | 0.3.0 |
+
+## Known consumers
+
+| Consumer | Symbols | Notes |
+|---|---|---|
+| dazzlecmd (`safedel/_volumes.py`, `fixpath.py`) | `get_drive_type`, `is_network_drive`, `is_unc_path`, `convert_to_local` | optional imports today; harden in stack P4 |
+| dazzlesum | top-level conversion/probe block | soft-imports today; harden in stack P4 |
+| modified_datetime_fix | mixed (incl. a vendored copy to retire) | stack P4 |
+| dazzle-filekit | `[unctools]` extra pin (no runtime import) | becomes a real edge only if/when filekit consumes identity at runtime |
+
+## Consolidation candidates (0.3.0)
+
+- `parse_unc_path`/`join_unc_path` vs `get_unc_path_elements`/`build_unc_path`
+  (near-duplicates; the latter preserve forward slashes in the relative part)
+- dazzle-lib adoption: derive errors from `dazzle_lib.PathIdentityError`
+  (deliberately deferred from 0.2.0 to keep the surgery diff reviewable)

{unctools-0.1.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.1.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.1.0 → unctools-0.2.2}/tests/basic_functionality_test.py

@@ -62,9 +62,9 @@ def run_tests():
     print("\nTesting core module imports...")
     try:
         from unctools import (
-            convert_to_local, convert_to_unc, normalize_path,
+            convert_to_local, convert_to_unc, classify_path_origin,
             is_unc_path, is_network_drive, is_subst_drive,
-            safe_open, batch_convert
+            file_exists, batch_convert
         )
         check(True, "Import core functions")
     except ImportError as e:
@@ -111,12 +111,12 @@ def run_tests():
     test_unc_path = r"\\server\share\folder"
     check(is_unc_path(test_unc_path), f"is_unc_path({test_unc_path}) should be True")
     
-    # Test path normalization
+    # Test origin classification (normalize_path removed in 0.2.0, D4)
     try:
-        normalized = normalize_path(test_path)
-        check(True, f"normalize_path({test_path}) => {normalized}")
+        origin = classify_path_origin(test_path)
+        check(True, f"classify_path_origin({test_path}) => {origin}")
     except Exception as e:
-        check(False, f"normalize_path({test_path}): {e}")
+        check(False, f"classify_path_origin({test_path}): {e}")
     
     # Test path conversion (just ensure it doesn't error)
     try:
@@ -157,10 +157,8 @@ def run_tests():
             temp_filename = f.name
             f.write("UNCtools test file")
         
-        # Test safe_open
-        with safe_open(temp_filename, 'r') as f:
-            content = f.read()
-            check(content == "UNCtools test file", f"safe_open() and read content: '{content}'")
+        # Test file_exists probe (safe_open removed in 0.2.0, D7)
+        check(file_exists(temp_filename), f"file_exists({temp_filename}) should be True")
         
         # Clean up
         os.unlink(temp_filename)

{unctools-0.1.0 → unctools-0.2.2}/tests/test_converter.py

@@ -10,7 +10,7 @@ from pathlib import Path
 from unittest import mock
 
 from unctools.converter import (
-    UNCConverter, convert_to_local, convert_to_unc, normalize_path,
+    UNCConverter, convert_to_local, convert_to_unc,
     parse_unc_path, join_unc_path
 )
 
@@ -180,24 +180,6 @@ class TestModuleFunctions:
             assert result == Path(TEST_UNC_PATH)
             mock_converter.convert_to_unc.assert_called_once_with(TEST_LOCAL_PATH)
     
-    def test_normalize_path(self):
-        """Test normalize_path function."""
-        # Test with prefer_unc=False (default)
-        with mock.patch('unctools.converter.convert_to_local') as mock_convert_local:
-            mock_convert_local.return_value = Path(TEST_LOCAL_PATH)
-            
-            result = normalize_path(TEST_UNC_PATH)
-            assert result == Path(TEST_LOCAL_PATH)
-            mock_convert_local.assert_called_once_with(Path(TEST_UNC_PATH))
-        
-        # Test with prefer_unc=True
-        with mock.patch('unctools.converter.convert_to_unc') as mock_convert_unc:
-            mock_convert_unc.return_value = Path(TEST_UNC_PATH)
-            
-            result = normalize_path(TEST_LOCAL_PATH, prefer_unc=True)
-            assert result == Path(TEST_UNC_PATH)
-            mock_convert_unc.assert_called_once_with(Path(TEST_LOCAL_PATH))
-    
     def test_parse_unc_path(self):
         """Test parse_unc_path function."""
         # Test with a valid UNC path

{unctools-0.1.0 → unctools-0.2.2}/tests/test_converter_v2.py

@@ -23,7 +23,7 @@ from tests.test_framework import (
 # Import UNCtools
 import unctools
 from unctools.converter import (
-    UNCConverter, convert_to_local, convert_to_unc, normalize_path,
+    UNCConverter, convert_to_local, convert_to_unc,
     parse_unc_path, join_unc_path
 )
 
@@ -155,12 +155,7 @@ def test_module_functions():
     path = convert_to_unc(TEST_LOCAL_PATH)
     assert_is_not_none(path)
     
-    # Test normalize_path
-    path = normalize_path(TEST_UNC_PATH)
-    assert_is_not_none(path)
-    
-    path = normalize_path(TEST_LOCAL_PATH, prefer_unc=True)
-    assert_is_not_none(path)
+    # normalize_path was removed in 0.2.0 (D4) -- the explicit converts ARE the API
 
 def test_parse_unc_path():
     """Test parse_unc_path function."""