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

provide/foundation/testing/transport/fixtures.py

@@ -5,11 +5,11 @@ Fixtures and helpers for testing network operations, including
 mock servers, free port allocation, and HTTP client mocking.
 """
 
+from collections.abc import Generator
+from http.server import BaseHTTPRequestHandler, HTTPServer
 import socket
 import threading
-from http.server import HTTPServer, BaseHTTPRequestHandler
 from typing import Any
-from collections.abc import Generator
 
 import pytest
 
@@ -18,12 +18,12 @@ import pytest
 def free_port() -> int:
     """
     Get a free port for testing.
-    
+
     Returns:
         An available port number on localhost.
     """
     with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        s.bind(('', 0))
+        s.bind(("", 0))
         s.listen(1)
         port = s.getsockname()[1]
     return port
@@ -33,62 +33,62 @@ def free_port() -> int:
 def mock_server(free_port) -> Generator[dict[str, Any], None, None]:
     """
     Create a simple mock HTTP server for testing.
-    
+
     Args:
         free_port: Free port number from fixture.
-    
+
     Yields:
         Dict with server info including url, port, and server instance.
     """
     responses = {}
     requests_received = []
-    
+
     class MockHandler(BaseHTTPRequestHandler):
         """Handler for mock HTTP server."""
-        
+
         def do_GET(self):
             """Handle GET requests."""
-            requests_received.append({
-                "method": "GET",
-                "path": self.path,
-                "headers": dict(self.headers)
-            })
-            
+            requests_received.append(
+                {"method": "GET", "path": self.path, "headers": dict(self.headers)}
+            )
+
             response = responses.get(self.path, {"status": 404, "body": b"Not Found"})
             self.send_response(response["status"])
             for header, value in response.get("headers", {}).items():
                 self.send_header(header, value)
             self.end_headers()
             self.wfile.write(response["body"])
-        
+
         def do_POST(self):
             """Handle POST requests."""
-            content_length = int(self.headers.get('Content-Length', 0))
+            content_length = int(self.headers.get("Content-Length", 0))
             body = self.rfile.read(content_length) if content_length else b""
-            
-            requests_received.append({
-                "method": "POST",
-                "path": self.path,
-                "headers": dict(self.headers),
-                "body": body
-            })
-            
+
+            requests_received.append(
+                {
+                    "method": "POST",
+                    "path": self.path,
+                    "headers": dict(self.headers),
+                    "body": body,
+                }
+            )
+
             response = responses.get(self.path, {"status": 200, "body": b"OK"})
             self.send_response(response["status"])
             for header, value in response.get("headers", {}).items():
                 self.send_header(header, value)
             self.end_headers()
             self.wfile.write(response["body"])
-        
+
         def log_message(self, format, *args):
             """Suppress log messages."""
             pass
-    
-    server = HTTPServer(('localhost', free_port), MockHandler)
+
+    server = HTTPServer(("localhost", free_port), MockHandler)
     server_thread = threading.Thread(target=server.serve_forever)
     server_thread.daemon = True
     server_thread.start()
-    
+
     yield {
         "url": f"http://localhost:{free_port}",
         "port": free_port,
@@ -96,7 +96,7 @@ def mock_server(free_port) -> Generator[dict[str, Any], None, None]:
         "responses": responses,
         "requests": requests_received,
     }
-    
+
     server.shutdown()
     server.server_close()
 
@@ -105,7 +105,7 @@ def mock_server(free_port) -> Generator[dict[str, Any], None, None]:
 def httpx_mock_responses():
     """
     Pre-configured responses for HTTPX mocking.
-    
+
     Returns:
         Dict of common mock responses.
     """
@@ -142,12 +142,12 @@ def httpx_mock_responses():
 def mock_websocket():
     """
     Mock WebSocket connection for testing.
-    
+
     Returns:
         Mock WebSocket with send, receive, close methods.
     """
-    from unittest.mock import Mock, AsyncMock
-    
+    from unittest.mock import AsyncMock, Mock
+
     ws = Mock()
     ws.send = AsyncMock()
     ws.receive = AsyncMock(return_value={"type": "text", "data": "message"})
@@ -155,11 +155,11 @@ def mock_websocket():
     ws.accept = AsyncMock()
     ws.ping = AsyncMock()
     ws.pong = AsyncMock()
-    
+
     # State properties
     ws.closed = False
     ws.url = "ws://localhost:8000/ws"
-    
+
     return ws
 
 
@@ -167,17 +167,17 @@ def mock_websocket():
 def mock_dns_resolver():
     """
     Mock DNS resolver for testing.
-    
+
     Returns:
         Mock resolver with resolve method.
     """
     from unittest.mock import Mock
-    
+
     resolver = Mock()
     resolver.resolve = Mock(return_value=["127.0.0.1", "::1"])
     resolver.reverse = Mock(return_value="localhost")
     resolver.clear_cache = Mock()
-    
+
     return resolver
 
 
@@ -185,39 +185,39 @@ def mock_dns_resolver():
 def tcp_client_server(free_port) -> Generator[dict[str, Any], None, None]:
     """
     Create a TCP client-server pair for testing.
