askpablos-api 0.1.0__py3-none-any.whl

askpablos_api/__init__.py

@@ -0,0 +1,28 @@
+"""
+askpablos_api
+
+A Python client library for interacting with the AskPablos proxy API service.
+"""
+
+from .core import AskPablos
+from .client import ProxyClient
+from .exceptions import (
+    AskPablosError,
+    AuthenticationError,
+    APIConnectionError,
+    ResponseError
+)
+from .utils import configure_logging
+
+__version__ = "0.1.0"
+
+# Set up default exports
+__all__ = [
+    "AskPablos",
+    "ProxyClient",
+    "AskPablosError",
+    "AuthenticationError",
+    "APIConnectionError",
+    "ResponseError",
+    "configure_logging",
+]

askpablos_api/client.py

@@ -0,0 +1,245 @@
+"""
+askpablos_api.client
+
+This module provides the main client class for interacting with the AskPablos proxy API.
+
+The ProxyClient class handles low-level communication with the AskPablos API service,
+including authentication, request signing, and HTTP communication. It serves as the
+foundation for higher-level interfaces like the AskPablos class.
+
+This module is designed for users who need direct control over API requests and
+authentication handling, or for building custom interfaces on top of the base client.
+"""
+
+import json
+import base64
+import hmac
+import hashlib
+import requests
+from typing import Optional, Dict, Any
+
+from .exceptions import APIConnectionError, ResponseError, AuthenticationError
+
+
+class ResponseData:
+    """Response object that provides dot notation access to response data."""
+
+    def __init__(self, status_code: int, headers: Dict[str, str], content: str,
+                 url: str, elapsed: float, encoding: Optional[str],
+                 json_data: Optional[Dict[str, Any]] = None):
+        self.status_code = status_code
+        self.headers = headers
+        self.content = content
+        self.url = url
+        self.elapsed = elapsed
+        self.encoding = encoding
+        self.json = json_data
+
+
+class ProxyClient:
+    """
+    ProxyClient securely sends requests through the AskPablos proxy service.
+
+    This is the low-level client that handles direct communication with the AskPablos
+    API. It manages authentication via HMAC-SHA256 signatures, constructs proper
+    request headers, and handles HTTP communication with the proxy service.
+
+    The ProxyClient is typically used internally by higher-level classes like AskPablos,
+    but can be used directly for fine-grained control over API interactions.
+
+    Attributes:
+        api_key (str): The API key for authentication.
+        secret_key (str): The secret key for HMAC signing.
+        api_url (str): The base URL of the proxy API service.
+
+    Security Note:
+        This client uses HMAC-SHA256 signatures to ensure request integrity and
+        authenticity. The secret_key is never transmitted and is only used locally
+        to generate signatures.
+    """
+
+    def __init__(self, api_key: str, secret_key: str, api_url: str):
+        """
+        Initialize the API client.
+
+        Sets up the client with authentication credentials and validates that
+        all required parameters are provided.
+
+        Args:
+            api_key (str): Your API key from the AskPablos dashboard. This identifies
+                          your account and is included in the X-API-Key header.
+            secret_key (str): Your shared secret for HMAC signing. This is used to
+                             generate request signatures and must be kept secure.
+            api_url (str): The proxy API base URL. This should be the full URL to
+                          the proxy endpoint.
+
+        Raises:
+            AuthenticationError: If any required credential is missing or empty.
+        """
+        self.api_key = api_key
+        self.secret_key = secret_key
+        self.api_url = api_url
+
+        if not all([api_key, secret_key, api_url]):
+            raise AuthenticationError("API key, secret key, and API URL must all be provided")
+
+    def _generate_signature(self, payload: str) -> str:
+        """
+        Generate a base64-encoded HMAC SHA256 signature.
+
+        Creates a cryptographic signature of the request payload using the client's
+        secret key. This signature is used by the API server to verify that the
+        request came from an authorized client and hasn't been tampered with.
+
+        Args:
+            payload (str): JSON string of the request body that will be signed.
+                          This should be the exact JSON that will be sent in the
+                          HTTP request body.
+
+        Returns:
+            str: Base64 encoded HMAC-SHA256 signature of the payload.
+
+        Note:
+            The signature is generated using HMAC-SHA256 with the client's secret key.
+            The resulting binary signature is then base64-encoded for transmission
+            in HTTP headers.
+        """
+        signature = hmac.new(
+            self.secret_key.encode(),
+            payload.encode(),
+            hashlib.sha256
+        ).digest()
+        return base64.b64encode(signature).decode()
+
+    def _build_headers(self, payload: str) -> dict:
+        """
+        Construct request headers with API key and signature.
+
+        Builds the complete set of HTTP headers needed for API authentication,
+        including the content type, API key, and request signature.
+
+        Args:
+            payload (str): JSON string of the request body. Used to generate
+                          the authentication signature.
+
+        Returns:
+            dict: HTTP headers dictionary containing:
+                - Content-Type: Set to "application/json"
+                - X-API-Key: Your API key for identification
+                - X-Signature: HMAC-SHA256 signature of the payload
+        """
+        return {
+            'Content-Type': 'application/json',
+            'X-API-Key': self.api_key,
+            'X-Signature': self._generate_signature(payload)
+        }
+
+    def request(
+            self,
+            url: str,
+            method: str = "GET",
+            data: dict = None,
+            headers: dict = None,
+            params: dict = None,
+            options: dict = None,
+            timeout: int = 30
+    ) -> ResponseData:
+        """
+        Send a request through the AskPablos proxy.
+
+        This is the core method that handles communication with the AskPablos API.
+        It constructs the request payload, generates authentication headers,
+        and sends the HTTP request to the proxy service.
+
+        Args:
+            url (str): The target URL to fetch through the proxy. Must be a valid
+                      HTTP or HTTPS URL.
+            method (str, optional): HTTP method for the request. Supported methods
+                                  include GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS.
+                                  Defaults to "GET".
+            data (dict, optional): Request payload for POST/PUT requests. Will be
+                                 included in the request body sent to the target URL.
+            headers (dict, optional): Custom headers to send to the target URL.
+                                    These are forwarded to the target server, not
+                                    used for API authentication.
+            params (dict, optional): Query parameters to append to the target URL.
+            options (dict, optional): Proxy-specific options controlling how the
+                                    request is processed. See options below.
+            timeout (int, optional): Request timeout in seconds. If the proxy
+                                   doesn't respond within this time, the request
+                                   will be cancelled. Defaults to 30.
+
+        Proxy Options:
+            The options dictionary can contain:
+            - browser (bool): Use browser automation for JavaScript rendering
+            - rotate_proxy (bool): Use proxy rotation for this request
+            - user_agent (str): Custom user agent string
+            - cookies (dict): Cookies to include with the request
+            - Any other proxy-specific options supported by the API
+
+        Returns:
+            dict: The JSON response from the AskPablos API containing the results
+                 of the proxied request. The exact structure depends on the API
+                 version, but typically includes status_code, headers, content, etc.
+
+        Raises:
+            APIConnectionError: If the client cannot connect to the AskPablos API
+                              due to network issues, DNS problems, or timeouts.
+            ResponseError: If the API returns an HTTP error status code (4xx or 5xx).
+                         The exception will include the status code and error message.
+        """
+        # Initialize options dictionary if not provided
+        if options is None:
+            options = {}
+
+        # Create the request data - matching your exact format
+        request_data = {
+            "url": url,
+            "method": method.upper(),
+            "browser": options.get("browser", False),
+            "rotateProxy": options.get("rotate_proxy", False)
+        }
+
+        if data:
+            request_data["data"] = data
+
+        if headers:
+            request_data["headers"] = headers
+
+        if params:
+            request_data["params"] = params
+
+        # Add any additional options
+        for key, value in options.items():
+            if key not in ["browser", "rotate_proxy"]:
+                request_data[key] = value
+
+        # Convert to JSON with same separators as your example
+        payload = json.dumps(request_data, separators=(',', ':'))
+        headers = self._build_headers(payload)
+
+        try:
+            response = requests.post(self.api_url, data=payload, headers=headers, timeout=timeout)
+
+            if response.status_code >= 400:
+                error_msg = response.json().get('error', 'Unknown error') if response.text else 'No error details provided'
+                raise ResponseError(response.status_code, error_msg)
+
+            # Return complete response information
+            response_data = ResponseData(
+                url=response.url,
+                status_code=response.status_code,
+                headers=dict(response.headers),
+                content=json.loads(response.text).get('data'),
+                elapsed=response.elapsed.total_seconds(),
+                encoding=response.encoding
+            )
+
+            try:
+                response_data.json = response.json()
+            except (ValueError, json.JSONDecodeError):
+                response_data.json = None
+
+            return response_data
+        except requests.RequestException as e:
+            raise APIConnectionError(f"Failed to connect to API: {str(e)}")

