The Reddit Instance
*******************

class praw.Reddit(site_name: Optional[str] = None, config_interpolation: Optional[str] = None, requestor_class: Optional[Type[prawcore.requestor.Requestor]] = None, requestor_kwargs: Optional[Dict[str, Any]] = None, **config_settings: Union[str, bool])

   The Reddit class provides convenient access to Reddit’s API.

   Instances of this class are the gateway to interacting with
   Reddit’s API through PRAW. The canonical way to obtain an instance
   of this class is via:

      import praw

      reddit = praw.Reddit(
          client_id="CLIENT_ID",
          client_secret="CLIENT_SECRET",
          password="PASSWORD",
          user_agent="USERAGENT",
          username="USERNAME",
      )

   __init__(site_name: Optional[str] = None, config_interpolation: Optional[str] = None, requestor_class: Optional[Type[prawcore.requestor.Requestor]] = None, requestor_kwargs: Optional[Dict[str, Any]] = None, **config_settings: Union[str, bool])

      Initialize a Reddit instance.

      Parameters:
         * **site_name** – The name of a section in your "praw.ini"
           file from which to load settings from. This parameter, in
           tandem with an appropriately configured "praw.ini", file is
           useful if you wish to easily save credentials for different
           applications, or communicate with other servers running
           Reddit. If "site_name" is "None", then the site name will
           be looked for in the environment variable praw_site. If it
           is not found there, the DEFAULT site will be used.

         * **requestor_class** – A class that will be used to create a
           requestor. If not set, use "prawcore.Requestor" (default:
           None).

         * **requestor_kwargs** – Dictionary with additional keyword
           arguments used to initialize the requestor (default: None).

      Additional keyword arguments will be used to initialize the
      "Config" object. This can be used to specify configuration
      settings during instantiation of the "Reddit" instance. For more
      details, please see Configuring PRAW.

      Required settings are:

      * client_id

      * client_secret (for installed applications set this value to
        "None")

      * user_agent

      The "requestor_class" and "requestor_kwargs" allow for
      customization of the requestor "Reddit" will use. This allows,
      e.g., easily adding behavior to the requestor or wrapping its
      "Session" in a caching layer. Example usage:

         import json

         import betamax
         import requests
         from prawcore import Requestor

         from praw import Reddit


         class JSONDebugRequestor(Requestor):
             def request(self, *args, **kwargs):
                 response = super().request(*args, **kwargs)
                 print(json.dumps(response.json(), indent=4))
                 return response


         my_session = betamax.Betamax(requests.Session())
         reddit = Reddit(
             ..., requestor_class=JSONDebugRequestor, requestor_kwargs={"session": my_session}
         )

   auth

      An instance of "Auth".

      Provides the interface for interacting with installed and web
      applications.

      See also: Obtain the Authorization URL

   comment(id: Optional[str] = None, url: Optional[str] = None)

      Return a lazy instance of "Comment".

      Parameters:
         * **id** – The ID of the comment.

         * **url** – A permalink pointing to the comment.

      Note:

        If you want to obtain the comment’s replies, you will need to
        call "refresh()" on the returned "Comment".

   delete(path: str, data: Optional[Union[Dict[str, Union[str, Any]], bytes, IO, str]] = None, json=None) -> Any

      Return parsed objects returned from a DELETE request to "path".

      Parameters:
         * **path** – The path to fetch.

         * **data** – Dictionary, bytes, or file-like object to send
           in the body of the request (default: None).

         * **json** – JSON-serializable object to send in the body of
           the request with a Content-Type header of application/json
           (default: None). If "json" is provided, "data" should not
           be.

   domain(domain: str)

      Return an instance of "DomainListing".

      Parameters:
         **domain** – The domain to obtain submission listings for.

   front

      An instance of "Front".

      Provides the interface for interacting with front page listings.
      For example:

         for submission in reddit.front.hot():
             print(submission)

   get(path: str, params: Optional[Union[str, Dict[str, Union[str, int]]]] = None)

      Return parsed objects returned from a GET request to "path".

      Parameters:
         * **path** – The path to fetch.

         * **params** – The query parameters to add to the request
           (default: None).

   inbox

      An instance of "Inbox".

      Provides the interface to a user’s inbox which produces
      "Message", "Comment", and "Submission" instances. For example,
      to iterate through comments which mention the authorized user
      run:

         for comment in reddit.inbox.mentions():
             print(comment)

   info(fullnames: Optional[Iterable[str]] = None, url: Optional[str] = None, subreddits: Optional[Iterable[Union[praw.models.reddit.subreddit.Subreddit, str]]] = None) -> Generator[Union[praw.models.reddit.subreddit.Subreddit, praw.models.reddit.comment.Comment, praw.models.reddit.submission.Submission], None, None]

      Fetch information about each item in "fullnames", "url", or
      "subreddits".

      Parameters:
         * **fullnames** – A list of fullnames for comments,
           submissions, and/or subreddits.

         * **url** – A url (as a string) to retrieve lists of link
           submissions from.

         * **subreddits** – A list of subreddit names or Subreddit
           objects to retrieve subreddits from.

      Returns:
         A generator that yields found items in their relative order.

      Items that cannot be matched will not be generated. Requests
      will be issued in batches for each 100 fullnames.

      Note:

        For comments that are retrieved via this method, if you want
        to obtain its replies, you will need to call "refresh()" on
        the yielded "Comment".

      Note:

        When using the URL option, it is important to be aware that
        URLs are treated literally by Reddit’s API. As such, the URLs
        “youtube.com” and “https://www.youtube.com” will provide a
        different set of submissions.

   live

      An instance of "LiveHelper".

      Provides the interface for working with "LiveThread" instances.
      At present only new LiveThreads can be created.

         reddit.live.create("title", "description")

   multireddit

      An instance of "MultiredditHelper".

      Provides the interface to working with "Multireddit" instances.
      For example you can obtain a "Multireddit" instance via:

         reddit.multireddit("samuraisam", "programming")

   patch(path: str, data: Optional[Union[Dict[str, Union[str, Any]], bytes, IO, str]] = None, json=None) -> Any

      Return parsed objects returned from a PATCH request to "path".

      Parameters:
         * **path** – The path to fetch.

         * **data** – Dictionary, bytes, or file-like object to send
           in the body of the request (default: None).

         * **json** – JSON-serializable object to send in the body of
           the request with a Content-Type header of application/json
           (default: None). If "json" is provided, "data" should not
           be.

   post(path: str, data: Optional[Union[Dict[str, Union[str, Any]], bytes, IO, str]] = None, files: Optional[Dict[str, IO]] = None, params: Optional[Union[str, Dict[str, str]]] = None, json=None) -> Any

      Return parsed objects returned from a POST request to "path".

      Parameters:
         * **path** – The path to fetch.

         * **data** – Dictionary, bytes, or file-like object to send
           in the body of the request (default: None).

         * **files** – Dictionary, filename to file (like) object
           mapping (default: None).

         * **params** – The query parameters to add to the request
           (default: None).

         * **json** – JSON-serializable object to send in the body of
           the request with a Content-Type header of application/json
           (default: None). If "json" is provided, "data" should not
           be.

   put(path: str, data: Optional[Union[Dict[str, Union[str, Any]], bytes, IO, str]] = None, json=None)

      Return parsed objects returned from a PUT request to "path".

      Parameters:
         * **path** – The path to fetch.

         * **data** – Dictionary, bytes, or file-like object to send
           in the body of the request (default: None).

         * **json** – JSON-serializable object to send in the body of
           the request with a Content-Type header of application/json
           (default: None). If "json" is provided, "data" should not
           be.

   random_subreddit(nsfw: bool = False) -> praw.models.reddit.subreddit.Subreddit

      Return a random lazy instance of "Subreddit".

      Parameters:
         **nsfw** – Return a random NSFW (not safe for work) subreddit
         (default: False).

   property read_only

      Return True when using the ReadOnlyAuthorizer.

   redditor(name: Optional[str] = None, fullname: Optional[str] = None) -> praw.models.reddit.redditor.Redditor

      Return a lazy instance of "Redditor".

      Parameters:
         * **name** – The name of the redditor.

         * **fullname** – The fullname of the redditor, starting with
           "t2_".

      Either "name" or "fullname" can be provided, but not both.

   redditors

      An instance of "Redditors".

      Provides the interface for Redditor discovery. For example, to
      iterate over the newest Redditors, run:

         for redditor in reddit.redditors.new(limit=None):
             print(redditor)

   request(method: str, path: str, params: Optional[Union[str, Dict[str, Union[str, int]]]] = None, data: Optional[Union[Dict[str, Union[str, Any]], bytes, IO, str]] = None, files: Optional[Dict[str, IO]] = None, json=None) -> Any

      Return the parsed JSON data returned from a request to URL.

      Parameters:
         * **method** – The HTTP method (e.g., GET, POST, PUT,
           DELETE).

         * **path** – The path to fetch.

         * **params** – The query parameters to add to the request
           (default: None).

         * **data** – Dictionary, bytes, or file-like object to send
           in the body of the request (default: None).

         * **files** – Dictionary, filename to file (like) object
           mapping (default: None).

         * **json** – JSON-serializable object to send in the body of
           the request with a Content-Type header of application/json
           (default: None). If "json" is provided, "data" should not
           be.

   submission(id: Optional[str] = None, url: Optional[str] = None) -> praw.models.reddit.submission.Submission

      Return a lazy instance of "Submission".

      Parameters:
         * **id** – A Reddit base36 submission ID, e.g., "2gmzqe".

         * **url** – A URL supported by "id_from_url()".`.

      Either "id" or "url" can be provided, but not both.

   subreddit

      An instance of "SubredditHelper".

      Provides the interface to working with "Subreddit" instances.
      For example to create a Subreddit run:

         reddit.subreddit.create("coolnewsubname")

      To obtain a lazy "Subreddit" instance run:

         reddit.subreddit("redditdev")

      Multiple subreddits can be combined and filtered views of r/all
      can also be used just like a subreddit:

         reddit.subreddit("redditdev+learnpython+botwatch")
         reddit.subreddit("all-redditdev-learnpython")

   subreddits

      An instance of "Subreddits".

      Provides the interface for "Subreddit" discovery. For example,
      to iterate over the set of default subreddits run:

         for subreddit in reddit.subreddits.default(limit=None):
             print(subreddit)

   user

      An instance of "User".

      Provides the interface to the currently authorized "Redditor".
      For example to get the name of the current user run:

         print(reddit.user.me())

   property validate_on_submit

      Get validate_on_submit.

      Deprecated since version 7.0: If property "validate_on_submit"
      is set to False, the behavior is deprecated by Reddit. This
      attribute will be removed around May-June 2020.

Helper Classes

* reddit.front

* reddit.inbox

* reddit.live

* reddit.multireddit

* reddit.redditors

* reddit.subreddit

* reddit.subreddits

* reddit.user
