unctools 0.1.0__tar.gz → 0.2.0__tar.gz

{unctools-0.1.0/unctools.egg-info → unctools-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unctools
-Version: 0.1.0
+Version: 0.2.0
 Summary: A comprehensive toolkit for handling UNC paths, network drives, and substituted drives
 Home-page: https://github.com/djdacy/unctools
 Author: Dustin Darcy

unctools-0.2.0/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.0}/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.0}/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.0}/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."""

unctools-0.2.0/tests/test_import_stability.py

@@ -0,0 +1,97 @@
+"""Import-stability canary + 0.2.0 surgery contract (see docs/api-stability.md).
+
+Locked surface: if this test fails, a consumer breaks -- follow the
+api-stability process (noisy shim, register, slate removal), never a silent fix.
+
+Also asserts the 0.2.0 surgery outcomes (STACK-MAP D4/D7/D8):
+- deleted content-I/O wrappers are GONE (probe-not-mutate, rule 3a)
+- moved survivors live in their new homes (and the top-level namespace)
+- the get_path_type -> classify_path_origin shim warns (alias A4)
+- the operations facade warns on import (removed in 0.3.0)
+"""
+
+import importlib
+import warnings
+
+import pytest
+
+LOCKED_SURFACE = {
+    "unctools": [
+        # identity conversion
+        "convert_to_local", "convert_to_unc", "batch_convert",
+        "get_unc_path_elements", "build_unc_path",
+        # origin classification + probes
+        "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",
+        # package plumbing
+        "configure_logging", "get_version",
+    ],
+    "unctools.converter": [
+        "UNCConverter", "convert_to_local", "convert_to_unc", "batch_convert",
+        "get_unc_path_elements", "build_unc_path", "refresh_mappings",
+    ],
+    "unctools.detector": [
+        "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",
+    ],
+}
+
+DELETED_FOREVER = {
+    # D7: content I/O has no home at L0 (probe, never mutate)
+    "unctools.operations": ["safe_open", "safe_copy", "batch_copy",
+                            "process_files", "replace_in_file",
+                            "batch_replace_in_files"],
+    # D8: case handling merged into dazzle-filekit
+    "unctools.utils.compat": ["path_exists_case_sensitive",
+                              "get_case_sensitive_path"],
+    # D4: the explicit converts ARE the API
+    "unctools.converter": ["normalize_path"],
+}
+
+
+def test_locked_surface_importable():
+    missing = []
+    for module_name, symbols in LOCKED_SURFACE.items():
+        module = importlib.import_module(module_name)
+        for symbol in symbols:
+            if not hasattr(module, symbol):
+                missing.append(f"{module_name}.{symbol}")
+    assert not missing, f"Locked API symbols missing: {missing}"
+
+
+def test_deleted_symbols_stay_deleted():
+    present = []
+    for module_name, symbols in DELETED_FOREVER.items():
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")  # operations facade warns on import
+            module = importlib.import_module(module_name)
+        for symbol in symbols:
+            if hasattr(module, symbol):
+                present.append(f"{module_name}.{symbol}")
+    assert not present, (
+        f"Deleted-by-contract symbols re-appeared: {present} -- "
+        f"these were removed by STACK-MAP D4/D7/D8 and must not return."
+    )
+
+
+def test_get_path_type_shim_warns_and_delegates():
+    """A4: old name works through 0.2.x, warns naming the new home."""
+    import unctools
+    with pytest.warns(DeprecationWarning, match="classify_path_origin"):
+        result = unctools.get_path_type("C:\\")
+    assert result == unctools.classify_path_origin("C:\\")
+
+
+def test_operations_facade_warns_on_import():
+    """The dissolved operations module is a 0.2.x-only facade (gone in 0.3.0)."""
+    import sys
+    sys.modules.pop("unctools.operations", None)
+    with pytest.warns(DeprecationWarning, match="0.3.0"):
+        import unctools.operations  # noqa: F401
+
+
+def test_version_is_0_2_0():
+    import unctools
+    assert unctools.__version__ == "0.2.0"

unctools-0.2.0/tests/test_operations.py

@@ -0,0 +1,361 @@
+#!/usr/bin/env python3
+"""
+Tests for the unctools.operations module using the test framework.
+"""
+
+import os
+import sys
+import tempfile
+import logging
+import shutil
+from pathlib import Path
+from unittest import mock
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.abspath(os.path.dirname(os.path.dirname(__file__))))
+
+# Import test framework
+from tests.test_framework import (
+    TestSuite, assert_true, assert_false, assert_equal, 
+    assert_not_equal, assert_is_none, assert_is_not_none,
+    skip_if_not_windows, skip_if_windows, skip_if_no_module,
+    run_test_suites, SkipTest
+)
+
+# Import UNCtools
+import unctools
+# 0.2.0 (STACK-MAP D7): content-I/O wrappers were deleted; survivors moved
+# to their layer-correct homes. Tests import from the new locations.
+from unctools.converter import (
+    batch_convert, get_unc_path_elements, build_unc_path
+)
+from unctools.detector import (
+    file_exists, is_path_accessible, find_accessible_path
+)
+from unctools.detector import is_unc_path, PATH_TYPE_UNC
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, 
+                   format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+
+# Test data
+TEST_UNC_PATH = "\\\\server\\share\\folder\\file.txt"
+TEST_LOCAL_PATH = "C:\\Users\\username\\Documents\\file.txt"
+
+class TestEnvironment:
+    """Manages a temporary test environment with files."""
+    
+    def __init__(self):
+        """Initialize the test environment."""
+        self.temp_dir = None
+        self.test_files = []
+        self.output_dir = None
+    
+    def setup(self):
+        """Set up the test environment."""
+        # Create a temporary directory
+        self.temp_dir = tempfile.mkdtemp(prefix='unctools_test_')
+        
+        # Create an output directory for copy tests
+        self.output_dir = os.path.join(self.temp_dir, 'output')
+        os.makedirs(self.output_dir, exist_ok=True)
+        
+        # Create test files
+        self._create_test_files()
+        
+        # Return self for convenience
+        return self
+    
+    def teardown(self):
+        """Clean up the test environment."""
+        # Remove the temporary directory
+        if self.temp_dir and os.path.exists(self.temp_dir):
+            shutil.rmtree(self.temp_dir)
+            self.temp_dir = None
+            self.test_files = []
+            self.output_dir = None
+    
+    def _create_test_files(self):
+        """Create test files in the temporary directory."""
+        # Create files with different content
+        file_paths = []
+        
+        # Create a simple text file
+        text_file = os.path.join(self.temp_dir, 'text_file.txt')
+        with open(text_file, 'w') as f:
+            f.write('This is a test file.')
+        file_paths.append(text_file)
+        
+        # Create a nested directory
+        nested_dir = os.path.join(self.temp_dir, 'nested')
+        os.makedirs(nested_dir, exist_ok=True)
+        
+        # Create a file in the nested directory
+        nested_file = os.path.join(nested_dir, 'nested_file.txt')
+        with open(nested_file, 'w') as f:
+            f.write('This is a nested file.')
+        file_paths.append(nested_file)
+        
+        # Create binary file
+        binary_file = os.path.join(self.temp_dir, 'binary_file.bin')
+        with open(binary_file, 'wb') as f:
+            f.write(b'\x00\x01\x02\x03\x04')
+        file_paths.append(binary_file)
+        
+        # Create multiple text files for batch operations
+        #for i in range(3):
+        #    batch_file = os.path.join(self.temp_dir, f'batch_file_{i}.txt')
+        #    with open(batch_file, 'w') as f:
+        #        f.write(f'This is batch file {i}.')
+        #    file_paths.append(batch_file)
+        
+        # Store the file paths
+        self.test_files = file_paths
+        
+        return file_paths
+
+# Create test suite setup and teardown functions
+def setup_test_environment():
+    """Set up a test environment for tests."""
+    env = TestEnvironment()
+    return env.setup()
+
+def teardown_test_environment(env=None):
+    """Clean up the test environment."""
+    if env:
+        env.teardown()
+
+
+def test_file_exists(env):
+    """Test file_exists function."""
+    # Test with an existing file
+    test_file = env.test_files[0]
+    assert_true(file_exists(test_file), "Existing file should be detected")
+    
+    # Test with a non-existent file
+    non_existent = os.path.join(env.temp_dir, 'non_existent.txt')
+    assert_false(file_exists(non_existent), "Non-existent file should not be detected")
+    
+    # Test with a directory
+    assert_true(file_exists(env.temp_dir), "Directory should be detected as existing")
+    
+    # Test with convert_paths behavior
+    # Mock convert_to_local and convert_to_unc to return alternate paths
+    # and os.path.exists to return True for the converted path
+    
+    def mock_convert_to_local(path):
+        return Path(str(path) + ".local")
+    
+    def mock_convert_to_unc(path):
+        return Path(str(path) + ".unc")
+    
+    def mock_is_unc_path(path):
+        path_str = str(path)  # Convert Path to string before checking
+        return path_str.startswith("\\\\") or path_str.startswith("//")
+    
+    def mock_exists(path):
+        return str(path).endswith(".local") or str(path).endswith(".unc")
+    
+    with mock.patch('unctools.converter.convert_to_local', side_effect=mock_convert_to_local), \
+         mock.patch('unctools.converter.convert_to_unc', side_effect=mock_convert_to_unc), \
+         mock.patch('unctools.detector.is_unc_path', side_effect=mock_is_unc_path), \
+         mock.patch('os.path.exists', side_effect=mock_exists):
+        
+        # Test with a UNC path (should try convert_to_local)
+        assert_true(file_exists(TEST_UNC_PATH, check_both_paths=True), 
+                   "UNC path should be detected via local path conversion")
+        
+        # Test with a local path (should try convert_to_unc)
+        assert_true(file_exists(TEST_LOCAL_PATH, check_both_paths=True), 
+                   "Local path should be detected via UNC path conversion")
+
+
+def test_batch_convert(env):
+    """Test batch_convert function."""
+    # Get a list of test files
+    test_files = env.test_files[:3]  # Take the first 3 files
+    
+    # Mock convert_to_local and convert_to_unc to return predictable results
+    def mock_convert_to_local(path):
+        return Path(str(path) + ".local")
+    
+    def mock_convert_to_unc(path):
+        return Path(str(path) + ".unc")
+    
+    with mock.patch('unctools.converter.convert_to_local', side_effect=mock_convert_to_local), \
+         mock.patch('unctools.converter.convert_to_unc', side_effect=mock_convert_to_unc):
+        
+        # Test batch convert to UNC
+        results = batch_convert([str(f) for f in test_files], to_unc=True)
+        
+        # Verify results
+        assert_equal(len(results), len(test_files), 
+                    "Should have results for all input files")
+        
+        for original, converted in results.items():
+            assert_equal(converted, original + ".unc", 
+                        f"Converted path for {original} should end with .unc")
+        
+        # Test batch convert to local
+        results = batch_convert([str(f) for f in test_files], to_unc=False)
+        
+        # Verify results
+        assert_equal(len(results), len(test_files), 
+                    "Should have results for all input files")
+        
+        for original, converted in results.items():
+            assert_equal(converted, original + ".local", 
+                        f"Converted path for {original} should end with .local")
+
+
+
+def test_get_unc_path_elements(env):
+    """Test get_unc_path_elements function."""
+    # Test with a valid UNC path
+    result = get_unc_path_elements(TEST_UNC_PATH)
+    assert_equal(result, ("server", "share", "folder\\file.txt"), 
+                "Should extract the correct components")
+    
+    # Test with a UNC path without a relative path
+    result = get_unc_path_elements("\\\\server\\share")
+    assert_equal(result, ("server", "share", ""), 
+                "Should extract the correct components without relative path")
+    
+    # Test with a non-UNC path
+    result = get_unc_path_elements(TEST_LOCAL_PATH)
+    assert_is_none(result, "Should return None for non-UNC path")
+    
+    # Test with forward slashes
+    result = get_unc_path_elements("//server/share/folder/file.txt")
+    assert_equal(result, ("server", "share", "folder/file.txt"), 
+                "Should extract the correct components with forward slashes")
+
+def test_build_unc_path(env=None):
+    """Test build_unc_path function."""
+    # Note: This function doesn't need the env parameter but should accept it
+    # for consistency with other test functions.
+    
+    # Test with all components
+    result = build_unc_path("server", "share", "folder\\file.txt")
+    assert_equal(result, "\\\\server\\share\\folder\\file.txt", 
+                "Should build the correct UNC path")
+    
+    # Test without relative path
+    result = build_unc_path("server", "share")
+    assert_equal(result, "\\\\server\\share", 
+                "Should build the correct UNC path without relative path")
+    
+    # Test with empty relative path
+    result = build_unc_path("server", "share", "")
+    assert_equal(result, "\\\\server\\share", 
+                "Should build the correct UNC path with empty relative path")
+    
+    # Test with relative path that starts with backslash
+    result = build_unc_path("server", "share", "\\folder\\file.txt")
+    assert_equal(result, "\\\\server\\share\\folder\\file.txt", 
+                "Should build the correct UNC path and handle leading backslash")
+
+def test_is_path_accessible(env):
+    """Test is_path_accessible function."""
+    # Test with an accessible file
+    test_file = env.test_files[0]
+    assert_true(is_path_accessible(test_file), "File should be accessible")
+    
+    # Test with an accessible directory
+    assert_true(is_path_accessible(env.temp_dir), "Directory should be accessible")
+    
+    # Test with a non-existent file
+    non_existent = os.path.join(env.temp_dir, 'non_existent.txt')
+    assert_false(is_path_accessible(non_existent), "Non-existent file should not be accessible")
+    
+    # Test with convert_paths behavior
+    # Mock conversion and path access functions
+    def mock_convert_to_local(path):
+        return Path(env.test_files[0])  # Return a valid file
+    
+    def mock_convert_to_unc(path):
+        return Path(env.test_files[0])  # Return a valid file
+    
+    def mock_is_unc_path(path):
+        path_str = str(path)
+        return path_str.startswith("\\\\") or path_str.startswith("//")
+    
+    with mock.patch('unctools.converter.convert_to_local', side_effect=mock_convert_to_local), \
+         mock.patch('unctools.converter.convert_to_unc', side_effect=mock_convert_to_unc), \
+         mock.patch('unctools.detector.is_unc_path', side_effect=mock_is_unc_path):
+        
+        # Test with a UNC path (should try convert_to_local)
+        assert_true(is_path_accessible(TEST_UNC_PATH, check_both_paths=True), 
+                   "UNC path should be accessible after conversion")
+        
+        # Test with a non-UNC path (should try convert_to_unc)
+        assert_true(is_path_accessible(non_existent, check_both_paths=True), 
+                   "Path should be accessible after conversion")
+
+def test_find_accessible_path(env):
+    """Test find_accessible_path function."""
+    # Test with an accessible file
+    test_file = env.test_files[0]
+    path = find_accessible_path(test_file)
+    assert_is_not_none(path, "Accessible path should be found")
+    assert_equal(str(path), test_file, "Found path should match the original")
+    
+    # Test with a non-existent file
+    non_existent = os.path.join(env.temp_dir, 'non_existent.txt')
+    
+    # Mock conversion and path access functions
+    def mock_convert_to_local(path):
+        return Path(env.test_files[0])  # Return a valid file
+    
+    def mock_convert_to_unc(path):
+        return Path(env.test_files[0])  # Return a valid file
+    
+    def mock_is_unc_path(path):
+        path_str = str(path)
+        return path_str.startswith("\\\\") or path_str.startswith("//")
+    
+    def mock_is_path_accessible(path, check_both_paths=True):
+        return str(path) == env.test_files[0] or \
+               str(path) == str(Path(env.test_files[0]))
+    
+    with mock.patch('unctools.converter.convert_to_local', side_effect=mock_convert_to_local), \
+         mock.patch('unctools.converter.convert_to_unc', side_effect=mock_convert_to_unc), \
+         mock.patch('unctools.detector.is_unc_path', side_effect=mock_is_unc_path), \
+         mock.patch('unctools.detector.is_path_accessible', side_effect=mock_is_path_accessible):
+        
+        # Test with a UNC path (should try convert_to_local)
+        path = find_accessible_path(TEST_UNC_PATH)
+        assert_is_not_none(path, "Accessible path should be found after conversion")
+        
+        # Test with a non-UNC path (should try convert_to_unc)
+        path = find_accessible_path(non_existent)
+        assert_is_not_none(path, "Accessible path should be found after conversion")
+        
+        # Test with a path that can't be made accessible
+        with mock.patch('unctools.detector.is_path_accessible', return_value=False):
+            path = find_accessible_path(non_existent)
+            assert_is_none(path, "No accessible path should be found")
+
+
+
+def run_tests():
+    """Run all operations tests."""
+    suite = TestSuite("UNCtools Operations Tests")
+    
+    # Set suite setup and teardown
+    suite.set_setup(setup_test_environment)
+    suite.set_teardown(teardown_test_environment)
+    
+    # Add tests
+    suite.add_test(test_file_exists)
+    suite.add_test(test_batch_convert)
+    suite.add_test(test_get_unc_path_elements)
+    suite.add_test(test_build_unc_path)
+    suite.add_test(test_is_path_accessible)
+    suite.add_test(test_find_accessible_path)
+    
+    # Run suite
+    return run_test_suites([suite])
+
+if __name__ == "__main__":
+    sys.exit(run_tests())

{unctools-0.1.0 → unctools-0.2.0}/unctools/__init__.py

@@ -32,7 +32,7 @@ Advanced Windows functionality:
     mappings = get_network_mappings()
 """
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 
 import os
 import sys