askpablos_api/config.py

@@ -0,0 +1,20 @@
+"""
+askpablos_api.config
+
+Configuration settings for the AskPablos API client.
+
+This module contains default configuration values and settings that can be
+customized if needed. The primary API URL is defined here so users don't
+need to specify it when creating client instances.
+"""
+
+# Default API configuration
+DEFAULT_API_URL = "http://10.10.10.178:7500/api/proxy/"
+
+# Default request settings - matching your example
+DEFAULT_TIMEOUT = 30
+DEFAULT_ROTATE_PROXY = True
+DEFAULT_BROWSER = False
+
+# User agent for requests
+DEFAULT_USER_AGENT = "AskPablos-Python-Client/0.1.0"

askpablos_api/core.py

@@ -0,0 +1,113 @@
+"""
+askpablos_api.core
+
+Core functionality for the AskPablos proxy API client.
+
+This module provides the main AskPablos class, which serves as a simple interface
+for making GET requests through the AskPablos proxy service. The client handles
+authentication, error management, and request formatting automatically.
+"""
+
+from typing import Dict, Optional
+import logging
+
+from .client import ProxyClient, ResponseData
+from .utils import build_proxy_options
+from .exceptions import AskPablosError
+from .config import DEFAULT_API_URL
+
+logger = logging.getLogger("askpablos_api")
+
+
+class AskPablos:
+    """
+    Simple interface for making GET requests through the AskPablos proxy API.
+
+    This class provides a clean interface for sending GET requests through the
+    AskPablos proxy service. It handles authentication, request formatting,
+    and error management automatically.
+
+    The AskPablos class is designed to be simple and focused - it only supports
+    GET requests to keep the interface clean and easy to use.
+
+    Attributes:
+        client (ProxyClient): The underlying client for making API requests.
+
+    """
+
+    def __init__(self, api_key: str, secret_key: str):
+        """
+        Initialize the AskPablos API client.
+
+        Creates a new instance of the AskPablos client with the provided
+        authentication credentials. The client will use these credentials
+        for all subsequent API requests.
+
+        Args:
+            api_key (str): Your unique API key from the AskPablos dashboard.
+            secret_key (str): Your private secret key used for HMAC signing.
+
+        Raises:
+            AuthenticationError: If any of the required credentials are missing
+                                or invalid.
+        """
+        self.client = ProxyClient(api_key, secret_key, DEFAULT_API_URL)
+
+    def get(
+            self,
+            url: str,
+            params: Optional[Dict[str, str]] = None,
+            headers: Optional[Dict[str, str]] = None,
+            browser: bool = False,
+            rotate_proxy: bool = False,
+            timeout: int = 30,
+            **options
+    ) -> ResponseData:
+        """
+        Send a GET request through the AskPablos proxy.
+
+        This is the main method for fetching web pages and API endpoints through
+        the AskPablos proxy service. It supports various options for customizing
+        the request behavior.
+
+        Args:
+            url (str): The target URL to fetch. Must be a valid HTTP/HTTPS URL.
+            params (Dict[str, str], optional): URL query parameters to append.
+                                             Example: {"page": "1", "limit": "10"}
+            headers (Dict[str, str], optional): Custom headers for the request.
+            browser (bool, optional): Whether to use browser automation for
+                                    JavaScript rendering. Useful for SPAs and
+                                    dynamic content. Defaults to False.
+            rotate_proxy (bool, optional): Whether to use proxy rotation for this
+                                         request. Helps avoid rate limiting.
+                                         Defaults to True.
+            timeout (int, optional): Request timeout in seconds. Defaults to 30.
+            **options: Additional proxy options like user_agent, cookies, etc.
+
+        Returns:
+            ResponseData: The response object from the API containing:
+                - status_code (int): HTTP status code from the target server
+                - headers (Dict[str, str]): Response headers from target server
+                - content (str): Response body/content
+                - url (str): Final URL after any redirects
+                - elapsed (float): Time taken to complete the request in seconds
+                - encoding (Optional[str]): Response text encoding
+                - json (Optional[Dict[str, Any]]): Parsed JSON data if available
+
+        Raises:
+            APIConnectionError: If the client cannot connect to the AskPablos API.
+            ResponseError: If the API returns an error status code.
+            AuthenticationError: If authentication fails.
+        """
+        # Build proxy options
+        proxy_options = build_proxy_options(
+            browser=browser,
+            rotate_proxy=rotate_proxy,
+            **options
+        )
+
+        try:
+            return self.client.request(url=url, headers=headers, params=params, options=proxy_options, timeout=timeout)
+        except AskPablosError as e:
+            logger.error(f"GET request failed: {str(e)}")
+            raise

