Advanced Features

# Request interceptor - adds auth token to every request
async def auth_interceptor(config):
    config.headers['Authorization'] = 'Bearer my-secret-token'
    return config

# Request interceptor - logs each request
async def log_interceptor(config):
    print(f"Request: {config.method} {config.url}")
    return config

# Response interceptor - handles errors globally
async def error_interceptor(response):
    if response.status >= 400:
        print(f"Error {response.status}: {response.status_text}")
    return response

# Register interceptors
client.interceptors.use(auth_interceptor)
client.interceptors.use(log_interceptor)
client.interceptors.use(error_interceptor, is_response=True)

# Remove an interceptor by index
index = client.interceptors.use(some_interceptor)
client.interceptors.eject(index)

def on_upload(loaded, total):
    percent = (loaded / total) * 100 if total > 0 else 0
    print(f"Uploading: {percent:.1f}% ({loaded}/{total} bytes)")

def on_download(loaded, total):
    percent = (loaded / total) * 100 if total > 0 else 0
    print(f"Downloading: {percent:.1f}%")

# Large file upload with progress
with open('large_file.bin', 'rb') as f:
    response = await client.post(
        'https://httpbin.org/post',
        data=f,
        on_upload_progress=on_upload
    )

# Download with progress
response = await client.get(
    'https://httpbin.org/bytes/50000',
    on_download_progress=on_download,
    response_type='blob'
)

from atomhttp import AtomHTTP

form = AtomHTTP.FormData()
form.append('username', 'johndoe')
form.append('email', 'john@example.com')
form.append('avatar', open('profile.jpg', 'rb'), filename='profile.jpg')
form.append('document', open('resume.pdf', 'rb'), filename='resume.pdf')

# Supports multiple values for the same field
form.append('tags', 'python')
form.append('tags', 'http')
form.append('tags', 'async')

response = await client.post('https://api.example.com/upload', data=form)

# Using AtomHTTP.all() for concurrent execution
tasks = [
    client.get('/posts/1'),
    client.get('/posts/2'),
    client.get('/posts/3')
]
responses = await AtomHTTP.all(tasks)

for resp in responses:
    print(f"Post {resp.data['id']}: {resp.status}")

# Using spread() to distribute responses to individual arguments
def process_results(res1, res2, res3):
    return {
        'first': res1.data['title'],
        'second': res2.data['title'],
        'third': res3.data['title']
    }

result = await AtomHTTP.spread(process_results, *responses)

# Transform request data - convert strings to uppercase
client.defaults.transformRequest = lambda data: data.upper() if isinstance(data, str) else data

# Transform response data - add timestamp and metadata
client.defaults.transformResponse = lambda data: {
    'timestamp': time.time(),
    'content': data,
    'version': 'v2'
} if isinstance(data, dict) else data

response = await client.post('/api/message', data='hello world')
print(response.data)
# {
#     'timestamp': 1700000000,
#     'content': 'hello world',
#     'version': 'v2'
# }

from atomhttp.auth import BasicAuth, BearerAuth

# Basic Authentication - encodes credentials as base64
basic = BasicAuth('username', 'password')
response = await client.get('https://httpbin.org/basic-auth/username/password',
                           headers=basic.get_header())

# Bearer Token Authentication - adds token directly
bearer = BearerAuth('your-jwt-token-here')
response = await client.get('https://api.example.com/protected',
                           headers=bearer.get_header())

# Using interceptors for complex auth flows
async def oauth_interceptor(config):
    token = await get_oauth_token()
    config.headers['Authorization'] = f'Bearer {token}'
    return config

client.interceptors.use(oauth_interceptor)

# Download as Blob (bytes) - best for small to medium files
response = await client.get('https://httpbin.org/image/png', response_type='blob')
image_data = response.data  # bytes

# Save to file
with open('image.png', 'wb') as f:
    f.write(image_data)

# Download as ArrayBuffer (alias for blob)
response = await client.get('https://httpbin.org/bytes/10000', response_type='arraybuffer')
binary_data = response.data  # bytes

# Download as Stream - best for very large files
response = await client.get('https://example.com/large-file.zip', response_type='stream')
async for chunk in response.data:
    process_chunk(chunk)

client = AtomHTTP({
    'timeout': 30,
    'maxRedirects': 5,
    'maxBodyLength': 10 * 1024 * 1024,   # 10MB
    'maxContentLength': 50 * 1024 * 1024, # 50MB
    'keepAlive': True,
    'socketPath': '/var/run/docker.sock',
    'decompress': True
})

# Override timeout for a specific request
response = await client.get('https://slow-api.com', timeout=5)