@@ -42,16 +42,21 @@ from pathlib import Path
 # Set up package-level logger
 logger = logging.getLogger(__name__)
 
-# Import core functionality into the main namespace
-from .converter import convert_to_local, convert_to_unc, normalize_path
-from .detector import (
-    is_unc_path, is_network_drive, is_subst_drive, 
-    get_path_type, get_network_mappings, detect_path_issues
+# Import core functionality into the main namespace.
+# 0.2.0 (STACK-MAP D4/D7/D8): normalize_path and the content-I/O wrappers
+# (safe_open, safe_copy, batch_copy, process_files, replace_in_file*) were
+# REMOVED; get_path_type was renamed classify_path_origin (deprecated shim
+# kept through 0.2.x); the operations module dissolved into converter
+# (path algebra) and detector (read-only probes).
+from .converter import (
+    convert_to_local, convert_to_unc,
+    batch_convert, get_unc_path_elements, build_unc_path,
 )
-from .operations import (
-    safe_open, safe_copy, batch_convert, batch_copy, 
-    process_files, file_exists, replace_in_file, batch_replace_in_files,
-    get_unc_path_elements, build_unc_path, is_path_accessible, find_accessible_path
+from .detector import (
+    is_unc_path, is_network_drive, is_subst_drive,
+    classify_path_origin, get_path_type,  # get_path_type = deprecated shim (A4)
+    get_network_mappings, detect_path_issues,
+    file_exists, is_path_accessible, find_accessible_path,
 )
 
 # Determine if we're running on Windows