askpablos_api/exceptions.py

@@ -0,0 +1,79 @@
+"""
+askpablos_api.exceptions
+
+This module defines exceptions specific to the AskPablos API client.
+
+The exception hierarchy is designed to provide clear and specific error handling
+for different types of failures that can occur when interacting with the AskPablos
+API service.
+"""
+
+
+class AskPablosError(Exception):
+    """
+    Base exception for all AskPablos API errors.
+
+    This is the root exception class for all errors that can occur within the
+    AskPablos API client. All other exceptions inherit from this base class.
+    """
+    pass
+
+
+class AuthenticationError(AskPablosError):
+    """
+    Raised when there is an authentication problem with the API.
+
+    This exception is raised when:
+    - API key is missing or empty
+    - Secret key is missing or empty
+    - Authentication credentials are invalid
+    - HMAC signature verification fails
+    """
+    pass
+
+
+class APIConnectionError(AskPablosError):
+    """
+    Raised when the client fails to connect to the API.
+
+    This exception is raised when:
+    - Network connectivity issues prevent reaching the API
+    - DNS resolution fails for the API URL
+    - Connection timeouts occur
+    - The API server is unreachable or down
+    """
+    pass
+
+
+class ResponseError(AskPablosError):
+    """
+    Raised when there is an error in the API response.
+
+    This exception is raised when the AskPablos API returns an HTTP error
+    status code (4xx or 5xx). It includes both the status code and the
+    error message from the API response.
+
+    Common scenarios:
+    - 400 Bad Request: Invalid request parameters
+    - 401 Unauthorized: Authentication failed
+    - 403 Forbidden: Access denied
+    - 404 Not Found: Endpoint not found
+    - 429 Too Many Requests: Rate limit exceeded
+    - 500 Internal Server Error: Server error
+
+    Attributes:
+        status_code (int): The HTTP status code from the API response
+        message (str): The error message from the API response
+    """
+
+    def __init__(self, status_code: int, message: str):
+        """
+        Initialize a ResponseError with status code and message.
+
+        Args:
+            status_code (int): The HTTP status code from the API response
+            message (str): The error message describing what went wrong
+        """
+        self.status_code = status_code
+        self.message = message
+        super().__init__(f"API response error (status {status_code}): {message}")

