tessl/pypi-httpie

HTTPie: modern, user-friendly command-line HTTP client for the API era.

—

Pending

Overview

Eval results

Files

HTTP Client

Name: tessl/pypi-httpie
Author: tessl

HTTPie's HTTP client module provides low-level functions for building and sending HTTP requests programmatically.

from httpie.client import collect_messages, build_requests_session, make_request_kwargs, make_send_kwargs, finalize_headers
from httpie.context import Environment
from httpie.models import RequestsMessage
from typing import Iterable, Callable
import argparse
import requests

Capabilities

Message Collection

Core function for collecting HTTP request and response messages.

def collect_messages(
    env: Environment,
    args: argparse.Namespace,
    request_body_read_callback: Callable[[bytes], None] = None,
) -> Iterable[RequestsMessage]:
    """
    Core message collection and HTTP execution.
    
    Args:
        env: HTTPie environment instance
        args: Parsed command-line arguments
        request_body_read_callback: Optional callback for request body streaming
        
    Yields:
        RequestsMessage: HTTP request and response messages
    """

Session Building

Functions for building HTTP sessions with custom configurations.

def build_requests_session(
    session_name: str = None,
    config_dir: str = None,
    read_only: bool = False,
    **session_kwargs
) -> requests.Session:
    """
    Build a requests session with HTTPie configurations.
    
    Args:
        session_name: Name of persistent session
        config_dir: Configuration directory path
        read_only: Whether session should be read-only
        **session_kwargs: Additional session configuration
        
    Returns:
        requests.Session: Configured HTTP session
    """

Request Preparation

Utilities for preparing HTTP request parameters.

def make_request_kwargs(
    args: argparse.Namespace,
    base_headers: dict = None
) -> dict:
    """
    Build keyword arguments for requests.request().
    
    Args:
        args: Parsed command-line arguments
        base_headers: Base headers to include
        
    Returns:
        dict: Request keyword arguments
    """

def make_send_kwargs(args: argparse.Namespace) -> dict:
    """
    Build keyword arguments for session.send().
    
    Args:
        args: Parsed command-line arguments
        
    Returns:
        dict: Send keyword arguments
    """

def finalize_headers(headers: dict) -> dict:
    """
    Finalize headers before sending request.
    
    Args:
        headers: Request headers dictionary
        
    Returns:
        dict: Finalized headers
    """

Usage Examples

Basic Message Collection

from httpie.core import main
from httpie.client import collect_messages
from httpie.context import Environment
from httpie.cli.definition import parser

# Parse arguments
env = Environment()
args = parser.parse_args(['GET', 'httpie.io/hello'], env=env)

# Collect messages
for message in collect_messages(env, args):
    if hasattr(message, 'status_code'):
        print(f"Response: {message.status_code}")
    else:
        print(f"Request: {message.method}")

Custom Session Building

from httpie.client import build_requests_session

# Build session with custom configuration
session = build_requests_session(
    session_name='api-client',
    timeout=30,
    verify=True
)

# Use session for requests
response = session.get('https://api.example.com/data')

Request Preparation

from httpie.client import make_request_kwargs
from httpie.cli.definition import parser
from httpie.context import Environment

# Parse arguments
env = Environment()
args = parser.parse_args(['POST', 'api.example.com', 'name=John'], env=env)

# Prepare request kwargs
request_kwargs = make_request_kwargs(args)
print(f"Method: {request_kwargs['method']}")
print(f"URL: {request_kwargs['url']}")
print(f"Data: {request_kwargs.get('data', 'None')}")

Install with Tessl CLI