provide-foundation 0.0.0.dev0__py3-none-any.whl → 0.0.0.dev1__py3-none-any.whl

provide/foundation/logger/trace.py

@@ -36,3 +36,30 @@ if not hasattr(stdlib_logging, TRACE_LEVEL_NAME):  # pragma: no cover
         (cast(Any, stdlib_logging.root)).trace = trace.__get__(
             stdlib_logging.root, stdlib_logging.Logger
         )
+
+# Also patch PrintLogger from structlog to support trace method
+try:
+    import structlog
+    from structlog import PrintLogger
+    
+    if not hasattr(PrintLogger, "trace"):  # pragma: no cover
+        def trace_for_print_logger(
+            self: PrintLogger, msg: object, *args: object, **kwargs: object
+        ) -> None:  # pragma: no cover
+            # PrintLogger doesn't have level checking, so just format and print like other methods
+            if args:
+                try:
+                    formatted_msg = str(msg) % args
+                except (TypeError, ValueError):
+                    formatted_msg = f"{msg} {args}"
+            else:
+                formatted_msg = str(msg)
+            
+            # Use the same output mechanism as other PrintLogger methods
+            self._file.write(formatted_msg + "\n")
+            self._file.flush()
+        
+        PrintLogger.trace = trace_for_print_logger  # type: ignore[attr-defined]
+        
+except ImportError:  # pragma: no cover
+    pass

provide/foundation/metrics/otel.py

@@ -1,9 +1,9 @@
 """OpenTelemetry metrics integration."""
 
-from provide.foundation.logger import get_logger
 from provide.foundation.logger.config.telemetry import TelemetryConfig
+from provide.foundation.logger.setup import get_vanilla_logger
 
-log = get_logger(__name__)
+slog = get_vanilla_logger(__name__)
 
 # Feature detection
 try:
@@ -47,15 +47,15 @@ def setup_opentelemetry_metrics(config: TelemetryConfig) -> None:
     """
     # Check if metrics are disabled first, before checking dependencies
     if not config.metrics_enabled or config.globally_disabled:
-        log.debug("📊 OpenTelemetry metrics disabled")
+        slog.debug("📊 OpenTelemetry metrics disabled")
         return
 
     # Check if OpenTelemetry metrics are available
     if not _HAS_OTEL_METRICS:
-        log.debug("📊 OpenTelemetry metrics not available (dependencies not installed)")
+        slog.debug("📊 OpenTelemetry metrics not available (dependencies not installed)")
         return
 
-    log.debug("📊🚀 Setting up OpenTelemetry metrics")
+    slog.debug("📊🚀 Setting up OpenTelemetry metrics")
 
     # Create resource with service information
     resource_attrs = {}
@@ -73,7 +73,7 @@ def setup_opentelemetry_metrics(config: TelemetryConfig) -> None:
         endpoint = config.otlp_endpoint
         headers = config.get_otlp_headers_dict()
 
-        log.debug(f"📊📤 Configuring OTLP metrics exporter: {endpoint}")
+        slog.debug(f"📊📤 Configuring OTLP metrics exporter: {endpoint}")
 
         # Choose exporter based on protocol
         if config.otlp_protocol == "grpc":
@@ -91,7 +91,7 @@ def setup_opentelemetry_metrics(config: TelemetryConfig) -> None:
         reader = PeriodicExportingMetricReader(exporter, export_interval_millis=60000)
         readers.append(reader)
 
-        log.debug(f"✅ OTLP metrics exporter configured: {config.otlp_protocol}")
+        slog.debug(f"✅ OTLP metrics exporter configured: {config.otlp_protocol}")
 
     # Create meter provider
     meter_provider = MeterProvider(resource=resource, metric_readers=readers)
@@ -105,7 +105,7 @@ def setup_opentelemetry_metrics(config: TelemetryConfig) -> None:
     meter = otel_metrics.get_meter(__name__)
     _set_meter(meter)
 
-    log.info("📊✅ OpenTelemetry metrics setup complete")
+    slog.info("📊✅ OpenTelemetry metrics setup complete")
 
 
 def shutdown_opentelemetry_metrics() -> None:
@@ -117,6 +117,6 @@ def shutdown_opentelemetry_metrics() -> None:
         meter_provider = otel_metrics.get_meter_provider()
         if hasattr(meter_provider, "shutdown"):
             meter_provider.shutdown()
-            log.debug("📊🛑 OpenTelemetry meter provider shutdown")
+            slog.debug("📊🛑 OpenTelemetry meter provider shutdown")
     except Exception as e:
-        log.warning(f"⚠️ Error shutting down OpenTelemetry metrics: {e}")
+        slog.warning(f"⚠️ Error shutting down OpenTelemetry metrics: {e}")

provide/foundation/process/lifecycle.py

@@ -67,8 +67,16 @@ class ManagedProcess:
         self.stderr_relay = stderr_relay
         self.kwargs = kwargs
 
-        # Build environment
+        # Build environment - always start with current environment
         self._env = os.environ.copy()
+        
+        # Clean coverage-related environment variables from subprocess
+        # to prevent interference with output capture during testing
+        for key in list(self._env.keys()):
+            if key.startswith(('COVERAGE', 'COV_CORE')):
+                self._env.pop(key, None)
+        
+        # Merge in any provided environment variables
         if env:
             self._env.update(env)
 
@@ -357,6 +365,7 @@ async def wait_for_process_output(
     loop = asyncio.get_event_loop()
     start_time = loop.time()
     buffer = ""
+    last_exit_code = None
 
     plog.debug(
         "⏳ Waiting for process output pattern",
@@ -365,17 +374,62 @@ async def wait_for_process_output(
     )
 
     while (loop.time() - start_time) < timeout:
-        # Check if process is still running
+        # Check if process has exited
         if not process.is_running():
-            returncode = process.returncode
-            plog.error("Process exited unexpectedly", returncode=returncode)
-            raise ProcessError(f"Process exited with code {returncode}")
-
+            last_exit_code = process.returncode
+            plog.debug("Process exited", returncode=last_exit_code)
+            
+            # Try to drain any remaining output from the pipes
+            if process._process and process._process.stdout:
+                try:
+                    # Non-blocking read of any remaining data
+                    remaining = process._process.stdout.read()
+                    if remaining:
+                        if isinstance(remaining, bytes):
+                            buffer += remaining.decode("utf-8", errors="replace")
+                        else:
+                            buffer += str(remaining)
+                        plog.debug("Read remaining output from exited process", size=len(remaining))
+                except Exception:
+                    pass
+            
+            # Check buffer after draining
+            if all(part in buffer for part in expected_parts):
+                plog.debug("Found expected pattern after process exit")
+                return buffer
+            
+            # If process exited and we don't have the pattern, fail
+            if last_exit_code is not None:
+                if last_exit_code != 0:
+                    plog.error("Process exited with error", returncode=last_exit_code, buffer=buffer[:200])
+                    raise ProcessError(f"Process exited with code {last_exit_code}")
+                else:
+                    # For exit code 0, give it a small window to collect buffered output
+                    await asyncio.sleep(0.1)
+                    # Try one more time to drain output
+                    if process._process and process._process.stdout:
+                        try:
+                            remaining = process._process.stdout.read()
+                            if remaining:
+                                if isinstance(remaining, bytes):
+                                    buffer += remaining.decode("utf-8", errors="replace")
+                                else:
+                                    buffer += str(remaining)
+                        except Exception:
+                            pass
+                    # Final check
+                    if all(part in buffer for part in expected_parts):
+                        plog.debug("Found expected pattern after final drain")
+                        return buffer
+                    # Process exited cleanly but pattern not found
+                    plog.error("Process exited without expected output", returncode=0, buffer=buffer[:200])
+                    raise ProcessError(f"Process exited with code {last_exit_code} before expected output found")
+        
         try:
-            # Try to read a line first
-            line = await process.read_line_async(timeout=2.0)
+            # Try to read a line with short timeout
+            line = await process.read_line_async(timeout=0.1)
             if line:
-                buffer += line
+                buffer += line + "\n"  # Add newline back since readline strips it
                 plog.debug("Read line from process", line=line[:100])
 
                 # Check if we have all expected parts
@@ -384,23 +438,25 @@ async def wait_for_process_output(
                     return buffer
 
         except TimeoutError:
-            plog.debug("Line read timeout, trying character-by-character")
-
-        try:
-            # Fall back to character-by-character reading
-            char = await process.read_char_async(timeout=1.0)
-            if char:
-                buffer += char
-                plog.debug("Read character", char=repr(char), buffer_size=len(buffer))
-
-                # Check pattern again
-                if all(part in buffer for part in expected_parts):
-                    plog.debug("Found expected pattern in buffer (char mode)")
-                    return buffer
-
-        except TimeoutError:
-            await asyncio.sleep(0.25)
-
+            pass
+        except Exception:
+            # Process might have exited, continue
+            pass
+
+        # Short sleep to avoid busy loop
+        await asyncio.sleep(0.01)
+
+    # Final check of buffer before timeout error
+    if all(part in buffer for part in expected_parts):
+        return buffer
+    
+    # If process exited with 0 but we didn't get output, that's still a timeout
+    plog.error(
+        "Timeout waiting for pattern",
+        expected_parts=expected_parts,
+        buffer=buffer[:200],
+        last_exit_code=last_exit_code,
+    )
     raise TimeoutError(
         f"Expected pattern {expected_parts} not found within {timeout}s timeout"
     )

provide/foundation/testing/__init__.py

@@ -93,6 +93,83 @@ def __getattr__(name: str) -> Any:
         import provide.foundation.testing.fixtures as fixtures_module
 
         return getattr(fixtures_module, name)
+    
+    # Import submodules directly
+    elif name in ["archive", "common", "file", "process", "transport", "mocking", "time", "threading"]:
+        import importlib
+        return importlib.import_module(f"provide.foundation.testing.{name}")
+    
+    # File testing utilities (backward compatibility)
+    elif name in [
+        "temp_directory",
+        "test_files_structure",
+        "temp_file",
+        "binary_file",
+        "nested_directory_structure",
+        "empty_directory",
+        "readonly_file",
+    ]:
+        import provide.foundation.testing.file.fixtures as file_module
+        return getattr(file_module, name)
+    
+    # Process/async testing utilities (backward compatibility)
+    elif name in [
+        "clean_event_loop",
+        "async_timeout",
+        "mock_async_process",
+        "async_stream_reader",
+        "event_loop_policy",
+        "async_context_manager",
+        "async_iterator",
+        "async_queue",
+        "async_lock",
+        "mock_async_sleep",
+    ]:
+        import provide.foundation.testing.process.fixtures as process_module
+        return getattr(process_module, name)
+    
+    # Common mock utilities (backward compatibility)
+    elif name in [
+        "mock_http_config",
+        "mock_telemetry_config",
+        "mock_config_source",
+        "mock_event_emitter",
+        "mock_transport",
+        "mock_metrics_collector",
+        "mock_cache",
+        "mock_database",
+        "mock_file_system",
+        "mock_subprocess",
+    ]:
+        import provide.foundation.testing.common.fixtures as common_module
+        return getattr(common_module, name)
+    
+    # Transport/network testing utilities (backward compatibility)
+    elif name in [
+        "free_port",
+        "mock_server",
+        "httpx_mock_responses",
+        "mock_websocket",
+        "mock_dns_resolver",
+        "tcp_client_server",
+        "mock_ssl_context",
+        "network_timeout",
+        "mock_http_headers",
+    ]:
+        import provide.foundation.testing.transport.fixtures as transport_module
+        return getattr(transport_module, name)
+    
+    # Archive testing utilities
+    elif name in [
+        "archive_test_content",
+        "large_file_for_compression",
+        "multi_format_archives",
+        "archive_with_permissions",
+        "corrupted_archives",
+        "archive_stress_test_files",
+    ]:
+        import provide.foundation.testing.archive.fixtures as archive_module
+        return getattr(archive_module, name)
 
     # Crypto fixtures (many fixtures)
     elif name in [

provide/foundation/testing/archive/__init__.py

@@ -0,0 +1,24 @@
+"""
+Archive testing fixtures for the provide-io ecosystem.
+
+Standard fixtures for testing archive operations (tar, zip, gzip, bzip2)
+across any project that depends on provide.foundation.
+"""
+
+from provide.foundation.testing.archive.fixtures import (
+    archive_test_content,
+    large_file_for_compression,
+    multi_format_archives,
+    archive_with_permissions,
+    corrupted_archives,
+    archive_stress_test_files,
+)
+
+__all__ = [
+    "archive_test_content",
+    "large_file_for_compression",
+    "multi_format_archives",
+    "archive_with_permissions",
+    "corrupted_archives",
+    "archive_stress_test_files",
+]

provide/foundation/testing/archive/fixtures.py

@@ -0,0 +1,217 @@
+"""
+Archive Testing Fixtures.
+
+Fixtures specific to testing archive operations like tar, zip, gzip, bzip2.
+Builds on top of file fixtures for archive-specific test scenarios.
+"""
+
+from pathlib import Path
+from collections.abc import Generator
+
+import pytest
+
+from provide.foundation.testing.file.fixtures import temp_directory
+
+
+@pytest.fixture
+def archive_test_content() -> Generator[tuple[Path, dict[str, str]], None, None]:
+    """
+    Create a standard set of files for archive testing.
+    
+    Creates multiple files with different types of content to ensure
+    proper compression and extraction testing.
+    
+    Yields:
+        Tuple of (source_dir, content_map) where content_map maps
+        relative paths to their expected content.
+    """
+    with temp_directory() as temp_dir:
+        source = temp_dir / "archive_source"
+        source.mkdir()
+        
+        content_map = {
+            "text_file.txt": "This is a text file for archive testing.\n" * 10,
+            "data.json": '{"test": "data", "array": [1, 2, 3]}',
+            "script.py": "#!/usr/bin/env python\nprint('Hello from archive')\n",
+            "nested/dir/file.md": "# Nested File\nContent in nested directory",
+            "binary.dat": "Binary\x00\x01\x02\x03\xFF\xFE data",
+            "empty.txt": "",
+        }
+        
+        # Create all files
+        for rel_path, content in content_map.items():
+            file_path = source / rel_path
+            file_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            if isinstance(content, str):
+                file_path.write_text(content)
+            else:
+                file_path.write_bytes(content.encode() if isinstance(content, str) else content)
+        
+        yield source, content_map
+
+
+@pytest.fixture
+def large_file_for_compression() -> Generator[Path, None, None]:
+    """
+    Create a large file suitable for compression testing.
+    
+    The file contains repetitive content that compresses well.
+    
+    Yields:
+        Path to a large file with compressible content.
+    """
+    with temp_directory() as temp_dir:
+        large_file = temp_dir / "large_compressible.txt"
+        
+        # Create 10MB of highly compressible content
+        content = "This is a line of text that will be repeated many times.\n" * 100
+        large_content = content * 1000  # ~6MB of repetitive text
+        
+        large_file.write_text(large_content)
+        yield large_file
+
+
+@pytest.fixture
+def multi_format_archives() -> Generator[dict[str, Path], None, None]:
+    """
+    Create sample archives in different formats for format detection testing.
+    
+    Yields:
+        Dict mapping format names to paths of sample archives.
+    """
+    with temp_directory() as temp_dir:
+        archives = {}
+        
+        # Create minimal valid archives in different formats
+        # Note: These are minimal headers, not full valid archives
+        
+        # GZIP file (magic: 1f 8b)
+        gzip_file = temp_dir / "sample.gz"
+        gzip_file.write_bytes(b'\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\x03' + b'compressed data')
+        archives["gzip"] = gzip_file
+        
+        # BZIP2 file (magic: BZh)
+        bzip2_file = temp_dir / "sample.bz2"
+        bzip2_file.write_bytes(b'BZh91AY&SY' + b'compressed data')
+        archives["bzip2"] = bzip2_file
+        
+        # ZIP file (magic: PK\x03\x04)
+        zip_file = temp_dir / "sample.zip"
+        zip_file.write_bytes(b'PK\x03\x04' + b'\x00' * 16 + b'zipfile')
+        archives["zip"] = zip_file
+        
+        # TAR file (has specific header structure)
+        tar_file = temp_dir / "sample.tar"
+        # Minimal tar header (512 bytes)
+        tar_header = b'testfile.txt' + b'\x00' * 88  # name
+        tar_header += b'0000644\x00'  # mode
+        tar_header += b'0000000\x00'  # uid
+        tar_header += b'0000000\x00'  # gid
+        tar_header += b'00000000000\x00'  # size
+        tar_header += b'00000000000\x00'  # mtime
+        tar_header += b'        '  # checksum placeholder
+        tar_header += b'0'  # typeflag
+        tar_header += b'\x00' * 355  # padding to 512 bytes
+        tar_file.write_bytes(tar_header[:512])
+        archives["tar"] = tar_file
+        
+        yield archives
+
+
+@pytest.fixture
+def archive_with_permissions() -> Generator[Path, None, None]:
+    """
+    Create files with specific permissions for archive permission testing.
+    
+    Yields:
+        Path to directory containing files with various permission modes.
+    """
+    with temp_directory() as temp_dir:
+        source = temp_dir / "permissions_test"
+        source.mkdir()
+        
+        # Regular file
+        regular = source / "regular.txt"
+        regular.write_text("Regular file")
+        regular.chmod(0o644)
+        
+        # Executable file
+        executable = source / "script.sh"
+        executable.write_text("#!/bin/bash\necho 'Hello'")
+        executable.chmod(0o755)
+        
+        # Read-only file
+        readonly = source / "readonly.txt"
+        readonly.write_text("Read only content")
+        readonly.chmod(0o444)
+        
+        # Directory with specific permissions
+        special_dir = source / "special"
+        special_dir.mkdir()
+        special_dir.chmod(0o700)
+        
+        yield source
+
+
+@pytest.fixture
+def corrupted_archives() -> Generator[dict[str, Path], None, None]:
+    """
+    Create corrupted archive files for error handling testing.
+    
+    Yields:
+        Dict mapping format names to paths of corrupted archives.
+    """
+    with temp_directory() as temp_dir:
+        corrupted = {}
+        
+        # Corrupted GZIP (invalid header)
+        bad_gzip = temp_dir / "corrupted.gz"
+        bad_gzip.write_bytes(b'\x1f\x8c' + b'not really gzip data')
+        corrupted["gzip"] = bad_gzip
+        
+        # Corrupted ZIP (incomplete header)
+        bad_zip = temp_dir / "corrupted.zip"
+        bad_zip.write_bytes(b'PK\x03')  # Incomplete magic
+        corrupted["zip"] = bad_zip
+        
+        # Corrupted BZIP2 (wrong magic)
+        bad_bzip2 = temp_dir / "corrupted.bz2"
+        bad_bzip2.write_bytes(b'BZX' + b'not bzip2')
+        corrupted["bzip2"] = bad_bzip2
+        
+        # Empty file claiming to be archive
+        empty_archive = temp_dir / "empty.tar.gz"
+        empty_archive.write_bytes(b'')
+        corrupted["empty"] = empty_archive
+        
+        yield corrupted
+
+
+@pytest.fixture
+def archive_stress_test_files() -> Generator[Path, None, None]:
+    """
+    Create a large number of files for stress testing archive operations.
+    
+    Yields:
+        Path to directory with many files for stress testing.
+    """
+    with temp_directory() as temp_dir:
+        stress_dir = temp_dir / "stress_test"
+        stress_dir.mkdir()
+        
+        # Create 100 files in various subdirectories
+        for i in range(10):
+            subdir = stress_dir / f"subdir_{i}"
+            subdir.mkdir()
+            
+            for j in range(10):
+                file_path = subdir / f"file_{j}.txt"
+                file_path.write_text(f"Content of file {i}_{j}\n" * 10)
+        
+        # Add some binary files
+        for i in range(5):
+            bin_file = stress_dir / f"binary_{i}.dat"
+            bin_file.write_bytes(bytes(range(256)) * 10)
+        
+        yield stress_dir

provide/foundation/testing/common/__init__.py

@@ -0,0 +1,34 @@
+"""
+Common testing fixtures for the provide-io ecosystem.
+
+Standard mock objects and fixtures that are used across multiple modules
+in any project that depends on provide.foundation.
+"""
+
+from provide.foundation.testing.common.fixtures import (
+    mock_http_config,
+    mock_logger,
+    mock_telemetry_config,
+    mock_config_source,
+    mock_event_emitter,
+    mock_transport,
+    mock_metrics_collector,
+    mock_cache,
+    mock_database,
+    mock_file_system,
+    mock_subprocess,
+)
+
+__all__ = [
+    "mock_http_config",
+    "mock_logger",
+    "mock_telemetry_config",
+    "mock_config_source",
+    "mock_event_emitter",
+    "mock_transport",
+    "mock_metrics_collector",
+    "mock_cache",
+    "mock_database",
+    "mock_file_system",
+    "mock_subprocess",
+]