atomhttp 1.0.0__tar.gz

atomhttp-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abolfazl Hosseini
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

atomhttp-1.0.0/PKG-INFO

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: atomhttp
+Version: 1.0.0
+Summary: Professional asynchronous HTTP client for Python — interceptors, progress tracking, FormData, Blob, concurrent requests, and full type hints
+Author-email: Abolfazl Hosseini <tryuzr@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/inject3r/atomhttp
+Project-URL: Repository, https://github.com/inject3r/atomhttp.git
+Project-URL: Documentation, https://inject3r.github.io/atomhttp
+Project-URL: Issues, https://github.com/inject3r/atomhttp/issues
+Project-URL: Changelog, https://github.com/inject3r/atomhttp/releases
+Keywords: http,client,async,await,aiohttp,rest,api,interceptor,progress,formdata
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Framework :: AsyncIO
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.8.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: isort>=5.10.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0.0; extra == "test"
+Provides-Extra: all
+Requires-Dist: aiohttp>=3.8.0; extra == "all"
+Requires-Dist: pytest>=7.0.0; extra == "all"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "all"
+Requires-Dist: pytest-cov>=4.0.0; extra == "all"
+Dynamic: license-file
+
+<p align="center">
+  <img src="https://inject3r.github.io/atomhttp/logo.jpg" alt="AtomHTTP Logo" width="350">
+</p>
+
+# AtomHTTP
+
+A professional, feature-rich asynchronous HTTP client for Python — designed for developers who need reliability, flexibility, and performance.
+
+**[Full Documentation](https://inject3r.github.io/atomhttp)** — Complete API reference, advanced guides, and examples
+
+<br/>
+
+## Features
+
+- **Full HTTP Method Support**: GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS with async/await syntax
+- **Request & Response Interceptors**: Modify requests before sending and responses before returning
+- **Upload & Download Progress Tracking**: Real-time callbacks for monitoring data transfer
+- **FormData Support**: Multipart/form-data and URL-encoded form handling with file uploads
+- **Multiple Response Types**: JSON (auto-parsed), text, blob, arraybuffer, and stream
+- **Concurrent Request Helpers**: Execute multiple requests in parallel with `all()` and `spread()`
+- **Base URL Configuration**: Set a base URL once and use relative paths
+- **Automatic JSON Serialization**: No need to manually encode/decode JSON
+- **Authentication**: Basic Auth and Bearer Token support
+- **Comprehensive Error Handling**: Typed exceptions with standardized error codes
+- **Timeout & Redirect Control**: Configurable timeouts and maximum redirect limits
+- **Keep-Alive & Connection Pooling**: Reuse connections for better performance
+- **Proxy Support**: Route requests through HTTP proxies
+- **Unix Socket Path Support**: Connect via Unix domain sockets
+- **Size Limits**: Configure maximum request body and response content lengths
+- **Status Code Validation**: Custom validation functions for HTTP status codes
+- **CSRF Protection**: Built-in support for XSRF token headers
+- **Automatic Decompression**: Handles gzip and deflate compressed responses
+- **Mock Adapter for Testing**: Simulate responses without network calls
+- **Type Hints**: Full typing support for excellent IDE autocompletion
+
+## Installation
+
+```bash
+pip install atomhttp
+```
+
+With development dependencies:
+
+```bash
+pip install atomhttp[dev]
+```
+
+## Quick Start
+
+```python
+import asyncio
+from atomhttp import AtomHTTP
+
+async def main():
+    client = AtomHTTP({'baseURL': 'https://api.example.com'})
+    response = await client.get('/users')
+    print(response.status, response.data)
+    await client.close()
+
+asyncio.run(main())
+```
+
+## Documentation
+
+For complete documentation, API reference, and advanced usage examples, visit:
+
+**[https://inject3r.github.io/atomhttp](https://inject3r.github.io/atomhttp)**
+
+The documentation includes:
+
+- Detailed API reference for all classes and methods
+- Advanced usage patterns and best practices
+- Configuration options and their effects
+- Error handling strategies
+- Migration guides from other HTTP clients
+
+## Requirements
+
+- Python 3.8+
+- aiohttp 3.8.0+
+
+## Running Tests
+
+```bash
+# Run all tests with coverage
+./scripts/tests.sh
+
+# Clean test output files
+./scripts/test_clean.sh
+```
+
+## License
+
+This project is licensed under the MIT License.
+
+## Author
+
+**Abolfazl Hosseini**
+
+- Email: tryuzr@gmail.com
+- GitHub: [@inject3r](https://github.com/inject3r)
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## Acknowledgments
+
+- [aiohttp](https://docs.aiohttp.org/) - Async HTTP client/server framework
+- All contributors and users of this project

atomhttp-1.0.0/README.md

@@ -0,0 +1,116 @@
+<p align="center">
+  <img src="https://inject3r.github.io/atomhttp/logo.jpg" alt="AtomHTTP Logo" width="350">
+</p>
+
+# AtomHTTP
+
+A professional, feature-rich asynchronous HTTP client for Python — designed for developers who need reliability, flexibility, and performance.
+
+**[Full Documentation](https://inject3r.github.io/atomhttp)** — Complete API reference, advanced guides, and examples
+
+<br/>
+
+## Features
+
+- **Full HTTP Method Support**: GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS with async/await syntax
+- **Request & Response Interceptors**: Modify requests before sending and responses before returning
+- **Upload & Download Progress Tracking**: Real-time callbacks for monitoring data transfer
+- **FormData Support**: Multipart/form-data and URL-encoded form handling with file uploads
+- **Multiple Response Types**: JSON (auto-parsed), text, blob, arraybuffer, and stream
+- **Concurrent Request Helpers**: Execute multiple requests in parallel with `all()` and `spread()`
+- **Base URL Configuration**: Set a base URL once and use relative paths
+- **Automatic JSON Serialization**: No need to manually encode/decode JSON
+- **Authentication**: Basic Auth and Bearer Token support
+- **Comprehensive Error Handling**: Typed exceptions with standardized error codes
+- **Timeout & Redirect Control**: Configurable timeouts and maximum redirect limits
+- **Keep-Alive & Connection Pooling**: Reuse connections for better performance
+- **Proxy Support**: Route requests through HTTP proxies
+- **Unix Socket Path Support**: Connect via Unix domain sockets
+- **Size Limits**: Configure maximum request body and response content lengths
+- **Status Code Validation**: Custom validation functions for HTTP status codes
+- **CSRF Protection**: Built-in support for XSRF token headers
+- **Automatic Decompression**: Handles gzip and deflate compressed responses
+- **Mock Adapter for Testing**: Simulate responses without network calls
+- **Type Hints**: Full typing support for excellent IDE autocompletion
+
+## Installation
+
+```bash
+pip install atomhttp
+```
+
+With development dependencies:
+
+```bash
+pip install atomhttp[dev]
+```
+
+## Quick Start
+
+```python
+import asyncio
+from atomhttp import AtomHTTP
+
+async def main():
+    client = AtomHTTP({'baseURL': 'https://api.example.com'})
+    response = await client.get('/users')
+    print(response.status, response.data)
+    await client.close()
+
+asyncio.run(main())
+```
+
+## Documentation
+
+For complete documentation, API reference, and advanced usage examples, visit:
+
+**[https://inject3r.github.io/atomhttp](https://inject3r.github.io/atomhttp)**
+
+The documentation includes:
+
+- Detailed API reference for all classes and methods
+- Advanced usage patterns and best practices
+- Configuration options and their effects
+- Error handling strategies
+- Migration guides from other HTTP clients
+
+## Requirements
+
+- Python 3.8+
+- aiohttp 3.8.0+
+
+## Running Tests
+
+```bash
+# Run all tests with coverage
+./scripts/tests.sh
+
+# Clean test output files
+./scripts/test_clean.sh
+```
+
+## License
+
+This project is licensed under the MIT License.
+
+## Author
+
+**Abolfazl Hosseini**
+
+- Email: tryuzr@gmail.com
+- GitHub: [@inject3r](https://github.com/inject3r)
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## Acknowledgments
+
+- [aiohttp](https://docs.aiohttp.org/) - Async HTTP client/server framework
+- All contributors and users of this project

atomhttp-1.0.0/atomhttp/__init__.py

@@ -0,0 +1,76 @@
+"""
+AtomHTTP - Professional HTTP Client for Python
+===============================================
+
+A comprehensive, asynchronous HTTP client for Python with features including:
+    - Full HTTP method support (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS)
+    - Request and response interceptors
+    - Upload and download progress tracking
+    - FormData (multipart/form-data) with file uploads
+    - Blob, ArrayBuffer, and stream response types
+    - Concurrent request helpers (all, spread)
+    - Base URL configuration
+    - Automatic JSON serialization/deserialization
+    - Comprehensive error handling with typed exceptions
+    - Type hints for better IDE support
+    - Mock adapter for testing
+    - Keep-alive connection pooling
+    - Proxy support
+    - Unix socket path support
+    - Configurable timeouts and redirect limits
+
+This module exports the main AtomHTTP client class along with all necessary
+types, exceptions, and utilities for making HTTP requests.
+
+Example:
+    >>> import asyncio
+    >>> from atomhttp import AtomHTTP
+    >>> 
+    >>> async def main():
+    ...     client = AtomHTTP({'baseURL': 'https://api.example.com'})
+    ...     response = await client.get('/users')
+    ...     print(response.status, response.data)
+    ...     await client.close()
+    >>> 
+    >>> asyncio.run(main())
+"""
+
+from .client import AtomHTTP
+from .errors.http_errors import (
+    AtomHTTPError,
+    AtomHTTPRequestError,
+    AtomHTTPNetworkError,
+    AtomHTTPTimeoutError
+)
+from .core.response import Response
+from .core.config import RequestConfig
+from .core.form_data import FormData
+from .core.adapters import HTTPAdapter, MockAdapter
+from .interceptors.manager import InterceptorManager
+
+__version__ = "2.0.0"
+
+__all__ = [
+    # Main client
+    "AtomHTTP",
+    
+    # Exception classes
+    "AtomHTTPError",
+    "AtomHTTPRequestError",
+    "AtomHTTPNetworkError",
+    "AtomHTTPTimeoutError",
+    
+    # Core types
+    "Response",
+    "RequestConfig",
+    
+    # Interceptor management
+    "InterceptorManager",
+    
+    # Data types
+    "FormData",
+    
+    # Adapters
+    "HTTPAdapter",
+    "MockAdapter",
+]

atomhttp-1.0.0/atomhttp/adapters/__init__.py

@@ -0,0 +1,4 @@
+from .http_adapter import HTTPAdapter
+from .mock_adapter import MockAdapter
+
+__all__ = ['HTTPAdapter', 'MockAdapter']

atomhttp-1.0.0/atomhttp/adapters/http_adapter.py

@@ -0,0 +1,102 @@
+"""
+HTTP Adapter Module
+-------------------
+This module provides the base HTTP adapter for making asynchronous HTTP requests
+using aiohttp. It handles request execution, timeout management, proxy support,
+and response processing.
+
+The HTTPAdapter is the default transport layer for the AtomHTTP client,
+responsible for converting RequestConfig objects into actual HTTP requests
+and wrapping responses into AtomHTTP Response objects.
+"""
+
+import aiohttp
+from typing import Optional
+from ..core.config import RequestConfig
+from ..core.response import Response
+
+
+class HTTPAdapter:
+    """
+    HTTP adapter for making asynchronous HTTP requests using aiohttp.
+    
+    This adapter serves as the transport layer for the AtomHTTP client,
+    handling the low-level details of HTTP communication including connection
+    management, timeout handling, proxy configuration, and response parsing.
+    
+    Attributes:
+        proxy (Optional[str]): Proxy server URL to use for requests.
+                              Format: 'http://proxy.example.com:8080'
+    """
+    
+    def __init__(self, proxy: Optional[str] = None):
+        """
+        Initialize the HTTP adapter with optional proxy configuration.
+        
+        Args:
+            proxy (Optional[str]): Proxy server URL. If provided, all requests
+                                  will be routed through this proxy.
+        """
+        self.proxy = proxy
+    
+    async def send(self, config: RequestConfig) -> Response:
+        """
+        Execute an HTTP request based on the provided configuration.
+        
+        This method performs the actual HTTP request using aiohttp,
+        handling all aspects of the request lifecycle including connection
+        establishment, timeout management, request headers and body,
+        redirect following, and response parsing.
+        
+        Args:
+            config (RequestConfig): Request configuration object containing all
+                                   request parameters such as URL, method,
+                                   headers, data, timeout, etc.
+        
+        Returns:
+            Response: A AtomHTTP Response object containing the parsed response
+                     data, status code, headers, and original configuration.
+        
+        Raises:
+            aiohttp.ClientError: If a network-related error occurs
+            asyncio.TimeoutError: If the request exceeds the configured timeout
+            json.JSONDecodeError: If response_type='json' and response is invalid JSON
+        """
+        # Configure timeout with total request duration limit
+        timeout = aiohttp.ClientTimeout(total=config.timeout)
+        
+        # Create TCP connector if proxy is configured
+        connector = None
+        if self.proxy:
+            connector = aiohttp.TCPConnector()
+        
+        # Create a new client session for this request
+        # Using async context manager ensures proper cleanup
+        async with aiohttp.ClientSession(connector=connector) as session:
+            # Execute the HTTP request with all configured parameters
+            async with session.request(
+                method=config.method,
+                url=config.url,
+                headers=config.headers,
+                params=config.params,
+                data=config.data,
+                timeout=timeout,
+                max_redirects=config.maxRedirects
+            ) as response:
+                # Parse response body based on expected response type
+                # JSON responses are automatically deserialized to dict/list
+                # Non-JSON responses are returned as plain text
+                if config.responseType == 'json':
+                    data = await response.json()
+                else:
+                    data = await response.text()
+                
+                # Wrap the aiohttp response in AtomHTTP's Response object
+                return Response(
+                    data=data,
+                    status=response.status,
+                    status_text=response.reason,
+                    headers=dict(response.headers),
+                    config=config,
+                    request=config
+                )

atomhttp-1.0.0/atomhttp/adapters/mock_adapter.py

@@ -0,0 +1,130 @@
+"""
+Mock Adapter Module
+-------------------
+This module provides a mock HTTP adapter for testing purposes.
+
+The MockAdapter allows developers to simulate HTTP responses without making
+actual network requests. This is useful for unit testing, integration testing,
+and development scenarios where external APIs are unavailable or undesirable
+to call directly.
+"""
+
+from typing import Dict, Any, Optional
+from ..core.config import RequestConfig
+from ..core.response import Response
+
+
+class MockAdapter:
+    """
+    Mock adapter for testing HTTP requests without actual network calls.
+    
+    This adapter stores predefined responses for specific request patterns
+    and returns them when matching requests are made. It enables isolated
+    testing of code that depends on HTTP responses without external dependencies.
+    
+    Features:
+        - Register mock responses for specific HTTP methods and URLs
+        - Customizable response data, status codes, and status texts
+        - Automatic 404 response for unregistered endpoints
+        - No actual network connections are established
+    
+    Attributes:
+        _responses (Dict[str, Dict]): Internal storage mapping request keys
+                                     to their configured mock responses.
+    
+    Example:
+        >>> mock = MockAdapter()
+        >>> mock.on('GET', 'https://api.test/users', {'users': []}, 200)
+        >>> response = await mock.send(config)
+    """
+    
+    def __init__(self):
+        """
+        Initialize an empty mock adapter with no predefined responses.
+        
+        Use the on() method to register mock responses before sending requests.
+        """
+        self._responses: Dict[str, Dict] = {}
+    
+    def on(self, method: str, url: str, response_data: Any, status: int = 200):
+        """
+        Register a mock response for a specific HTTP method and URL.
+        
+        When a request with the matching method and URL is sent through this
+        adapter, the registered response will be returned instead of making
+        an actual network request.
+        
+        Args:
+            method (str): HTTP method (GET, POST, PUT, DELETE, etc.)
+            url (str): Full URL or path that this mock should respond to
+            response_data (Any): Data to be returned as the response body.
+                                Can be dict, list, string, or any JSON-serializable type.
+            status (int): HTTP status code to return. Defaults to 200.
+        
+        Note:
+            If multiple responses are registered for the same method and URL,
+            the last registration will overwrite previous ones.
+        
+        Example:
+            >>> mock = MockAdapter()
+            >>> mock.on('GET', 'https://api.test/users', {'users': []}, 200)
+            >>> mock.on('POST', 'https://api.test/users', {'id': 1}, 201)
+            >>> mock.on('GET', 'https://api.test/users/1', {'name': 'John'}, 200)
+        """
+        # Create a unique key combining method and URL for lookup
+        key = f"{method}:{url}"
+        
+        # Store the mock response configuration
+        self._responses[key] = {
+            'data': response_data,
+            'status': status,
+            'status_text': 'OK' if status == 200 else 'Error'
+        }
+    
+    async def send(self, config: RequestConfig) -> Response:
+        """
+        Send a mock request and return a predefined response.
+        
+        This method looks up the request method and URL in the registered
+        responses. If a match is found, the corresponding mock response is
+        returned. Otherwise, a 404 Not Found response is returned.
+        
+        Args:
+            config (RequestConfig): Request configuration containing method and URL.
+                                   Other config fields (headers, data, etc.) are
+                                   ignored in mock mode.
+        
+        Returns:
+            Response: A AtomHTTP Response object containing either the registered
+                     mock data or a 404 error response.
+        
+        Note:
+            No actual HTTP request is made. The response is constructed entirely
+            from in-memory mock data, making this adapter suitable for tests
+            that require deterministic, repeatable responses.
+        """
+        # Build lookup key from request configuration
+        key = f"{config.method}:{config.url}"
+        
+        # Check if a mock response is registered for this request
+        if key in self._responses:
+            mock = self._responses[key]
+            # Return the registered mock response
+            return Response(
+                data=mock['data'],
+                status=mock['status'],
+                status_text=mock['status_text'],
+                headers={},
+                config=config,
+                request=config
+            )
+        else:
+            # Return default 404 response for unregistered endpoints
+            return Response(
+                data={'error': 'No mock found'},
+                status=404,
+                status_text='Not Found',
+                headers={},
+                config=config,
+                request=config
+            )

atomhttp-1.0.0/atomhttp/auth/__init__.py

@@ -0,0 +1,4 @@
+from .basic_auth import BasicAuth
+from .bearer_auth import BearerAuth
+
+__all__ = ['BasicAuth', 'BearerAuth']