GitHub | PyPI | Issues | Changelog

ghreq is a simple wrapper around requests with various customizations aimed at working with the GitHub REST API. Notable features include:

• When making a request, you only need to specify the part of the URL after the API base URL. You can even construct objects for making requests with a URL baked in.
• All request methods return decoded JSON by default.
• 4xx and 5xx responses are automatically raised as errors without needing to call raise_for_status().
• Errors raised for 4xx and 5xx responses include the body of the response in the error message.
• Support for iterating over paginated results
• The Accept and X-GitHub-Api-Version headers are automatically set to their recommended values.
• Follows GitHub's recommendations for dealing with rate limits, including waiting between mutating requests and waiting & retrying in response to rate-limit errors
• Automatic retrying on 5xx errors with exponential backoff

Installation

ghreq requires Python 3.10 or higher. Just use pip for Python 3 (You have pip, right?) to install it:

python3 -m pip install ghreq

Example

from ghreq import Client

with Client(token="your-api-token-here") as client:
    user = client.get("/user")
    print("I am user", user["login"])
    print()

    print("Here are my repositories:")
    for repo in client.paginate("/user/repos"):
        print(repo["full_name"])
    print()

    hello_world = client / "repos" / "octocat" / "Hello-World"
    details = hello_world.get()
    print(f"{details['full_name']} has been starred {details['stargazers_count']} times.")
    print("Here is the first page of its open issues & PRs:")
    for issue in (hello_world / "issues").get():
        print(f"#{issue['number']}: {issue['title']}")

API

Client Class

class Client:
    def __init__(
        *,
        token: str | None = None,
        api_url: str = DEFAULT_API_URL,
        session: requests.Session | None = None,
        set_headers: bool | None = None,
        user_agent: str | None = None,
        accept: str | None = DEFAULT_ACCEPT,
        api_version: str | None = DEFAULT_API_VERSION,
        mutation_delay: float = 1.0,
        retry_config: RetryConfig | None = None,
    )

An HTTP client class for interacting with the GitHub REST API (or sufficiently similar APIs).

Constructor arguments:

token

The GitHub access token, if any, to use to authenticate to the API.

This argument is ignored if set_headers is False or defaulted to False.

api_url

The base URL to which to append paths passed to the request methods

session

A pre-configured requests.Session instance to use for making requests. If no session is supplied, a new session is instantiated.

set_headers

Whether to set various headers for requests made via the session. If set_headers is None, it is defaulted to True if session is None and to False otherwise.

If set_headers is True or defaulted to True, the following request headers are set on the session:

• Accept (if accept is non-None)
• Authorization (set to "Bearer {token}" if token is non-None)
• User-Agent (if user_agent is non-None)
• X-GitHub-Api-Version (if api_version is non-None)
• any additional headers included in headers

If set_headers is False or defaulted to False, then Client does not set any headers on the session, and the other header-related parameters are ignored.

user_agent

A user agent string to include in the headers of requests. If not set, the requests library's default user agent is used.

This argument is ignored if set_headers is False or defaulted to False.

accept

Value to set the Accept header to. Can be set to None to not set the header at all.

This argument is ignored if set_headers is False or defaulted to False.

api_version

Value to set the X-GitHub-Api-Version header to. Can be set to None to not set the header at all.

This argument is ignored if set_headers is False or defaulted to False.

headers

Optional mapping of additional headers to set on the session after setting all other headers.

This argument is ignored if set_headers is False or defaulted to False.

mutation_delay

When making a POST, PATCH, PUT, or DELETE request, if the time since the last such request is fewer than mutation_delay seconds, then the client will sleep long enough to make up the difference before performing the request.

retry_config

Configuration for the request retrying mechanism. If not set, a RetryConfig instance with all default attributes will be used; see below.

Client instances can be used as context managers, in which case they close their internal requests.Session instances on exit (regardless of whether the session was user-provided or not).

A Client instance can be "divided" by a string (e.g., client / "user") to obtain an Endpoint instance that makes requests to the URL formed from api_url and the "divisor"; see below.

Client.request(
    method: str,
    path: str,
    json: Any = None,
    *,
    params: ParamsType = None,
    headers: HeadersType = None,
    data: DataType = None,
    timeout: TimeoutType = None,
    allow_redirects: bool = True,
    stream: bool = False,
    raw: bool = False,
) -> Any

Perform an HTTP request with the given method/verb. If path begins with http:// or https://, it is used as-is for the URL of the request. Otherwise, path is appended to the api_url value supplied to the constructor, with a forward slash inserted in between if there isn't one present already. Thus, given a client constructed with the default api_url, the following are equivalent:

client.request("GET", "user")

client.request("GET", "/user")

client.request("GET", "https://api.github.com/user")

If the request is successful, the body is decoded as JSON and returned; if the body is empty (except possibly for whitespace), None is returned. To make the method return the actual requests.Response object instead, pass raw=True (or stream=True, which implies it).

The remaining arguments have the same meaning as in requests.

If the request fails, it may be retried with exponentially increasing wait times between attempts; see the documentation of RetryConfig below. If all retries are exhausted without success, the exception from the final request is raised.

If the request fails with a 4xx or 5xx response, a PrettyHTTPError is raised.

Client.get(
    path: str,
    *,
    params: ParamsType = None,
    headers: HeadersType = None,
    timeout: TimeoutType = None,
    stream: bool = False,
    raw: bool = False,
) -> Any

