class TwitchAPI(object):
    """Twitch API client."""

    def __init__(self, client_id, oauth_token=None):
        """Initialize the API."""
        super(TwitchAPI, self).__init__()
        self._client_id = client_id
        self._oauth_token = oauth_token
        self._initial_backoff, self._max_retries = backoff_config()

    def _get_request_headers(self):
        """Prepare the headers for the requests."""
        headers = {
            "Accept": "application/vnd.twitchtv.v5+json",
            "Client-ID": self._client_id,
        }

        if self._oauth_token:
            headers["Authorization"] = "OAuth {}".format(self._oauth_token)

        return headers

    def _request_get(self, path, params=None, json=True, url=BASE_URL):
        """Perform a HTTP GET request."""
        url = urljoin(url, path)
        headers = self._get_request_headers()

        response = requests.get(url, params=params, headers=headers)
        if response.status_code >= 500:

            backoff = self._initial_backoff
            for _ in range(self._max_retries):
                time.sleep(backoff)
                backoff_response = requests.get(
                    url, params=params, headers=headers, timeout=DEFAULT_TIMEOUT
                )
                if backoff_response.status_code < 500:
                    response = backoff_response
                    break
                backoff *= 2

        response.raise_for_status()
        if json:
            return response.json()
        else:
            return response

    def _request_post(self, path, data=None, params=None, url=BASE_URL):
        """Perform a HTTP POST request.."""
        url = urljoin(url, path)

        headers = self._get_request_headers()

        response = requests.post(
            url, json=data, params=params, headers=headers, timeout=DEFAULT_TIMEOUT
        )
        response.raise_for_status()
        if response.status_code == 200:
            return response.json()

    def _request_put(self, path, data=None, params=None, url=BASE_URL):
        """Perform a HTTP PUT request."""
        url = urljoin(url, path)

        headers = self._get_request_headers()
        response = requests.put(
            url, json=data, params=params, headers=headers, timeout=DEFAULT_TIMEOUT
        )
        response.raise_for_status()
        if response.status_code == 200:
            return response.json()

    def _request_delete(self, path, params=None, url=BASE_URL):
        """Perform a HTTP DELETE request."""
        url = urljoin(url, path)

        headers = self._get_request_headers()

        response = requests.delete(
            url, params=params, headers=headers, timeout=DEFAULT_TIMEOUT
        )
        response.raise_for_status()
        if response.status_code == 200:
            return response.json() BROADCAST_TYPE_HIGHLIGHT = "highlight" BROADCAST_TYPES = [
    BROADCAST_TYPE_ARCHIVE,
    BROADCAST_TYPE_HIGHLIGHT,
    BROADCAST_TYPE_UPLOAD,
    BROADCAST_TYPE_ARCHIVE_UPLOAD,
    BROADCAST_TYPE_ARCHIVE_HIGHLIGHT,
    BROADCAST_TYPE_HIGHLIGHT_UPLOAD,
    BROADCAST_TYPE_ALL,
] DIRECTION_ASC = "asc" DIRECTION_DESC = "desc" DIRECTIONS = [DIRECTION_ASC, DIRECTION_DESC] VIDEO_SORT_TIME = "time" VIDEO_SORTS = [VIDEO_SORT_TIME, VIDEO_SORT_TRENDING, VIDEO_SORT_VIEWS] def oauth_required(func):
    def wrapper(*args, **kwargs):
        if not args[0]._oauth_token:
            raise TwitchAuthException("OAuth token required")
        return func(*args, **kwargs)

    return wrapper class TwitchAttributeException(TwitchException):
    pass class Channel(TwitchObject):
    pass class Community(TwitchObject):
    pass class Follow(TwitchObject):
    pass class Subscription(TwitchObject):
    pass class Team(TwitchObject):
    pass class User(TwitchObject):
    pass class Video(TwitchObject):
    pass
from twitch.api.base import TwitchAPI
from twitch.constants import (
    BROADCAST_TYPE_HIGHLIGHT,
    BROADCAST_TYPES,
    DIRECTION_ASC,
    DIRECTION_DESC,
    DIRECTIONS,
    VIDEO_SORT_TIME,
    VIDEO_SORTS,
)
from twitch.decorators import oauth_required
from twitch.exceptions import TwitchAttributeException
from twitch.resources import Channel, Community, Follow, Subscription, Team, User, Video


class Channels(TwitchAPI):
    @oauth_required
    def get(self):
        response = self._request_get("channel")
        return Channel.construct_from(response)

    def get_by_id(self, channel_id):
        response = self._request_get("channels/{}".format(channel_id))
        return Channel.construct_from(response)

    @oauth_required
    def update(
        self, channel_id, status=None, game=None, delay=None, channel_feed_enabled=None
    ):
        data = {}
        if status is not None:
            data["status"] = status
        if game is not None:
            data["game"] = game
        if delay is not None:
            data["delay"] = delay
        if channel_feed_enabled is not None:
            data["channel_feed_enabled"] = channel_feed_enabled

        post_data = {"channel": data}
        response = self._request_put("channels/{}".format(channel_id), post_data)
        return Channel.construct_from(response)

    @oauth_required
    def get_editors(self, channel_id):
        response = self._request_get("channels/{}/editors".format(channel_id))
        return [User.construct_from(x) for x in response["users"]]

    def get_followers(

        self, channel_id, limit=25, offset=0, cursor=None, direction=DIRECTION_DESC