askpablos_api/utils.py

@@ -0,0 +1,79 @@
+"""
+askpablos_api.utils
+
+Utility functions and helpers for the AskPablos API client.
+
+This module provides utility functions that support the main API client
+functionality, including logging configuration and option building.
+"""
+
+import logging
+from typing import Optional, Dict, Any
+
+# Configure logging
+logger = logging.getLogger("askpablos_api")
+
+
+def configure_logging(level: int = logging.INFO,
+                      format_string: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s") -> None:
+    """
+    Configure the logger for the AskPablos API package.
+
+    Sets up logging for the AskPablos API client with customizable log level
+    and format. This is useful for debugging API requests and understanding
+    what's happening during client operations.
+
+    Args:
+        level (int, optional): The logging level to use. Defaults to logging.INFO.
+        format_string (str, optional): The format string for log messages.
+
+    Example:
+        >>> from askpablos_api import configure_logging
+        >>> import logging
+        >>> configure_logging(level=logging.DEBUG)
+    """
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter(format_string)
+    handler.setFormatter(formatter)
+
+    logger.setLevel(level)
+    logger.addHandler(handler)
+    logger.propagate = False
+
+
+def build_proxy_options(browser: bool = False,
+                        rotate_proxy: bool = True,
+                        user_agent: Optional[str] = None,
+                        cookies: Optional[Dict[str, str]] = None,
+                        **kwargs) -> Dict[str, Any]:
+    """
+    Build a dictionary of options for the proxy request.
+
+    Creates a standardized options dictionary for proxy requests with common
+    parameters and defaults.
+
+    Args:
+        browser (bool, optional): Whether to use browser automation. Defaults to False.
+        rotate_proxy (bool, optional): Whether to use proxy rotation. Defaults to True.
+        user_agent (str, optional): Custom User-Agent string.
+        cookies (Dict[str, str], optional): Dictionary of cookies.
+        **kwargs: Additional options to include in the proxy request.
+
+    Returns:
+        Dict[str, Any]: Dictionary of proxy options.
+    """
+    options = {
+        "browser": browser,
+        "rotate_proxy": rotate_proxy
+    }
+
+    if user_agent:
+        options["user_agent"] = user_agent
+
+    if cookies:
+        options["cookies"] = cookies
+
+    # Add any additional options
+    options.update(kwargs)
+
+    return options

askpablos_api-0.1.0.dist-info/METADATA

@@ -0,0 +1,255 @@
+Metadata-Version: 2.4
+Name: askpablos-api
+Version: 0.1.0
+Summary: Professional Python client for the AskPablos proxy API service
+Author-email: Fawad Ali <fawadstar6@gmail.com>
+Maintainer-email: Fawad Ali <fawadstar6@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/fawadss1/askpablos-api
+Project-URL: Documentation, https://askpablos-api.readthedocs.io
+Project-URL: Repository, https://github.com/fawadss1/askpablos-api
+Project-URL: Bug Tracker, https://github.com/fawadss1/askpablos-api/issues
+Keywords: proxy,api,web-scraping,browser,http-client,askpablos
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Internet :: WWW/HTTP :: Browsers
+Classifier: Topic :: Internet :: Proxy Servers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.0; extra == "dev"
+Requires-Dist: black>=21.0; extra == "dev"
+Requires-Dist: flake8>=3.8; extra == "dev"
+Requires-Dist: mypy>=0.900; extra == "dev"
+Requires-Dist: pre-commit>=2.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=4.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=1.0; extra == "docs"
+Requires-Dist: myst-parser>=0.15; extra == "docs"
+Dynamic: license-file
+
+# AskPablos API Client
+[![PyPI Version](https://img.shields.io/pypi/v/askpablos-api.svg)](https://pypi.python.org/pypi/askpablos-api)
+[![Supported Python Versions](https://img.shields.io/pypi/pyversions/askpablos-api.svg)](https://pypi.python.org/pypi/askpablos-api)
+
+A simple Python client for making GET requests through the AskPablos proxy API service. This library provides a clean and easy-to-use interface for fetching web pages and APIs through the AskPablos proxy infrastructure.
+
+## Features
+
+- 🔐 **Secure Authentication**: HMAC-SHA256 signature-based authentication
+- 🌐 **Proxy Support**: Route requests through rotating proxies
+- 🤖 **Browser Integration**: Support for JavaScript-heavy websites
+- 🛡️ **Error Handling**: Comprehensive exception handling
+- 📊 **Logging**: Built-in logging support for debugging
+- 🎯 **Simple Interface**: GET-only requests for clean API
+
+## Installation
+
+```bash
+pip install askpablos-api
+```
+
+## Quick Start
+
+```python
+from askpablos_api import AskPablos
+
+# Initialize the client
+client = AskPablos(
+    api_key="your_api_key",
+    secret_key="your_secret_key"
+)
+
+# Make a simple GET request
+response = client.get("https://httpbin.org/ip")
+print(response)
+```
+
+## Authentication
+
+The AskPablos API uses HMAC-SHA256 signature-based authentication. You only need:
+
+1. **API Key**: Your unique API identifier
+2. **Secret Key**: Your private key for signing requests
+
+```python
+from askpablos_api import AskPablos
+
+client = AskPablos(
+    api_key="your_api_key",
+    secret_key="your_secret_key"
+)
+```
+
+## Usage Examples
+
+### Basic GET Requests
+
+```python
+# Simple GET request
+response = client.get("https://example.com")
+
+# GET with query parameters
+response = client.get(
+    "https://api.example.com/users",
+    params={"page": 1, "limit": 10}
+)
+
+# GET with custom headers
+response = client.get(
+    "https://api.example.com/data",
+    headers={"Authorization": "Bearer token123"}
+)
+```
+
+### Advanced Options
+
+```python
+# Use browser automation for JavaScript-heavy sites
+response = client.get(
+    "https://spa-website.com",
+    browser=True
+)
+
+# Disable proxy rotation
+response = client.get(
+    "https://example.com",
+    rotate_proxy=False
+)
+
+# Custom user agent and cookies
+response = client.get(
+    "https://example.com",
+    user_agent="Mozilla/5.0 (Custom Bot)",
+    cookies={"session": "abc123"}
+)
+
+# Custom timeout
+response = client.get(
+    "https://slow-website.com",
+    timeout=60
+)
+```
+
+### Error Handling
+
+```python
+from askpablos_api import (
+    AskPablos, 
+    AuthenticationError, 
+    APIConnectionError, 
+    ResponseError
+)
+
+try:
+    client = AskPablos(api_key="", secret_key="")
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+
+try:
+    response = client.get("https://example.com")
+except APIConnectionError as e:
+    print(f"Connection failed: {e}")
+except ResponseError as e:
+    print(f"API error {e.status_code}: {e.message}")
+```
+
+### Logging
+
+```python
+from askpablos_api import configure_logging
+import logging
+
+# Enable debug logging
+configure_logging(level=logging.DEBUG)
+
+client = AskPablos(api_key="...", secret_key="...")
+response = client.get("https://example.com")  # This will be logged
+```
+
+## API Reference
+
+### AskPablos Class
+
+The main interface for the API client.
+
+#### Constructor
+
+```python
+AskPablos(api_key: str, secret_key: str)
+```
+
+**Parameters:**
+- `api_key` (str): Your API key from the AskPablos dashboard
+- `secret_key` (str): Your secret key for HMAC signing
+
+#### Methods
+
+##### get()
+
+```python
+get(url, params=None, headers=None, browser=False, rotate_proxy=True, timeout=30, **options)
+```
+
+Send a GET request through the AskPablos proxy.
+
+**Parameters:**
+- `url` (str): Target URL to fetch
+- `params` (dict, optional): URL query parameters
+- `headers` (dict, optional): Custom headers
+- `browser` (bool, optional): Use browser automation (default: False)
+- `rotate_proxy` (bool, optional): Enable proxy rotation (default: True)
+- `timeout` (int, optional): Request timeout in seconds (default: 30)
+- `**options`: Additional options like user_agent, cookies, etc.
+
+**Returns:** Dictionary containing the API response
+
+### Exception Classes
+
+- `AskPablosError` - Base exception class
+- `AuthenticationError` - Authentication-related errors
+- `APIConnectionError` - Connection and network errors
+- `ResponseError` - API response errors
+
+## Response Format
+
+All successful requests return a dictionary with:
+
+```python
+{
+    "status_code": 200,
+    "headers": {"content-type": "text/html", ...},
+    "content": "Response body content",
+    "url": "Final URL after redirects",
+    "proxy_used": "proxy.example.com:8080",
+    "time_taken": 1.23
+}
+```
+
+## Requirements
+
+- Python 3.9+
+- requests >= 2.25.0
+
+## License
+
+This project is licensed under the MIT License.
+
+## Support
+
+For support and questions:
+- Email: fawadstar6@gmail.com

askpablos_api-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+askpablos_api/__init__.py,sha256=oFUjsefQY1uzVw_3gXySwfjif1uKozOjz6PU7vLezI0,562
+askpablos_api/client.py,sha256=8WE_mlL5HXxYwddvbY7BS0_FxY7VP6o_NzqABQBsU5A,10296
+askpablos_api/config.py,sha256=k4a9DWqqLqpi6Kj_SaMmugM0lMfdWLLqqakUWJXZ8wI,593
+askpablos_api/core.py,sha256=-flWGRtCIkjoFthnf5k-4tMVJ1qJqo0yXVrgENvXN8M,4692
+askpablos_api/exceptions.py,sha256=FbAlgo8yQ0L6aewT2atnfJVm2ty-8r9WHcx6uCMbrvw,2486
+askpablos_api/utils.py,sha256=0TAzmWutodhSIaHUiCvLlAb6fozDuOhDWZJiQgg-5BI,2584
+askpablos_api-0.1.0.dist-info/licenses/LICENSE,sha256=DhJQ4_j45c_DWghISLKmJshcLvX_Pr7QXaahe2iRMNo,1087
+askpablos_api-0.1.0.dist-info/METADATA,sha256=n9Wm6aINVDWr53vifsNNUJIcl-S32jeTv1GaQoz69Xk,7047
+askpablos_api-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+askpablos_api-0.1.0.dist-info/top_level.txt,sha256=XM61mjwJQtG8sSxvUHD_yMOQKguLv3Yh0hc5S2zHlYc,14
+askpablos_api-0.1.0.dist-info/RECORD,,

askpablos_api-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

askpablos_api-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Fawad Ali
+
+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.

askpablos_api-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+askpablos_api