Perform a GET request. See the documentation of request() for more information.

Client.post(
    path: str,
    json: Any = None,
    *,
    params: ParamsType = None,
    headers: HeadersType = None,
    data: DataType = None,
    timeout: TimeoutType = None,
    stream: bool = False,
    raw: bool = False,
) -> Any

Perform a POST request. See the documentation of request() for more information.

Client.put(
    path: str,
    json: Any = None,
    *,
    params: ParamsType = None,
    headers: HeadersType = None,
    data: DataType = None,
    timeout: TimeoutType = None,
    stream: bool = False,
    raw: bool = False,
) -> Any

Perform a PUT request. See the documentation of request() for more information.

Client.patch(
    path: str,
    json: Any = None,
    *,
    params: ParamsType = None,
    headers: HeadersType = None,
    data: DataType = None,
    timeout: TimeoutType = None,
    stream: bool = False,
    raw: bool = False,
) -> Any

Perform a PATCH request. See the documentation of request() for more information.

Client.delete(
    path: str,
    json: Any = None,
    *,
    params: ParamsType = None,
    headers: HeadersType = None,
    data: DataType = None,
    timeout: TimeoutType = None,
    stream: bool = False,
    raw: bool = False,
) -> Any

Perform a DELETE request. See the documentation of request() for more information.

Client.paginate(
    path: str,
    *,
    params: ParamsType = None,
    headers: HeadersType = None,
    timeout: TimeoutType = None,
    raw: Literal[True, False] = False,
) -> Iterator

Perform a series of paginated GET requests and yield the items from each page. The path and params arguments are only used for the initial request; further requests follow the "next" entry in the Link header of each response.

The bodies of the responses must be either JSON lists (in which case the list elements are yielded) or JSON objects in which exactly one field is a list (in which case the elements of that list are yielded); otherwise, an error occurs.

If raw is True, then instead of yielding each page's items, the returned iterator will yield each page as a requests.Response object.

Client.close() -> None

Close the client's internal requests.Session. No more request methods may be called afterwards.

This method is called automatically on exit when using Client as a context manager.

Endpoint Class

class Endpoint:
    client: Client
    url: str

A combination of a Client instance and a URL. Endpoint has request(), get(), post(), put(), patch(), delete(), and paginate() methods that work the same way as for Client, except that Endpoint's methods do not take path arguments; instead, they make requests to the stored URL. This is useful if you find yourself making requests to the same URL and/or paths under the same URL over & over.

An Endpoint instance is constructed by applying the / (division) operator to a Client or Endpoint instance on the left and a string on the right. If the string begins with http:// or https://, it is used as-is for the URL of the resulting Endpoint. Otherwise, the string is appended to the api_url or url attribute of the object on the left, with a forward slash inserted in between if there isn't one present already. Thus, given a client constructed with the default api_url, the following are equivalent:

client.get("repos/octocat/hello-world")

(client / "repos/octocat/hello-world").get()

(client / "repos" / "octocat" / "hello-world").get()

RetryConfig Class

class RetryConfig:
    def __init__(
        retries: int = 10,
        backoff_factor: float = 1.0,
        backoff_base: float = 1.25,
        backoff_jitter: float = 0.0
        backoff_max: float = 120.0,
        total_wait: float | None = 300.0,
        retry_statuses: Container[int] = range(500, 600),
    )

A container for storing configuration for ghreq's retrying mechanism. A request is retried if (a) a response.RequestException is raised that is not a ValueError (e.g., a connection or timeout error), (b) the server responds with a 403 status code and either the Retry-After header is present or the body contains the string "rate limit", or (c) the server responds with a status code listed in retry_statuses.

When a request is retried, the client sleeps for increasing amounts of time between repeated requests until either a non-retriable response is obtained, retries retry attempts have been performed, or the total amount of time elapsed since the start of the first request exceeds total_wait, if set.

The first retry happens after sleeping for backoff_factor * 0.1 seconds, and subsequent retries happen after sleeping for backoff_factor * backoff_base ** (retry_number - 1) + random.random() * backoff_jitter seconds, up to a maximum of backoff_max per retry. If a Retry-After or x-ratelimit-reset header indicates a larger duration to sleep for, that value is used instead. If the duration indicated by such a header would result in the next retry attempt being after total_wait is exceeded, retrying stops early.

PrettyHTTPError Class

class PrettyHTTPError(requests.HTTPError)

A subclass of requests.HTTPError raised automatically by the request methods if a response with a 4xx or 5xx status code is received. Unlike its parent class, stringifying a PrettyHTTPError will produce a string that contains the body of the response; if the body was JSON, that JSON will be pretty-printed.

Constants

DEFAULT_ACCEPT = "application/vnd.github+json"

The default value of the accept argument to the Client constructor

DEFAULT_API_URL = "https://api.github.com"

The default value of the api_url argument to the Client constructor

DEFAULT_API_VERSION = "2022-11-28"

The default value of the api_version argument to the Client constructor

Utility Functions

make_user_agent(name: str, version: str | None = None, url: str | None = None) -> str

Create a user agent string with the given client name, optional version, and optional URL. The string will also include the version of the requests library used and the implemention & version of Python.

get_github_api_url() -> str

If the GITHUB_API_URL environment variable is set to a nonempty string, that string is returned; otherwise, DEFAULT_API_URL is returned.