Auth
****

class praw.models.Auth(reddit: Reddit, _data: Optional[Dict[str, Any]])

   Auth provides an interface to Reddit’s authorization.

   __init__(reddit: Reddit, _data: Optional[Dict[str, Any]])

      Initialize a PRAWModel instance.

      Parameters:
         **reddit** – An instance of "Reddit".

   authorize(code: str) -> Optional[str]

      Complete the web authorization flow and return the refresh
      token.

      Parameters:
         **code** – The code obtained through the request to the
         redirect uri.

      Returns:
         The obtained refresh token, if available, otherwise "None".

      The session’s active authorization will be updated upon success.

   implicit(access_token: str, expires_in: int, scope: str) -> None

      Set the active authorization to be an implicit authorization.

      Parameters:
         * **access_token** – The access_token obtained from Reddit’s
           callback.

         * **expires_in** – The number of seconds the "access_token"
           is valid for. The origin of this value was returned from
           Reddit’s callback. You may need to subtract an offset
           before passing in this number to account for a delay
           between when Reddit prepared the response, and when you
           make this function call.

         * **scope** – A space-delimited string of Reddit OAuth2 scope
           names as returned from Reddit’s callback.

      Raises:
         "InvalidImplicitAuth" if "Reddit" was initialized for a non-
         installed application type.

   property limits

      Return a dictionary containing the rate limit info.

      The keys are:

      Remaining:
         The number of requests remaining to be made in the current
         rate limit window.

      Reset_timestamp:
         A unix timestamp providing an upper bound on when the rate
         limit counters will reset.

      Used:
         The number of requests made in the current rate limit window.

      All values are initially "None" as these values are set in
      response to issued requests.

      The "reset_timestamp" value is an upper bound as the real
      timestamp is computed on Reddit’s end in preparation for sending
      the response. This value may change slightly within a given
      window due to slight changes in response times and rounding.

   classmethod parse(data: Dict[str, Any], reddit: Reddit) -> Any

      Return an instance of "cls" from "data".

      Parameters:
         * **data** – The structured data.

         * **reddit** – An instance of "Reddit".

   scopes() -> Set[str]

      Return a set of scopes included in the current authorization.

      For read-only authorizations this should return "{"*"}".

   url(scopes: List[str], state: str, duration: str = 'permanent', implicit: bool = False) -> str

      Return the URL used out-of-band to grant access to your
      application.

      Parameters:
         * **scopes** – A list of OAuth scopes to request
           authorization for.

         * **state** – A string that will be reflected in the callback
           to "redirect_uri". This value should be temporarily unique
           to the client for whom the URL was generated for.

         * **duration** – Either "permanent" or "temporary" (default:
           permanent). "temporary" authorizations generate access
           tokens that last only 1 hour. "permanent" authorizations
           additionally generate a refresh token that can be
           indefinitely used to generate new hour-long access tokens.
           This value is ignored when "implicit=True".

         * **implicit** – For **installed** applications, this value
           can be set to use the implicit, rather than the code flow.
           When True, the "duration" argument has no effect as only
           temporary tokens can be retrieved.