-    
+
     Yields:
         Dict with client socket, server socket, and port info.
     """
     server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-    server_socket.bind(('localhost', free_port))
+    server_socket.bind(("localhost", free_port))
     server_socket.listen(1)
-    
+
     client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    
+
     # Run server accept in thread
     connection = None
-    
+
     def accept_connection():
         nonlocal connection
         connection, _ = server_socket.accept()
-    
+
     accept_thread = threading.Thread(target=accept_connection)
     accept_thread.daemon = True
     accept_thread.start()
-    
+
     # Connect client
-    client_socket.connect(('localhost', free_port))
+    client_socket.connect(("localhost", free_port))
     accept_thread.join(timeout=1)
-    
+
     yield {
         "client": client_socket,
         "server": connection,
         "server_socket": server_socket,
         "port": free_port,
     }
-    
+
     # Cleanup
     client_socket.close()
     if connection:
@@ -229,12 +229,12 @@ def tcp_client_server(free_port) -> Generator[dict[str, Any], None, None]:
 def mock_ssl_context():
     """
     Mock SSL context for testing secure connections.
-    
+
     Returns:
         Mock SSL context with common methods.
     """
     from unittest.mock import Mock
-    
+
     context = Mock()
     context.load_cert_chain = Mock()
     context.load_verify_locations = Mock()
@@ -242,7 +242,7 @@ def mock_ssl_context():
     context.wrap_socket = Mock()
     context.check_hostname = True
     context.verify_mode = 2  # ssl.CERT_REQUIRED
-    
+
     return context
 
 
@@ -250,7 +250,7 @@ def mock_ssl_context():
 def network_timeout():
     """
     Provide network timeout configuration for tests.
-    
+
     Returns:
         Dict with timeout values for different operations.
     """
@@ -266,7 +266,7 @@ def network_timeout():
 def mock_http_headers():
     """
     Common HTTP headers for testing.
-    
+
     Returns:
         Dict of typical HTTP headers.
     """
@@ -277,4 +277,4 @@ def mock_http_headers():
         "Authorization": "Bearer test_token",
         "X-Request-ID": "test-request-123",
         "X-Correlation-ID": "test-correlation-456",
-    }
+    }

provide/foundation/time/__init__.py

@@ -0,0 +1,18 @@
+"""
+Production time utilities for Foundation.
+
+Provides consistent time handling with Foundation integration,
+better testability, and timezone awareness.
+"""
+
+from provide.foundation.time.core import (
+    provide_now,
+    provide_sleep,
+    provide_time,
+)
+
+__all__ = [
+    "provide_now",
+    "provide_sleep",
+    "provide_time",
+]

provide/foundation/time/core.py

@@ -0,0 +1,63 @@
+"""Core time utilities for Foundation."""
+
+from datetime import datetime
+import time
+from zoneinfo import ZoneInfo
+
+
+def provide_time() -> float:
+    """
+    Get current time with Foundation tracking.
+
+    Returns:
+        Current time as seconds since epoch
+
+    Example:
+        >>> current_time = provide_time()
+        >>> isinstance(current_time, float)
+        True
+    """
+    return time.time()
+
+
+def provide_sleep(seconds: float) -> None:
+    """
+    Sleep with Foundation tracking and interruption support.
+
+    Args:
+        seconds: Number of seconds to sleep
+
+    Example:
+        >>> provide_sleep(0.1)  # Sleep for 100ms
+    """
+    if seconds < 0:
+        raise ValueError("Sleep duration must be non-negative")
+    time.sleep(seconds)
+
+
+def provide_now(tz: str | ZoneInfo | None = None) -> datetime:
+    """
+    Get current datetime with timezone awareness.
+
+    Args:
+        tz: Timezone (string name, ZoneInfo object, or None for local)
+
+    Returns:
+        Current datetime with timezone information
+
+    Example:
+        >>> now = provide_now()
+        >>> now.tzinfo is not None
+        True
+        >>> utc_now = provide_now("UTC")
+        >>> utc_now.tzinfo.key
+        'UTC'
+    """
+    if tz is None:
+        return datetime.now()
+    elif isinstance(tz, str):
+        zone = ZoneInfo(tz)
+    else:
+        zone = tz
+
+    return datetime.now(zone)

provide/foundation/tools/__init__.py

@@ -26,8 +26,8 @@ Example:
 
 from provide.foundation.tools.base import (
     BaseToolManager,
-    ToolMetadata,
     ToolError,
+    ToolMetadata,
 )
 from provide.foundation.tools.cache import ToolCache
 from provide.foundation.tools.downloader import ToolDownloader
@@ -55,4 +55,4 @@ __all__ = [
     "get_tool_manager",
     "get_tool_registry",
     "register_tool_manager",
-]
+]