27 files changed, 3049 insertions, 2859 deletions
diff --git a/mastodon/Mastodon.py b/mastodon/Mastodon.py
index 0ded1cf..23e4d9e 100644
--- a/mastodon/Mastodon.py
+++ b/mastodon/Mastodon.py
@@ -26,7 +26,7 @@ from .utility import parse_version_string, max_version, api_version
 from .utility import AttribAccessDict, AttribAccessDict
 from .utility import Mastodon as Utility
-from .error import *
+from .errors import *
 from .versions import _DICT_VERSION_APPLICATION, _DICT_VERSION_MENTION, _DICT_VERSION_MEDIA, _DICT_VERSION_ACCOUNT, _DICT_VERSION_POLL, \
                        _DICT_VERSION_STATUS, _DICT_VERSION_INSTANCE, _DICT_VERSION_HASHTAG, _DICT_VERSION_EMOJI, _DICT_VERSION_RELATIONSHIP, \
                        _DICT_VERSION_NOTIFICATION, _DICT_VERSION_CONTEXT, _DICT_VERSION_LIST, _DICT_VERSION_CARD, _DICT_VERSION_SEARCHRESULT, \
@@ -45,11 +45,33 @@ from .accounts import Mastodon as Accounts
 from .instance import Mastodon as Instance
 from .timeline import Mastodon as Timeline
 from .statuses import Mastodon as Statuses
+from .media import Mastodon as Media
+from .polls import Mastodon as Polls
+from .notifications import Mastodon as Notifications
+from .conversations import Mastodon as Conversations
+from .hashtags import Mastodon as Hashtags
+from .filters import Mastodon as Filters
+from .suggestions import Mastodon as Suggestions
+from .endorsements import Mastodon as Endorsements
+from .relationships import Mastodon as Relationships
+from .lists import Mastodon as Lists
+from .trends import Mastodon as Trends
+from .search import Mastodon as Search
+from .favourites import Mastodon as Favourites
+from .reports import Mastodon as Reports
+from .preferences import Mastodon as Preferences
+from .push import Mastodon as Push
+from .admin import Mastodon as Admin
+from .streaming_endpoints import Mastodon as Streaming
-##
+###
 # The actual Mastodon class
+#
+# Almost all code is now imported from smaller files to make editing a bit more pleasant
 ###
-class Mastodon(Utility, Authentication, Accounts, Instance, Timeline, Statuses):
+class Mastodon(Utility, Authentication, Accounts, Instance, Timeline, Statuses, Polls, Notifications, Hashtags, 
+                Filters, Suggestions, Endorsements, Relationships, Lists, Trends, Search, Favourites, Reports, 
+                Preferences, Push, Admin, Conversations, Media, Streaming):
    """
    Thorough and easy to use Mastodon
    API wrapper in Python.
@@ -65,2827 +87,3 @@ class Mastodon(Utility, Authentication, Accounts, Instance, Timeline, Statuses):
        Retrieve the maximum version of Mastodon supported by this version of Mastodon.py
        """
        return Mastodon.__SUPPORTED_MASTODON_VERSION
-    ###
-    # Reading data: Polls
-    ###
-    @api_version("2.8.0", "2.8.0", _DICT_VERSION_POLL)
-    def poll(self, id):
-        """
-        Fetch information about the poll with the given id
-        Returns a :ref:`poll dict <poll dict>`.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/polls/{0}'.format(str(id))
-        return self.__api_request('GET', url)
-    ###
-    # Reading data: Notifications
-    ###
-    @api_version("1.0.0", "3.5.0", _DICT_VERSION_NOTIFICATION)
-    def notifications(self, id=None, account_id=None, max_id=None, min_id=None, since_id=None, limit=None, exclude_types=None, types=None, mentions_only=None):
-        """
-        Fetch notifications (mentions, favourites, reblogs, follows) for the logged-in
-        user. Pass `account_id` to get only notifications originating from the given account.
-        There are different types of notifications: 
-            * `follow` - A user followed the logged in user
-            * `follow_request` - A user has requested to follow the logged in user (for locked accounts)
-            * `favourite` - A user favourited a post by the logged in user
-            * `reblog` - A user reblogged a post by the logged in user
-            * `mention` - A user mentioned the logged in user
-            * `poll` - A poll the logged in user created or voted in has ended
-            * `update` - A status the logged in user has reblogged (and only those, as of 4.0.0) has been edited
-            * `status` - A user that the logged in user has enabned notifications for has enabled `notify` (see :ref:`account_follow() <account_follow()>`)
-            * `admin.sign_up` - For accounts with appropriate permissions (TODO: document which those are when adding the permission API): A new user has signed up
-            * `admin.report` - For accounts with appropriate permissions (TODO: document which those are when adding the permission API): A new report has been received
-        Parameters `exclude_types` and `types` are array of these types, specifying them will in- or exclude the
-        types of notifications given. It is legal to give both parameters at the same tine, the result will then
-        be the intersection of the results of both filters. Specifying `mentions_only` is a deprecated way to set 
-        `exclude_types` to all but mentions.
-        Can be passed an `id` to fetch a single notification.
-        Returns a list of :ref:`notification dicts <notification dicts>`.
-        """
-        if mentions_only is not None:
-            if exclude_types is None and types is None:
-                if mentions_only:
-                    if self.verify_minimum_version("3.5.0", cached=True):
-                        types = ["mention"]
-                    else:
-                        exclude_types = ["follow", "favourite", "reblog", "poll", "follow_request"]
-            else:
-                raise MastodonIllegalArgumentError('Cannot specify exclude_types/types when mentions_only is present')
-            del mentions_only
-        if max_id is not None:
-            max_id = self.__unpack_id(max_id, dateconv=True)
-        if min_id is not None:
-            min_id = self.__unpack_id(min_id, dateconv=True)
-        if since_id is not None:
-            since_id = self.__unpack_id(since_id, dateconv=True)
-        if account_id is not None:
-            account_id = self.__unpack_id(account_id)
-        if id is None:
-            params = self.__generate_params(locals(), ['id'])
-            return self.__api_request('GET', '/api/v1/notifications', params)
-        else:
-            id = self.__unpack_id(id)
-            url = '/api/v1/notifications/{0}'.format(str(id))
-            return self.__api_request('GET', url)
-    ###
-    # Reading data: Accounts
-    ###
-    @api_version("1.0.0", "1.0.0", _DICT_VERSION_ACCOUNT)
-    def account(self, id):
-        """
-        Fetch account information by user `id`.
-        Does not require authentication for publicly visible accounts.
-        Returns a :ref:`account dict <account dict>`.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/accounts/{0}'.format(str(id))
-        return self.__api_request('GET', url)
-    @api_version("1.0.0", "2.1.0", _DICT_VERSION_ACCOUNT)
-    def account_verify_credentials(self):
-        """
-        Fetch logged-in user's account information.
-        Returns a :ref:`account dict <account dict>` (Starting from 2.1.0, with an additional "source" field).
-        """
-        return self.__api_request('GET', '/api/v1/accounts/verify_credentials')
-    @api_version("1.0.0", "2.1.0", _DICT_VERSION_ACCOUNT)
-    def me(self):
-        """
-        Get this user's account. Synonym for `account_verify_credentials()`, does exactly
-        the same thing, just exists becase `account_verify_credentials()` has a confusing
-        name.
-        """
-        return self.account_verify_credentials()
-    @api_version("1.0.0", "2.8.0", _DICT_VERSION_STATUS)
-    def account_statuses(self, id, only_media=False, pinned=False, exclude_replies=False, exclude_reblogs=False, tagged=None, max_id=None, min_id=None, since_id=None, limit=None):
-        """
-        Fetch statuses by user `id`. Same options as :ref:`timeline() <timeline()>` are permitted.
-        Returned toots are from the perspective of the logged-in user, i.e.
-        all statuses visible to the logged-in user (including DMs) are
-        included.
-        If `only_media` is set, return only statuses with media attachments.
-        If `pinned` is set, return only statuses that have been pinned. Note that
-        as of Mastodon 2.1.0, this only works properly for instance-local users.
-        If `exclude_replies` is set, filter out all statuses that are replies.
-        If `exclude_reblogs` is set, filter out all statuses that are reblogs.
-        If `tagged` is set, return only statuses that are tagged with `tagged`. Only a single tag without a '#' is valid.
-        Does not require authentication for Mastodon versions after 2.7.0 (returns
-        publicly visible statuses in that case), for publicly visible accounts.
-        Returns a list of :ref:`status dicts <status dicts>`.
-        """
-        id = self.__unpack_id(id)
-        if max_id is not None:
-            max_id = self.__unpack_id(max_id, dateconv=True)
-        if min_id is not None:
-            min_id = self.__unpack_id(min_id, dateconv=True)
-        if since_id is not None:
-            since_id = self.__unpack_id(since_id, dateconv=True)
-        params = self.__generate_params(locals(), ['id'])
-        if not pinned:
-            del params["pinned"]
-        if not only_media:
-            del params["only_media"]
-        if not exclude_replies:
-            del params["exclude_replies"]
-        if not exclude_reblogs:
-            del params["exclude_reblogs"]
-        url = '/api/v1/accounts/{0}/statuses'.format(str(id))
-        return self.__api_request('GET', url, params)
-    @api_version("1.0.0", "2.6.0", _DICT_VERSION_ACCOUNT)
-    def account_following(self, id, max_id=None, min_id=None, since_id=None, limit=None):
-        """
-        Fetch users the given user is following.
-        Returns a list of :ref:`account dicts <account dicts>`.
-        """
-        id = self.__unpack_id(id)
-        if max_id is not None:
-            max_id = self.__unpack_id(max_id, dateconv=True)
-        if min_id is not None:
-            min_id = self.__unpack_id(min_id, dateconv=True)
-        if since_id is not None:
-            since_id = self.__unpack_id(since_id, dateconv=True)
-        params = self.__generate_params(locals(), ['id'])
-        url = '/api/v1/accounts/{0}/following'.format(str(id))
-        return self.__api_request('GET', url, params)
-    @api_version("1.0.0", "2.6.0", _DICT_VERSION_ACCOUNT)
-    def account_followers(self, id, max_id=None, min_id=None, since_id=None, limit=None):
-        """
-        Fetch users the given user is followed by.
-        Returns a list of :ref:`account dicts <account dicts>`.
-        """
-        id = self.__unpack_id(id)
-        if max_id is not None:
-            max_id = self.__unpack_id(max_id, dateconv=True)
-        if min_id is not None:
-            min_id = self.__unpack_id(min_id, dateconv=True)
-        if since_id is not None:
-            since_id = self.__unpack_id(since_id, dateconv=True)
-        params = self.__generate_params(locals(), ['id'])
-        url = '/api/v1/accounts/{0}/followers'.format(str(id))
-        return self.__api_request('GET', url, params)
-    @api_version("1.0.0", "1.4.0", _DICT_VERSION_RELATIONSHIP)
-    def account_relationships(self, id):
-        """
-        Fetch relationship (following, followed_by, blocking, follow requested) of
-        the logged in user to a given account. `id` can be a list.
-        Returns a list of :ref:`relationship dicts <relationship dicts>`.
-        """
-        id = self.__unpack_id(id)
-        params = self.__generate_params(locals())
-        return self.__api_request('GET', '/api/v1/accounts/relationships',
-                                  params)
-    @api_version("1.0.0", "2.3.0", _DICT_VERSION_ACCOUNT)
-    def account_search(self, q, limit=None, following=False):
-        """
-        Fetch matching accounts. Will lookup an account remotely if the search term is
-        in the username@domain format and not yet in the database. Set `following` to
-        True to limit the search to users the logged-in user follows.
-        Returns a list of :ref:`account dicts <account dicts>`.
-        """
-        params = self.__generate_params(locals())
-        if params["following"] == False:
-            del params["following"]
-        return self.__api_request('GET', '/api/v1/accounts/search', params)
-    @api_version("2.1.0", "2.1.0", _DICT_VERSION_LIST)
-    def account_lists(self, id):
-        """
-        Get all of the logged-in user's lists which the specified user is
-        a member of.
-        Returns a list of :ref:`list dicts <list dicts>`.
-        """
-        id = self.__unpack_id(id)
-        params = self.__generate_params(locals(), ['id'])
-        url = '/api/v1/accounts/{0}/lists'.format(str(id))
-        return self.__api_request('GET', url, params)
-    @api_version("3.4.0", "3.4.0", _DICT_VERSION_ACCOUNT)
-    def account_lookup(self, acct):
-        """
-        Look up an account from user@instance form (@instance allowed but not required for
-        local accounts). Will only return accounts that the instance already knows about, 
-        and not do any webfinger requests. Use `account_search` if you need to resolve users 
-        through webfinger from remote.
-        Returns an :ref:`account dict <account dict>`.
-        """
-        return self.__api_request('GET', '/api/v1/accounts/lookup', self.__generate_params(locals()))
-    
-    @api_version("3.5.0", "3.5.0", _DICT_VERSION_FAMILIAR_FOLLOWERS)
-    def account_familiar_followers(self, id):
-        """
-        Find followers for the account given by id (can be a list) that also follow the
-        logged in account.
-        Returns a list of :ref:`familiar follower dicts <familiar follower dicts>`
-        """
-        if not isinstance(id, list):
-            id = [id]
-        for i in range(len(id)):
-            id[i] = self.__unpack_id(id[i])
-        return self.__api_request('GET', '/api/v1/accounts/familiar_followers', {'id': id}, use_json=True)
-    ###
-    # Reading data: Featured hashtags
-    ###
-    @api_version("3.0.0", "3.0.0", _DICT_VERSION_FEATURED_TAG)
-    def featured_tags(self):
-        """
-        Return the hashtags the logged-in user has set to be featured on
-        their profile as a list of :ref:`featured tag dicts <featured tag dicts>`.
-        Returns a list of :ref:`featured tag dicts <featured tag dicts>`.
-        """
-        return self.__api_request('GET', '/api/v1/featured_tags')
-    @api_version("3.0.0", "3.0.0", _DICT_VERSION_HASHTAG)
-    def featured_tag_suggestions(self):
-        """
-        Returns the logged-in user's 10 most commonly-used hashtags.
-        Returns a list of :ref:`hashtag dicts <hashtag dicts>`.
-        """
-        return self.__api_request('GET', '/api/v1/featured_tags/suggestions')
-    ###
-    # Reading data: Keyword filters
-    ###
-    @api_version("2.4.3", "2.4.3", _DICT_VERSION_FILTER)
-    def filters(self):
-        """
-        Fetch all of the logged-in user's filters.
-        Returns a list of :ref:`filter dicts <filter dicts>`. Not paginated.
-        """
-        return self.__api_request('GET', '/api/v1/filters')
-    @api_version("2.4.3", "2.4.3", _DICT_VERSION_FILTER)
-    def filter(self, id):
-        """
-        Fetches information about the filter with the specified `id`.
-        Returns a :ref:`filter dict <filter dict>`.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/filters/{0}'.format(str(id))
-        return self.__api_request('GET', url)
-    @api_version("2.4.3", "2.4.3", _DICT_VERSION_FILTER)
-    def filters_apply(self, objects, filters, context):
-        """
-        Helper function: Applies a list of filters to a list of either statuses
-        or notifications and returns only those matched by none. This function will
-        apply all filters that match the context provided in `context`, i.e.
-        if you want to apply only notification-relevant filters, specify
-        'notifications'. Valid contexts are 'home', 'notifications', 'public' and 'thread'.
-        """
-        # Build filter regex
-        filter_strings = []
-        for keyword_filter in filters:
-            if not context in keyword_filter["context"]:
-                continue
-            filter_string = re.escape(keyword_filter["phrase"])
-            if keyword_filter["whole_word"]:
-                filter_string = "\\b" + filter_string + "\\b"
-            filter_strings.append(filter_string)
-        filter_re = re.compile("|".join(filter_strings), flags=re.IGNORECASE)
-        # Apply
-        filter_results = []
-        for filter_object in objects:
-            filter_status = filter_object
-            if "status" in filter_object:
-                filter_status = filter_object["status"]
-            filter_text = filter_status["content"]
-            filter_text = re.sub(r"<.*?>", " ", filter_text)
-            filter_text = re.sub(r"\s+", " ", filter_text).strip()
-            if not filter_re.search(filter_text):
-                filter_results.append(filter_object)
-        return filter_results
-    ###
-    # Reading data: Follow suggestions
-    ###
-    @api_version("2.4.3", "2.4.3", _DICT_VERSION_ACCOUNT)
-    def suggestions(self):
-        """
-        Fetch follow suggestions for the logged-in user.
-        Returns a list of :ref:`account dicts <account dicts>`.
-        """
-        return self.__api_request('GET', '/api/v1/suggestions')
-    ###
-    # Reading data: Follow suggestions
-    ###
-    @api_version("3.0.0", "3.0.0", _DICT_VERSION_ACCOUNT)
-    def directory(self, offset=None, limit=None, order=None, local=None):
-        """
-        Fetch the contents of the profile directory, if enabled on the server.
-        `offset` how many accounts to skip before returning results. Default 0.
-        `limit` how many accounts to load. Default 40.
-        `order` "active" to sort by most recently posted statuses (default) or
-                "new" to sort by most recently created profiles.
-        `local` True to return only local accounts.
-        Returns a list of :ref:`account dicts <account dicts>`.
-        """
-        params = self.__generate_params(locals())
-        return self.__api_request('GET', '/api/v1/directory', params)
-    ###
-    # Reading data: Endorsements
-    ###
-    @api_version("2.5.0", "2.5.0", _DICT_VERSION_ACCOUNT)
-    def endorsements(self):
-        """
-        Fetch list of users endorsed by the logged-in user.
-        Returns a list of :ref:`account dicts <account dicts>`.
-        """
-        return self.__api_request('GET', '/api/v1/endorsements')
-    ###
-    # Reading data: Searching
-    ###
-    def __ensure_search_params_acceptable(self, account_id, offset, min_id, max_id):
-        """
-        Internal Helper: Throw a MastodonVersionError if version is < 2.8.0 but parameters
-        for search that are available only starting with 2.8.0 are specified.
-        """
-        if any(item is not None for item in (account_id, offset, min_id, max_id)):
-            if not self.verify_minimum_version("2.8.0", cached=True):
-                raise MastodonVersionError("Advanced search parameters require Mastodon 2.8.0+")
-    @api_version("1.1.0", "2.8.0", _DICT_VERSION_SEARCHRESULT)
-    def search(self, q, resolve=True, result_type=None, account_id=None, offset=None, min_id=None, max_id=None, exclude_unreviewed=True):
-        """
-        Fetch matching hashtags, accounts and statuses. Will perform webfinger
-        lookups if resolve is True. Full-text search is only enabled if
-        the instance supports it, and is restricted to statuses the logged-in
-        user wrote or was mentioned in.
-        `result_type` can be one of "accounts", "hashtags" or "statuses", to only
-        search for that type of object.
-        Specify `account_id` to only get results from the account with that id.
-        `offset`, `min_id` and `max_id` can be used to paginate.
-        `exclude_unreviewed` can be used to restrict search results for hashtags to only
-        those that have been reviewed by moderators. It is on by default. When using the
-        v1 search API (pre 2.4.1), it is ignored.
-        Will use search_v1 (no tag dicts in return values) on Mastodon versions before
-        2.4.1), search_v2 otherwise. Parameters other than resolve are only available
-        on Mastodon 2.8.0 or above - this function will throw a MastodonVersionError
-        if you try to use them on versions before that. Note that the cached version
-        number will be used for this to avoid uneccesary requests.
-        Returns a :ref:`search result dict <search result dict>`, with tags as `hashtag dicts`_.
-        """
-        if self.verify_minimum_version("2.4.1", cached=True):
-            return self.search_v2(q, resolve=resolve, result_type=result_type, account_id=account_id, offset=offset, min_id=min_id, max_id=max_id, exclude_unreviewed=exclude_unreviewed)
-        else:
-            self.__ensure_search_params_acceptable(
-                account_id, offset, min_id, max_id)
-            return self.search_v1(q, resolve=resolve)
-    @api_version("1.1.0", "2.1.0", "2.1.0")
-    def search_v1(self, q, resolve=False):
-        """
-        Identical to `search_v2()`, except in that it does not return
-        tags as :ref:`hashtag dicts <hashtag dicts>`.
-        Returns a :ref:`search result dict <search result dict>`.
-        """
-        params = self.__generate_params(locals())
-        if not resolve:
-            del params['resolve']
-        return self.__api_request('GET', '/api/v1/search', params)
-    @api_version("2.4.1", "2.8.0", _DICT_VERSION_SEARCHRESULT)
-    def search_v2(self, q, resolve=True, result_type=None, account_id=None, offset=None, min_id=None, max_id=None, exclude_unreviewed=True):
-        """
-        Identical to `search_v1()`, except in that it returns tags as
-        :ref:`hashtag dicts <hashtag dicts>`, has more parameters, and resolves by default.
-        For more details documentation, please see `search()`
-        Returns a :ref:`search result dict <search result dict>`.
-        """
-        self.__ensure_search_params_acceptable(
-            account_id, offset, min_id, max_id)
-        params = self.__generate_params(locals())
-        if not resolve:
-            del params["resolve"]
-        if not exclude_unreviewed or not self.verify_minimum_version("3.0.0", cached=True):
-            del params["exclude_unreviewed"]
-        if "result_type" in params:
-            params["type"] = params["result_type"]
-            del params["result_type"]
-        return self.__api_request('GET', '/api/v2/search', params)
-    ###
-    # Reading data: Trends
-    ###
-    @api_version("2.4.3", "3.5.0", _DICT_VERSION_HASHTAG)
-    def trends(self, limit=None):
-        """
-        Alias for :ref:`trending_tags() <trending_tags()>`
-        """
-        return self.trending_tags(limit=limit) 
-    @api_version("3.5.0", "3.5.0", _DICT_VERSION_HASHTAG)
-    def trending_tags(self, limit=None, lang=None):
-        """
-        Fetch trending-hashtag information, if the instance provides such information.
-        Specify `limit` to limit how many results are returned (the maximum number
-        of results is 10, the endpoint is not paginated).
-        Does not require authentication unless locked down by the administrator.
-        Important versioning note: This endpoint does not exist for Mastodon versions
-        between 2.8.0 (inclusive) and 3.0.0 (exclusive). 
-        Pass `lang` to override the global locale parameter, which may affect trend ordering.
-        Returns a list of :ref:`hashtag dicts <hashtag dicts>`, sorted by the instance's trending algorithm,
-        descending.
-        """
-        params = self.__generate_params(locals())
-        if self.verify_minimum_version("3.5.0", cached=True):
-            # Starting 3.5.0, old version is deprecated
-            return self.__api_request('GET', '/api/v1/trends/tags', params)
-        else:
-            return self.__api_request('GET', '/api/v1/trends', params)
-    @api_version("3.5.0", "3.5.0", _DICT_VERSION_STATUS)
-    def trending_statuses(self):
-        """
-        Fetch trending-status information, if the instance provides such information.
-        Specify `limit` to limit how many results are returned (the maximum number
-        of results is 10, the endpoint is not paginated).
-        Pass `lang` to override the global locale parameter, which may affect trend ordering.
-        Returns a list of :ref:`status dicts <status dicts>`, sorted by the instances's trending algorithm,
-        descending.
-        """
-        params = self.__generate_params(locals())
-        return self.__api_request('GET', '/api/v1/trends/statuses', params)
-    @api_version("3.5.0", "3.5.0", _DICT_VERSION_CARD)
-    def trending_links(self):
-        """
-        Fetch trending-link information, if the instance provides such information.
-        Specify `limit` to limit how many results are returned (the maximum number
-        of results is 10, the endpoint is not paginated).
-        Returns a list of :ref:`card dicts <card dicts>`, sorted by the instances's trending algorithm,
-        descending.
-        """
-        params = self.__generate_params(locals())
-        return self.__api_request('GET', '/api/v1/trends/links', params)
-    ###
-    # Reading data: Lists
-    ###
-    @api_version("2.1.0", "2.1.0", _DICT_VERSION_LIST)
-    def lists(self):
-        """
-        Fetch a list of all the Lists by the logged-in user.
-        Returns a list of :ref:`list dicts <list dicts>`.
-        """
-        return self.__api_request('GET', '/api/v1/lists')
-    @api_version("2.1.0", "2.1.0", _DICT_VERSION_LIST)
-    def list(self, id):
-        """
-        Fetch info about a specific list.
-        Returns a :ref:`list dict <list dict>`.
-        """
-        id = self.__unpack_id(id)
-        return self.__api_request('GET', '/api/v1/lists/{0}'.format(id))
-    @api_version("2.1.0", "2.6.0", _DICT_VERSION_ACCOUNT)
-    def list_accounts(self, id, max_id=None, min_id=None, since_id=None, limit=None):
-        """
-        Get the accounts that are on the given list.
-        Returns a list of :ref:`account dicts <account dicts>`.
-        """
-        id = self.__unpack_id(id)
-        if max_id is not None:
-            max_id = self.__unpack_id(max_id, dateconv=True)
-        if min_id is not None:
-            min_id = self.__unpack_id(min_id, dateconv=True)
-        if since_id is not None:
-            since_id = self.__unpack_id(since_id, dateconv=True)
-        params = self.__generate_params(locals(), ['id'])
-        return self.__api_request('GET', '/api/v1/lists/{0}/accounts'.format(id))
-    ###
-    # Reading data: Mutes and Blocks
-    ###
-    @api_version("1.1.0", "2.6.0", _DICT_VERSION_ACCOUNT)
-    def mutes(self, max_id=None, min_id=None, since_id=None, limit=None):
-        """
-        Fetch a list of users muted by the logged-in user.
-        Returns a list of :ref:`account dicts <account dicts>`.
-        """
-        if max_id is not None:
-            max_id = self.__unpack_id(max_id, dateconv=True)
-        if min_id is not None:
-            min_id = self.__unpack_id(min_id, dateconv=True)
-        if since_id is not None:
-            since_id = self.__unpack_id(since_id, dateconv=True)
-        params = self.__generate_params(locals())
-        return self.__api_request('GET', '/api/v1/mutes', params)
-    @api_version("1.0.0", "2.6.0", _DICT_VERSION_ACCOUNT)
-    def blocks(self, max_id=None, min_id=None, since_id=None, limit=None):
-        """
-        Fetch a list of users blocked by the logged-in user.
-        Returns a list of :ref:`account dicts <account dicts>`.
-        """
-        if max_id is not None:
-            max_id = self.__unpack_id(max_id, dateconv=True)
-        if min_id is not None:
-            min_id = self.__unpack_id(min_id, dateconv=True)
-        if since_id is not None:
-            since_id = self.__unpack_id(since_id, dateconv=True)
-        params = self.__generate_params(locals())
-        return self.__api_request('GET', '/api/v1/blocks', params)
-    ###
-    # Reading data: Reports
-    ###
-    @api_version("1.1.0", "1.1.0", _DICT_VERSION_REPORT)
-    def reports(self):
-        """
-        Fetch a list of reports made by the logged-in user.
-        Returns a list of :ref:`report dicts <report dicts>`.
-        Warning: This method has now finally been removed, and will not
-        work on Mastodon versions 2.5.0 and above.
-        """
-        if self.verify_minimum_version("2.5.0", cached=True):
-            raise MastodonVersionError("API removed in Mastodon 2.5.0")
-        return self.__api_request('GET', '/api/v1/reports')
-    ###
-    # Reading data: Favourites
-    ###
-    @api_version("1.0.0", "2.6.0", _DICT_VERSION_STATUS)
-    def favourites(self, max_id=None, min_id=None, since_id=None, limit=None):
-        """
-        Fetch the logged-in user's favourited statuses.
-        Returns a list of :ref:`status dicts <status dicts>`.
-        """
-        if max_id is not None:
-            max_id = self.__unpack_id(max_id, dateconv=True)
-        if min_id is not None:
-            min_id = self.__unpack_id(min_id, dateconv=True)
-        if since_id is not None:
-            since_id = self.__unpack_id(since_id, dateconv=True)
-        params = self.__generate_params(locals())
-        return self.__api_request('GET', '/api/v1/favourites', params)
-    ###
-    # Reading data: Follow requests
-    ###
-    @api_version("1.0.0", "2.6.0", _DICT_VERSION_ACCOUNT)
-    def follow_requests(self, max_id=None, min_id=None, since_id=None, limit=None):
-        """
-        Fetch the logged-in user's incoming follow requests.
-        Returns a list of :ref:`account dicts <account dicts>`.
-        """
-        if max_id is not None:
-            max_id = self.__unpack_id(max_id, dateconv=True)
-        if min_id is not None:
-            min_id = self.__unpack_id(min_id, dateconv=True)
-        if since_id is not None:
-            since_id = self.__unpack_id(since_id, dateconv=True)
-        params = self.__generate_params(locals())
-        return self.__api_request('GET', '/api/v1/follow_requests', params)
-    ###
-    # Reading data: Domain blocks
-    ###
-    @api_version("1.4.0", "2.6.0", "1.4.0")
-    def domain_blocks(self, max_id=None, min_id=None, since_id=None, limit=None):
-        """
-        Fetch the logged-in user's blocked domains.
-        Returns a list of blocked domain URLs (as strings, without protocol specifier).
-        """
-        if max_id is not None:
-            max_id = self.__unpack_id(max_id, dateconv=True)
-        if min_id is not None:
-            min_id = self.__unpack_id(min_id, dateconv=True)
-        if since_id is not None:
-            since_id = self.__unpack_id(since_id, dateconv=True)
-        params = self.__generate_params(locals())
-        return self.__api_request('GET', '/api/v1/domain_blocks', params)
-    ###
-    # Reading data: Emoji
-    ###
-    @api_version("2.1.0", "2.1.0", _DICT_VERSION_EMOJI)
-    def custom_emojis(self):
-        """
-        Fetch the list of custom emoji the instance has installed.
-        Does not require authentication unless locked down by the administrator.
-        Returns a list of :ref:`emoji dicts <emoji dicts>`.
-        """
-        return self.__api_request('GET', '/api/v1/custom_emojis')
-    ###
-    # Reading data: Apps
-    ###
-    @api_version("2.0.0", "2.7.2", _DICT_VERSION_APPLICATION)
-    def app_verify_credentials(self):
-        """
-        Fetch information about the current application.
-        Returns an :ref:`application dict <application dict>`.
-        """
-        return self.__api_request('GET', '/api/v1/apps/verify_credentials')
-    ###
-    # Reading data: Webpush subscriptions
-    ###
-    @api_version("2.4.0", "2.4.0", _DICT_VERSION_PUSH)
-    def push_subscription(self):
-        """
-        Fetch the current push subscription the logged-in user has for this app.
-        Returns a :ref:`push subscription dict <push subscription dict>`.
-        """
-        return self.__api_request('GET', '/api/v1/push/subscription')
-    ###
-    # Reading data: Preferences
-    ###
-    @api_version("2.8.0", "2.8.0", _DICT_VERSION_PREFERENCES)
-    def preferences(self):
-        """
-        Fetch the user's preferences, which can be used to set some default options.
-        As of 2.8.0, apps can only fetch, not update preferences.
-        Returns a :ref:`preference dict <preference dict>`.
-        """
-        return self.__api_request('GET', '/api/v1/preferences')
-    ##
-    # Reading data: Announcements
-    ##
-    # /api/v1/announcements
-    @api_version("3.1.0", "3.1.0", _DICT_VERSION_ANNOUNCEMENT)
-    def announcements(self):
-        """
-        Fetch currently active announcements.
-        Returns a list of :ref:`announcement dicts <announcement dicts>`.
-        """
-        return self.__api_request('GET', '/api/v1/announcements')
-    ##
-    # Reading data: Read markers
-    ##
-    @api_version("3.0.0", "3.0.0", _DICT_VERSION_MARKER)
-    def markers_get(self, timeline=["home"]):
-        """
-        Get the last-read-location markers for the specified timelines. Valid timelines
-        are the same as in :ref:`timeline() <timeline()>`
-        Note that despite the singular name, `timeline` can be a list.
-        Returns a dict of :ref:`read marker dicts <read marker dicts>`, keyed by timeline name.
-        """
-        if not isinstance(timeline, (list, tuple)):
-            timeline = [timeline]
-        params = self.__generate_params(locals())
-        return self.__api_request('GET', '/api/v1/markers', params)
-    ###
-    # Reading data: Bookmarks
-    ###
-    @api_version("3.1.0", "3.1.0", _DICT_VERSION_STATUS)
-    def bookmarks(self, max_id=None, min_id=None, since_id=None, limit=None):
-        """
-        Get a list of statuses bookmarked by the logged-in user.
-        Returns a list of :ref:`status dicts <status dicts>`.
-        """
-        if max_id is not None:
-            max_id = self.__unpack_id(max_id, dateconv=True)
-        if min_id is not None:
-            min_id = self.__unpack_id(min_id, dateconv=True)
-        if since_id is not None:
-            since_id = self.__unpack_id(since_id, dateconv=True)
-        params = self.__generate_params(locals())
-        return self.__api_request('GET', '/api/v1/bookmarks', params)
-    ###
-    # Writing data: Statuses
-    ###
-    def __status_internal(self, status, in_reply_to_id=None, media_ids=None,
-                    sensitive=False, visibility=None, spoiler_text=None,
-                    language=None, idempotency_key=None, content_type=None,
-                    scheduled_at=None, poll=None, quote_id=None, edit=False):
-        if quote_id is not None:
-            if self.feature_set != "fedibird":
-                raise MastodonIllegalArgumentError('quote_id is only available with feature set fedibird')
-            quote_id = self.__unpack_id(quote_id)
-        if content_type is not None:
-            if self.feature_set != "pleroma":
-                raise MastodonIllegalArgumentError('content_type is only available with feature set pleroma')
-            # It would be better to read this from nodeinfo and cache, but this is easier
-            if not content_type in ["text/plain", "text/html", "text/markdown", "text/bbcode"]:
-                raise MastodonIllegalArgumentError('Invalid content type specified')
-        if in_reply_to_id is not None:
-            in_reply_to_id = self.__unpack_id(in_reply_to_id)
-        if scheduled_at is not None:
-            scheduled_at = self.__consistent_isoformat_utc(scheduled_at)
-        params_initial = locals()
-        # Validate poll/media exclusivity
-        if poll is not None:
-            if media_ids is not None and len(media_ids) != 0:
-                raise ValueError(
-                    'Status can have media or poll attached - not both.')
-        # Validate visibility parameter
-        valid_visibilities = ['private', 'public', 'unlisted', 'direct']
-        if params_initial['visibility'] is None:
-            del params_initial['visibility']
-        else:
-            params_initial['visibility'] = params_initial['visibility'].lower()
-            if params_initial['visibility'] not in valid_visibilities:
-                raise ValueError('Invalid visibility value! Acceptable values are %s' % valid_visibilities)
-        if params_initial['language'] is None:
-            del params_initial['language']
-        if params_initial['sensitive'] is False:
-            del [params_initial['sensitive']]
-        headers = {}
-        if idempotency_key is not None:
-            headers['Idempotency-Key'] = idempotency_key
-        if media_ids is not None:
-            try:
-                media_ids_proper = []
-                if not isinstance(media_ids, (list, tuple)):
-                    media_ids = [media_ids]
-                for media_id in media_ids:
-                    media_ids_proper.append(self.__unpack_id(media_id))
-            except Exception as e:
-                raise MastodonIllegalArgumentError("Invalid media dict: %s" % e)
-            params_initial["media_ids"] = media_ids_proper
-        if params_initial['content_type'] is None:
-            del params_initial['content_type']
-        use_json = False
-        if poll is not None:
-            use_json = True
-        params = self.__generate_params(params_initial, ['idempotency_key', 'edit'])
-        if edit is None:
-            # Post
-            return self.__api_request('POST', '/api/v1/statuses', params, headers=headers, use_json=use_json)
-        else:
-            # Edit
-            return self.__api_request('PUT', '/api/v1/statuses/{0}'.format(str(self.__unpack_id(edit))), params, headers=headers, use_json=use_json)
-    @api_version("1.0.0", "2.8.0", _DICT_VERSION_STATUS)
-    def status_post(self, status, in_reply_to_id=None, media_ids=None,
-                    sensitive=False, visibility=None, spoiler_text=None,
-                    language=None, idempotency_key=None, content_type=None,
-                    scheduled_at=None, poll=None, quote_id=None):
-        """
-        Post a status. Can optionally be in reply to another status and contain
-        media.
-        `media_ids` should be a list. (If it's not, the function will turn it
-        into one.) It can contain up to four pieces of media (uploaded via
-        :ref:`media_post() <media_post()>`). `media_ids` can also be the `media dicts`_ returned
-        by :ref:`media_post() <media_post()>` - they are unpacked automatically.
-        The `sensitive` boolean decides whether or not media attached to the post
-        should be marked as sensitive, which hides it by default on the Mastodon
-        web front-end.
-        The visibility parameter is a string value and accepts any of:
-        'direct' - post will be visible only to mentioned users
-        'private' - post will be visible only to followers
-        'unlisted' - post will be public but not appear on the public timeline
-        'public' - post will be public
-        If not passed in, visibility defaults to match the current account's
-        default-privacy setting (starting with Mastodon version 1.6) or its
-        locked setting - private if the account is locked, public otherwise
-        (for Mastodon versions lower than 1.6).
-        The `spoiler_text` parameter is a string to be shown as a warning before
-        the text of the status.  If no text is passed in, no warning will be
-        displayed.
-        Specify `language` to override automatic language detection. The parameter
-        accepts all valid ISO 639-1 (2-letter) or for languages where that do not
-        have one, 639-3 (three letter) language codes.
-        You can set `idempotency_key` to a value to uniquely identify an attempt
-        at posting a status. Even if you call this function more than once,
-        if you call it with the same `idempotency_key`, only one status will
-        be created.
-        Pass a datetime as `scheduled_at` to schedule the toot for a specific time
-        (the time must be at least 5 minutes into the future). If this is passed,
-        status_post returns a :ref:`scheduled status dict <scheduled status dict>` instead.
-        Pass `poll` to attach a poll to the status. An appropriate object can be
-        constructed using :ref:`make_poll() <make_poll()>` . Note that as of Mastodon version
-        2.8.2, you can only have either media or a poll attached, not both at
-        the same time.
-        **Specific to "pleroma" feature set:**: Specify `content_type` to set
-        the content type of your post on Pleroma. It accepts 'text/plain' (default),
-        'text/markdown', 'text/html' and 'text/bbcode'. This parameter is not
-        supported on Mastodon servers, but will be safely ignored if set.
-        **Specific to "fedibird" feature set:**: The `quote_id` parameter is
-        a non-standard extension that specifies the id of a quoted status.
-        Returns a :ref:`status dict <status dict>` with the new status.
-        """
-        return self.__status_internal( 
-            status, 
-            in_reply_to_id, 
-            media_ids, 
-            sensitive, 
-            visibility, 
-            spoiler_text, 
-            language, 
-            idempotency_key, 
-            content_type, 
-            scheduled_at, 
-            poll, 
-            quote_id, 
-            edit=None
-        )
-    @api_version("1.0.0", "2.8.0", _DICT_VERSION_STATUS)
-    def toot(self, status):
-        """
-        Synonym for :ref:`status_post() <status_post()>` that only takes the status text as input.
-        Usage in production code is not recommended.
-        Returns a :ref:`status dict <status dict>` with the new status.
-        """
-        return self.status_post(status)
-    @api_version("3.5.0", "3.5.0", _DICT_VERSION_STATUS)
-    def status_update(self, id, status = None, spoiler_text = None, sensitive = None, media_ids = None, poll = None):
-        """
-        Edit a status. The meanings of the fields are largely the same as in :ref:`status_post() <status_post()>`,
-        though not every field can be edited.
-        Note that editing a poll will reset the votes.
-        """
-        return self.__status_internal(
-            status = status, 
-            media_ids = media_ids, 
-            sensitive = sensitive, 
-            spoiler_text = spoiler_text, 
-            poll = poll, 
-            edit = id
-        ) 
-    @api_version("3.5.0", "3.5.0", _DICT_VERSION_STATUS_EDIT)
-    def status_history(self, id):
-        """
-        Returns the edit history of a status as a list of :ref:`status edit dicts <status edit dicts>`, starting
-        from the original form. Note that this means that a status that has been edited
-        once will have *two* entries in this list, a status that has been edited twice
-        will have three, and so on.
-        """
-        id = self.__unpack_id(id)
-        return self.__api_request('GET', "/api/v1/statuses/{0}/history".format(str(id)))
-    def status_source(self, id):
-        """
-        Returns the source of a status for editing.
-        Return value is a dictionary containing exactly the parameters you could pass to
-        :ref:`status_update() <status_update()>` to change nothing about the status, except `status` is `text`
-        instead.
-        """
-        id = self.__unpack_id(id)
-        return self.__api_request('GET', "/api/v1/statuses/{0}/source".format(str(id)))
-    @api_version("1.0.0", "2.8.0", _DICT_VERSION_STATUS)
-    def status_reply(self, to_status, status, in_reply_to_id=None, media_ids=None,
-                     sensitive=False, visibility=None, spoiler_text=None,
-                     language=None, idempotency_key=None, content_type=None,
-                     scheduled_at=None, poll=None, untag=False):
-        """
-        Helper function - acts like status_post, but prepends the name of all
-        the users that are being replied to to the status text and retains
-        CW and visibility if not explicitly overridden.
-        Set `untag` to True if you want the reply to only go to the user you
-        are replying to, removing every other mentioned user from the
-        conversation.
-        """
-        keyword_args = locals()
-        del keyword_args["self"]
-        del keyword_args["to_status"]
-        del keyword_args["untag"]
-        user_id = self.__get_logged_in_id()
-        # Determine users to mention
-        mentioned_accounts = collections.OrderedDict()
-        mentioned_accounts[to_status.account.id] = to_status.account.acct
-        if not untag:
-            for account in to_status.mentions:
-                if account.id != user_id and not account.id in mentioned_accounts.keys():
-                    mentioned_accounts[account.id] = account.acct
-        # Join into one piece of text. The space is added inside because of self-replies.
-        status = "".join(map(lambda x: "@" + x + " ",
-                         mentioned_accounts.values())) + status
-        # Retain visibility / cw
-        if visibility is None and 'visibility' in to_status:
-            visibility = to_status.visibility
-        if spoiler_text is None and 'spoiler_text' in to_status:
-            spoiler_text = to_status.spoiler_text
-        keyword_args["status"] = status
-        keyword_args["visibility"] = visibility
-        keyword_args["spoiler_text"] = spoiler_text
-        keyword_args["in_reply_to_id"] = to_status.id
-        return self.status_post(**keyword_args)
-    @api_version("2.8.0", "2.8.0", _DICT_VERSION_POLL)
-    def make_poll(self, options, expires_in, multiple=False, hide_totals=False):
-        """
-        Generate a poll object that can be passed as the `poll` option when posting a status.
-        options is an array of strings with the poll options (Maximum, by default: 4),
-        expires_in is the time in seconds for which the poll should be open.
-        Set multiple to True to allow people to choose more than one answer. Set
-        hide_totals to True to hide the results of the poll until it has expired.
-        """
-        poll_params = locals()
-        del poll_params["self"]
-        return poll_params
-    @api_version("1.0.0", "1.0.0", "1.0.0")
-    def status_delete(self, id):
-        """
-        Delete a status
-        Returns the now-deleted status, with an added "source" attribute that contains
-        the text that was used to compose this status (this can be used to power
-        "delete and redraft" functionality)
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/statuses/{0}'.format(str(id))
-        return self.__api_request('DELETE', url)
-    @api_version("1.0.0", "2.0.0", _DICT_VERSION_STATUS)
-    def status_reblog(self, id, visibility=None):
-        """
-        Reblog / boost a status.
-        The visibility parameter functions the same as in :ref:`status_post() <status_post()>` and
-        allows you to reduce the visibility of a reblogged status.
-        Returns a :ref:`status dict <status dict>` with a new status that wraps around the reblogged one.
-        """
-        params = self.__generate_params(locals(), ['id'])
-        valid_visibilities = ['private', 'public', 'unlisted', 'direct']
-        if 'visibility' in params:
-            params['visibility'] = params['visibility'].lower()
-            if params['visibility'] not in valid_visibilities:
-                raise ValueError('Invalid visibility value! Acceptable '
-                                 'values are %s' % valid_visibilities)
-        id = self.__unpack_id(id)
-        url = '/api/v1/statuses/{0}/reblog'.format(str(id))
-        return self.__api_request('POST', url, params)
-    @api_version("1.0.0", "2.0.0", _DICT_VERSION_STATUS)
-    def status_unreblog(self, id):
-        """
-        Un-reblog a status.
-        Returns a :ref:`status dict <status dict>` with the status that used to be reblogged.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/statuses/{0}/unreblog'.format(str(id))
-        return self.__api_request('POST', url)
-    @api_version("1.0.0", "2.0.0", _DICT_VERSION_STATUS)
-    def status_favourite(self, id):
-        """
-        Favourite a status.
-        Returns a :ref:`status dict <status dict>` with the favourited status.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/statuses/{0}/favourite'.format(str(id))
-        return self.__api_request('POST', url)
-    @api_version("1.0.0", "2.0.0", _DICT_VERSION_STATUS)
-    def status_unfavourite(self, id):
-        """
-        Un-favourite a status.
-        Returns a :ref:`status dict <status dict>` with the un-favourited status.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/statuses/{0}/unfavourite'.format(str(id))
-        return self.__api_request('POST', url)
-    @api_version("1.4.0", "2.0.0", _DICT_VERSION_STATUS)
-    def status_mute(self, id):
-        """
-        Mute notifications for a status.
-        Returns a :ref:`status dict <status dict>` with the now muted status
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/statuses/{0}/mute'.format(str(id))
-        return self.__api_request('POST', url)
-    @api_version("1.4.0", "2.0.0", _DICT_VERSION_STATUS)
-    def status_unmute(self, id):
-        """
-        Unmute notifications for a status.
-        Returns a :ref:`status dict <status dict>` with the status that used to be muted.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/statuses/{0}/unmute'.format(str(id))
-        return self.__api_request('POST', url)
-    @api_version("2.1.0", "2.1.0", _DICT_VERSION_STATUS)
-    def status_pin(self, id):
-        """
-        Pin a status for the logged-in user.
-        Returns a :ref:`status dict <status dict>` with the now pinned status
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/statuses/{0}/pin'.format(str(id))
-        return self.__api_request('POST', url)
-    @api_version("2.1.0", "2.1.0", _DICT_VERSION_STATUS)
-    def status_unpin(self, id):
-        """
-        Unpin a pinned status for the logged-in user.
-        Returns a :ref:`status dict <status dict>` with the status that used to be pinned.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/statuses/{0}/unpin'.format(str(id))
-        return self.__api_request('POST', url)
-    @api_version("3.1.0", "3.1.0", _DICT_VERSION_STATUS)
-    def status_bookmark(self, id):
-        """
-        Bookmark a status as the logged-in user.
-        Returns a :ref:`status dict <status dict>` with the now bookmarked status
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/statuses/{0}/bookmark'.format(str(id))
-        return self.__api_request('POST', url)
-    @api_version("3.1.0", "3.1.0", _DICT_VERSION_STATUS)
-    def status_unbookmark(self, id):
-        """
-        Unbookmark a bookmarked status for the logged-in user.
-        Returns a :ref:`status dict <status dict>` with the status that used to be bookmarked.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/statuses/{0}/unbookmark'.format(str(id))
-        return self.__api_request('POST', url)
-    ###
-    # Writing data: Scheduled statuses
-    ###
-    @api_version("2.7.0", "2.7.0", _DICT_VERSION_SCHEDULED_STATUS)
-    def scheduled_status_update(self, id, scheduled_at):
-        """
-        Update the scheduled time of a scheduled status.
-        New time must be at least 5 minutes into the future.
-        Returns a :ref:`scheduled status dict <scheduled status dict>`
-        """
-        scheduled_at = self.__consistent_isoformat_utc(scheduled_at)
-        id = self.__unpack_id(id)
-        params = self.__generate_params(locals(), ['id'])
-        url = '/api/v1/scheduled_statuses/{0}'.format(str(id))
-        return self.__api_request('PUT', url, params)
-    @api_version("2.7.0", "2.7.0", "2.7.0")
-    def scheduled_status_delete(self, id):
-        """
-        Deletes a scheduled status.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/scheduled_statuses/{0}'.format(str(id))
-        self.__api_request('DELETE', url)
-    ###
-    # Writing data: Polls
-    ###
-    @api_version("2.8.0", "2.8.0", _DICT_VERSION_POLL)
-    def poll_vote(self, id, choices):
-        """
-        Vote in the given poll.
-        `choices` is the index of the choice you wish to register a vote for
-        (i.e. its index in the corresponding polls `options` field. In case
-        of a poll that allows selection of more than one option, a list of
-        indices can be passed.
-        You can only submit choices for any given poll once in case of
-        single-option polls, or only once per option in case of multi-option
-        polls.
-        Returns the updated :ref:`poll dict <poll dict>`
-        """
-        id = self.__unpack_id(id)
-        if not isinstance(choices, list):
-            choices = [choices]
-        params = self.__generate_params(locals(), ['id'])
-        url = '/api/v1/polls/{0}/votes'.format(id)
-        self.__api_request('POST', url, params)
-    ###
-    # Writing data: Notifications
-    ###
-    @api_version("1.0.0", "1.0.0", "1.0.0")
-    def notifications_clear(self):
-        """
-        Clear out a user's notifications
-        """
-        self.__api_request('POST', '/api/v1/notifications/clear')
-    @api_version("1.3.0", "2.9.2", "2.9.2")
-    def notifications_dismiss(self, id):
-        """
-        Deletes a single notification
-        """
-        id = self.__unpack_id(id)
-        if self.verify_minimum_version("2.9.2", cached=True):
-            url = '/api/v1/notifications/{0}/dismiss'.format(str(id))
-            self.__api_request('POST', url)
-        else:
-            params = self.__generate_params(locals())
-            self.__api_request('POST', '/api/v1/notifications/dismiss', params)
-    ###
-    # Writing data: Conversations
-    ###
-    @api_version("2.6.0", "2.6.0", _DICT_VERSION_CONVERSATION)
-    def conversations_read(self, id):
-        """
-        Marks a single conversation as read.
-        Returns the updated :ref:`conversation dict <conversation dict>`.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/conversations/{0}/read'.format(str(id))
-        return self.__api_request('POST', url)
-    ###
-    # Writing data: Accounts
-    ###
-    @api_version("1.0.0", "3.3.0", _DICT_VERSION_RELATIONSHIP)
-    def account_follow(self, id, reblogs=True, notify=False):
-        """
-        Follow a user.
-        Set `reblogs` to False to hide boosts by the followed user.
-        Set `notify` to True to get a notification every time the followed user posts.
-        Returns a :ref:`relationship dict <relationship dict>` containing the updated relationship to the user.
-        """
-        id = self.__unpack_id(id)
-        params = self.__generate_params(locals(), ["id"])
-        if params["reblogs"] is None:
-            del params["reblogs"]
-        url = '/api/v1/accounts/{0}/follow'.format(str(id))
-        return self.__api_request('POST', url, params)
-    @api_version("1.0.0", "2.1.0", _DICT_VERSION_ACCOUNT)
-    def follows(self, uri):
-        """
-        Follow a remote user by uri (username@domain).
-        Returns a :ref:`account dict <account dict>`.
-        """
-        params = self.__generate_params(locals())
-        return self.__api_request('POST', '/api/v1/follows', params)
-    @api_version("1.0.0", "1.4.0", _DICT_VERSION_RELATIONSHIP)
-    def account_unfollow(self, id):
-        """
-        Unfollow a user.
-        Returns a :ref:`relationship dict <relationship dict>` containing the updated relationship to the user.
-        """
-        id = self.__unpack_id(id)
-        return self.__api_request('POST', '/api/v1/accounts/{0}/unfollow'.format(str(id)))
-    @api_version("3.5.0", "3.5.0", _DICT_VERSION_RELATIONSHIP)
-    def account_remove_from_followers(self, id):
-        """
-        Remove a user from the logged in users followers (i.e. make them unfollow the logged in
-        user / "softblock" them).
-        Returns a :ref:`relationship dict <relationship dict>` reflecting the updated following status.
-        """
-        id = self.__unpack_id(id)
-        return self.__api_request('POST', '/api/v1/accounts/{0}/remove_from_followers'.format(str(id)))
-    
-    @api_version("1.0.0", "1.4.0", _DICT_VERSION_RELATIONSHIP)
-    def account_block(self, id):
-        """
-        Block a user.
-        Returns a :ref:`relationship dict <relationship dict>` containing the updated relationship to the user.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/accounts/{0}/block'.format(str(id))
-        return self.__api_request('POST', url)
-    @api_version("1.0.0", "1.4.0", _DICT_VERSION_RELATIONSHIP)
-    def account_unblock(self, id):
-        """
-        Unblock a user.
-        Returns a :ref:`relationship dict <relationship dict>` containing the updated relationship to the user.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/accounts/{0}/unblock'.format(str(id))
-        return self.__api_request('POST', url)
-    @api_version("1.1.0", "2.4.3", _DICT_VERSION_RELATIONSHIP)
-    def account_mute(self, id, notifications=True, duration=None):
-        """
-        Mute a user.
-        Set `notifications` to False to receive notifications even though the user is
-        muted from timelines. Pass a `duration` in seconds to have Mastodon automatically
-        lift the mute after that many seconds.
-        Returns a :ref:`relationship dict <relationship dict>` containing the updated relationship to the user.
-        """
-        id = self.__unpack_id(id)
-        params = self.__generate_params(locals(), ['id'])
-        url = '/api/v1/accounts/{0}/mute'.format(str(id))
-        return self.__api_request('POST', url, params)
-    @api_version("1.1.0", "1.4.0", _DICT_VERSION_RELATIONSHIP)
-    def account_unmute(self, id):
-        """
-        Unmute a user.
-        Returns a :ref:`relationship dict <relationship dict>` containing the updated relationship to the user.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/accounts/{0}/unmute'.format(str(id))
-        return self.__api_request('POST', url)
-    @api_version("1.1.1", "3.1.0", _DICT_VERSION_ACCOUNT)
-    def account_update_credentials(self, display_name=None, note=None,
-                                   avatar=None, avatar_mime_type=None,
-                                   header=None, header_mime_type=None,
-                                   locked=None, bot=None,
-                                   discoverable=None, fields=None):
-        """
-        Update the profile for the currently logged-in user.
-        `note` is the user's bio.
-        `avatar` and 'header' are images. As with media uploads, it is possible to either
-        pass image data and a mime type, or a filename of an image file, for either.
-        `locked` specifies whether the user needs to manually approve follow requests.
-        `bot` specifies whether the user should be set to a bot.
-        `discoverable` specifies whether the user should appear in the user directory.
-        `fields` can be a list of up to four name-value pairs (specified as tuples) to
-        appear as semi-structured information in the user's profile.
-        Returns the updated `account dict` of the logged-in user.
-        """
-        params_initial = collections.OrderedDict(locals())
-        # Convert fields
-        if fields is not None:
-            if len(fields) > 4:
-                raise MastodonIllegalArgumentError(
-                    'A maximum of four fields are allowed.')
-            fields_attributes = []
-            for idx, (field_name, field_value) in enumerate(fields):
-                params_initial['fields_attributes[' +
-                               str(idx) + '][name]'] = field_name
-                params_initial['fields_attributes[' +
-                               str(idx) + '][value]'] = field_value
-        # Clean up params
-        for param in ["avatar", "avatar_mime_type", "header", "header_mime_type", "fields"]:
-            if param in params_initial:
-                del params_initial[param]
-        # Create file info
-        files = {}
-        if avatar is not None:
-            files["avatar"] = self.__load_media_file(avatar, avatar_mime_type)
-        if header is not None:
-            files["header"] = self.__load_media_file(header, header_mime_type)
-        params = self.__generate_params(params_initial)
-        return self.__api_request('PATCH', '/api/v1/accounts/update_credentials', params, files=files)
-    @api_version("2.5.0", "2.5.0", _DICT_VERSION_RELATIONSHIP)
-    def account_pin(self, id):
-        """
-        Pin / endorse a user.
-        Returns a :ref:`relationship dict <relationship dict>` containing the updated relationship to the user.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/accounts/{0}/pin'.format(str(id))
-        return self.__api_request('POST', url)
-    @api_version("2.5.0", "2.5.0", _DICT_VERSION_RELATIONSHIP)
-    def account_unpin(self, id):
-        """
-        Unpin / un-endorse a user.
-        Returns a :ref:`relationship dict <relationship dict>` containing the updated relationship to the user.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/accounts/{0}/unpin'.format(str(id))
-        return self.__api_request('POST', url)
-    @api_version("3.2.0", "3.2.0", _DICT_VERSION_RELATIONSHIP)
-    def account_note_set(self, id, comment):
-        """
-        Set a note (visible to the logged in user only) for the given account.
-        Returns a :ref:`status dict <status dict>` with the `note` updated.
-        """
-        id = self.__unpack_id(id)
-        params = self.__generate_params(locals(), ["id"])
-        return self.__api_request('POST', '/api/v1/accounts/{0}/note'.format(str(id)), params)
-    @api_version("3.3.0", "3.3.0", _DICT_VERSION_HASHTAG)
-    def account_featured_tags(self, id):
-        """
-        Get an account's featured hashtags.
-        Returns a list of :ref:`hashtag dicts <hashtag dicts>` (NOT `featured tag dicts`_).
-        """
-        id = self.__unpack_id(id)
-        return self.__api_request('GET', '/api/v1/accounts/{0}/featured_tags'.format(str(id)))
-    ###
-    # Writing data: Featured hashtags
-    ###
-    @api_version("3.0.0", "3.0.0", _DICT_VERSION_FEATURED_TAG)
-    def featured_tag_create(self, name):
-        """
-        Creates a new featured hashtag displayed on the logged-in user's profile.
-        Returns a :ref:`featured tag dict <featured tag dict>` with the newly featured tag.
-        """
-        params = self.__generate_params(locals())
-        return self.__api_request('POST', '/api/v1/featured_tags', params)
-    @api_version("3.0.0", "3.0.0", _DICT_VERSION_FEATURED_TAG)
-    def featured_tag_delete(self, id):
-        """
-        Deletes one of the logged-in user's featured hashtags.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/featured_tags/{0}'.format(str(id))
-        self.__api_request('DELETE', url)
-    ###
-    # Writing data: Keyword filters
-    ###
-    @api_version("2.4.3", "2.4.3", _DICT_VERSION_FILTER)
-    def filter_create(self, phrase, context, irreversible=False, whole_word=True, expires_in=None):
-        """
-        Creates a new keyword filter. `phrase` is the phrase that should be
-        filtered out, `context` specifies from where to filter the keywords.
-        Valid contexts are 'home', 'notifications', 'public' and 'thread'.
-        Set `irreversible` to True if you want the filter to just delete statuses
-        server side. This works only for the 'home' and 'notifications' contexts.
-        Set `whole_word` to False if you want to allow filter matches to
-        start or end within a word, not only at word boundaries.
-        Set `expires_in` to specify for how many seconds the filter should be
-        kept around.
-        Returns the :ref:`filter dict <filter dict>` of the newly created filter.
-        """
-        params = self.__generate_params(locals())
-        for context_val in context:
-            if not context_val in ['home', 'notifications', 'public', 'thread']:
-                raise MastodonIllegalArgumentError('Invalid filter context.')
-        return self.__api_request('POST', '/api/v1/filters', params)
-    @api_version("2.4.3", "2.4.3", _DICT_VERSION_FILTER)
-    def filter_update(self, id, phrase=None, context=None, irreversible=None, whole_word=None, expires_in=None):
-        """
-        Updates the filter with the given `id`. Parameters are the same
-        as in `filter_create()`.
-        Returns the :ref:`filter dict <filter dict>` of the updated filter.
-        """
-        id = self.__unpack_id(id)
-        params = self.__generate_params(locals(), ['id'])
-        url = '/api/v1/filters/{0}'.format(str(id))
-        return self.__api_request('PUT', url, params)
-    @api_version("2.4.3", "2.4.3", "2.4.3")
-    def filter_delete(self, id):
-        """
-        Deletes the filter with the given `id`.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/filters/{0}'.format(str(id))
-        self.__api_request('DELETE', url)
-    ###
-    # Writing data: Follow suggestions
-    ###
-    @api_version("2.4.3", "2.4.3", _DICT_VERSION_ACCOUNT)
-    def suggestion_delete(self, account_id):
-        """
-        Remove the user with the given `account_id` from the follow suggestions.
-        """
-        account_id = self.__unpack_id(account_id)
-        url = '/api/v1/suggestions/{0}'.format(str(account_id))
-        self.__api_request('DELETE', url)
-    ###
-    # Writing data: Lists
-    ###
-    @api_version("2.1.0", "2.1.0", _DICT_VERSION_LIST)
-    def list_create(self, title):
-        """
-        Create a new list with the given `title`.
-        Returns the :ref:`list dict <list dict>` of the created list.
-        """
-        params = self.__generate_params(locals())
-        return self.__api_request('POST', '/api/v1/lists', params)
-    @api_version("2.1.0", "2.1.0", _DICT_VERSION_LIST)
-    def list_update(self, id, title):
-        """
-        Update info about a list, where "info" is really the lists `title`.
-        Returns the :ref:`list dict <list dict>` of the modified list.
-        """
-        id = self.__unpack_id(id)
-        params = self.__generate_params(locals(), ['id'])
-        return self.__api_request('PUT', '/api/v1/lists/{0}'.format(id), params)
-    @api_version("2.1.0", "2.1.0", "2.1.0")
-    def list_delete(self, id):
-        """
-        Delete a list.
-        """
-        id = self.__unpack_id(id)
-        self.__api_request('DELETE', '/api/v1/lists/{0}'.format(id))
-    @api_version("2.1.0", "2.1.0", "2.1.0")
-    def list_accounts_add(self, id, account_ids):
-        """
-        Add the account(s) given in `account_ids` to the list.
-        """
-        id = self.__unpack_id(id)
-        if not isinstance(account_ids, list):
-            account_ids = [account_ids]
-        account_ids = list(map(lambda x: self.__unpack_id(x), account_ids))
-        params = self.__generate_params(locals(), ['id'])
-        self.__api_request(
-            'POST', '/api/v1/lists/{0}/accounts'.format(id), params)
-    @api_version("2.1.0", "2.1.0", "2.1.0")
-    def list_accounts_delete(self, id, account_ids):
-        """
-        Remove the account(s) given in `account_ids` from the list.
-        """
-        id = self.__unpack_id(id)
-        if not isinstance(account_ids, list):
-            account_ids = [account_ids]
-        account_ids = list(map(lambda x: self.__unpack_id(x), account_ids))
-        params = self.__generate_params(locals(), ['id'])
-        self.__api_request(
-            'DELETE', '/api/v1/lists/{0}/accounts'.format(id), params)
-    ###
-    # Writing data: Reports
-    ###
-    @api_version("1.1.0", "3.5.0", _DICT_VERSION_REPORT)
-    def report(self, account_id, status_ids=None, comment=None, forward=False, category=None, rule_ids=None):
-        """
-        Report statuses to the instances administrators.
-        Accepts a list of toot IDs associated with the report, and a comment.
-        Starting with Mastodon 3.5.0, you can also pass a `category` (one out of
-        "spam", "violation" or "other") and `rule_ids` (a list of rule IDs corresponding
-        to the rules returned by the :ref:`instance() <instance()>` API).
-        Set `forward` to True to forward a report of a remote user to that users
-        instance as well as sending it to the instance local administrators.
-        Returns a :ref:`report dict <report dict>`.
-        """
-        if category is not None and not category in ["spam", "violation", "other"]:
-            raise MastodonIllegalArgumentError("Invalid report category (must be spam, violation or other)")
-        account_id = self.__unpack_id(account_id)
-        if status_ids is not None:
-            if not isinstance(status_ids, list):
-                status_ids = [status_ids]
-            status_ids = list(map(lambda x: self.__unpack_id(x), status_ids))
-        params_initial = locals()
-        if not forward:
-            del params_initial['forward']
-        params = self.__generate_params(params_initial)
-        return self.__api_request('POST', '/api/v1/reports/', params)
-    ###
-    # Writing data: Follow requests
-    ###
-    @api_version("1.0.0", "3.0.0", _DICT_VERSION_RELATIONSHIP)
-    def follow_request_authorize(self, id):
-        """
-        Accept an incoming follow request.
-        Returns the updated :ref:`relationship dict <relationship dict>` for the requesting account.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/follow_requests/{0}/authorize'.format(str(id))
-        return self.__api_request('POST', url)
-    @api_version("1.0.0", "3.0.0", _DICT_VERSION_RELATIONSHIP)
-    def follow_request_reject(self, id):
-        """
-        Reject an incoming follow request.
-        Returns the updated :ref:`relationship dict <relationship dict>` for the requesting account.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/follow_requests/{0}/reject'.format(str(id))
-        return self.__api_request('POST', url)
-    ###
-    # Writing data: Media
-    ###
-    @api_version("1.0.0", "3.2.0", _DICT_VERSION_MEDIA)
-    def media_post(self, media_file, mime_type=None, description=None, focus=None, file_name=None, thumbnail=None, thumbnail_mime_type=None, synchronous=False):
-        """
-        Post an image, video or audio file. `media_file` can either be data or
-        a file name. If data is passed directly, the mime type has to be specified
-        manually, otherwise, it is determined from the file name. `focus` should be a tuple
-        of floats between -1 and 1, giving the x and y coordinates of the images
-        focus point for cropping (with the origin being the images center).
-        Throws a `MastodonIllegalArgumentError` if the mime type of the
-        passed data or file can not be determined properly.
-        `file_name` can be specified to upload a file with the given name,
-        which is ignored by Mastodon, but some other Fediverse server software
-        will display it. If no name is specified, a random name will be generated.
-        The filename of a file specified in media_file will be ignored.
-        Starting with Mastodon 3.2.0, `thumbnail` can be specified in the same way as `media_file`
-        to upload a custom thumbnail image for audio and video files.
-        Returns a :ref:`media dict <media dict>`. This contains the id that can be used in
-        status_post to attach the media file to a toot.
-        When using the v2 API (post Mastodon version 3.1.4), the `url` in the
-        returned dict will be `null`, since attachments are processed
-        asynchronously. You can fetch an updated dict using `media`. Pass
-        "synchronous" to emulate the old behaviour. Not recommended, inefficient
-        and deprecated, you know the deal.
-        """
-        files = {'file': self.__load_media_file(
-            media_file, mime_type, file_name)}
-        if focus is not None:
-            focus = str(focus[0]) + "," + str(focus[1])
-        if thumbnail is not None:
-            if not self.verify_minimum_version("3.2.0", cached=True):
-                raise MastodonVersionError(
-                    'Thumbnail requires version > 3.2.0')
-            files["thumbnail"] = self.__load_media_file(
-                thumbnail, thumbnail_mime_type)
-        # Disambiguate URL by version
-        if self.verify_minimum_version("3.1.4", cached=True):
-            ret_dict = self.__api_request(
-                'POST', '/api/v2/media', files=files, params={'description': description, 'focus': focus})
-        else:
-            ret_dict = self.__api_request(
-                'POST', '/api/v1/media', files=files, params={'description': description, 'focus': focus})
-        # Wait for processing?
-        if synchronous:
-            if self.verify_minimum_version("3.1.4"):
-                while not "url" in ret_dict or ret_dict.url is None:
-                    try:
-                        ret_dict = self.media(ret_dict)
-                        time.sleep(1.0)
-                    except:
-                        raise MastodonAPIError(
-                            "Attachment could not be processed")
-            else:
-                # Old version always waits
-                return ret_dict
-        return ret_dict
-    @api_version("2.3.0", "3.2.0", _DICT_VERSION_MEDIA)
-    def media_update(self, id, description=None, focus=None, thumbnail=None, thumbnail_mime_type=None):
-        """
-        Update the metadata of the media file with the given `id`. `description` and
-        `focus` and `thumbnail` are as in :ref:`media_post() <media_post()>` .
-        Returns the updated :ref:`media dict <media dict>`.
-        """
-        id = self.__unpack_id(id)
-        if focus is not None:
-            focus = str(focus[0]) + "," + str(focus[1])
-        params = self.__generate_params(
-            locals(), ['id', 'thumbnail', 'thumbnail_mime_type'])
-        if thumbnail is not None:
-            if not self.verify_minimum_version("3.2.0", cached=True):
-                raise MastodonVersionError(
-                    'Thumbnail requires version > 3.2.0')
-            files = {"thumbnail": self.__load_media_file(
-                thumbnail, thumbnail_mime_type)}
-            return self.__api_request('PUT', '/api/v1/media/{0}'.format(str(id)), params, files=files)
-        else:
-            return self.__api_request('PUT', '/api/v1/media/{0}'.format(str(id)), params)
-    @api_version("3.1.4", "3.1.4", _DICT_VERSION_MEDIA)
-    def media(self, id):
-        """
-        Get the updated JSON for one non-attached / in progress media upload belonging
-        to the logged-in user.
-        """
-        id = self.__unpack_id(id)
-        return self.__api_request('GET', '/api/v1/media/{0}'.format(str(id)))
-    ###
-    # Writing data: Domain blocks
-    ###
-    @api_version("1.4.0", "1.4.0", "1.4.0")
-    def domain_block(self, domain=None):
-        """
-        Add a block for all statuses originating from the specified domain for the logged-in user.
-        """
-        params = self.__generate_params(locals())
-        self.__api_request('POST', '/api/v1/domain_blocks', params)
-    @api_version("1.4.0", "1.4.0", "1.4.0")
-    def domain_unblock(self, domain=None):
-        """
-        Remove a domain block for the logged-in user.
-        """
-        params = self.__generate_params(locals())
-        self.__api_request('DELETE', '/api/v1/domain_blocks', params)
-    ##
-    # Writing data: Read markers
-    ##
-    @api_version("3.0.0", "3.0.0", _DICT_VERSION_MARKER)
-    def markers_set(self, timelines, last_read_ids):
-        """
-        Set the "last read" marker(s) for the given timeline(s) to the given id(s)
-        Note that if you give an invalid timeline name, this will silently do nothing.
-        Returns a dict with the updated :ref:`read marker dicts <read marker dicts>`, keyed by timeline name.
-        """
-        if not isinstance(timelines, (list, tuple)):
-            timelines = [timelines]
-        if not isinstance(last_read_ids, (list, tuple)):
-            last_read_ids = [last_read_ids]
-        if len(last_read_ids) != len(timelines):
-            raise MastodonIllegalArgumentError(
-                "Number of specified timelines and ids must be the same")
-        params = collections.OrderedDict()
-        for timeline, last_read_id in zip(timelines, last_read_ids):
-            params[timeline] = collections.OrderedDict()
-            params[timeline]["last_read_id"] = self.__unpack_id(last_read_id)
-        return self.__api_request('POST', '/api/v1/markers', params, use_json=True)
-    ###
-    # Writing data: Push subscriptions
-    ###
-    @api_version("2.4.0", "2.4.0", _DICT_VERSION_PUSH)
-    def push_subscription_set(self, endpoint, encrypt_params, follow_events=None,
-                              favourite_events=None, reblog_events=None,
-                              mention_events=None, poll_events=None,
-                              follow_request_events=None, status_events=None, policy='all'):
-        """
-        Sets up or modifies the push subscription the logged-in user has for this app.
-        `endpoint` is the endpoint URL mastodon should call for pushes. Note that mastodon
-        requires https for this URL. `encrypt_params` is a dict with key parameters that allow
-        the server to encrypt data for you: A public key `pubkey` and a shared secret `auth`.
-        You can generate this as well as the corresponding private key using the
-        :ref:`push_subscription_generate_keys() <push_subscription_generate_keys()>` function.
-        `policy` controls what sources will generate webpush events. Valid values are
-        `all`, `none`, `follower` and `followed`.
-        The rest of the parameters controls what kind of events you wish to subscribe to.
-        Returns a :ref:`push subscription dict <push subscription dict>`.
-        """
-        if not policy in ['all', 'none', 'follower', 'followed']:
-            raise MastodonIllegalArgumentError("Valid values for policy are 'all', 'none', 'follower' or 'followed'.")
-        endpoint = Mastodon.__protocolize(endpoint)
-        push_pubkey_b64 = base64.b64encode(encrypt_params['pubkey'])
-        push_auth_b64 = base64.b64encode(encrypt_params['auth'])
-        params = {
-            'subscription[endpoint]': endpoint,
-            'subscription[keys][p256dh]': push_pubkey_b64,
-            'subscription[keys][auth]': push_auth_b64,
-            'policy': policy
-        }
-        if follow_events is not None:
-            params['data[alerts][follow]'] = follow_events
-        if favourite_events is not None:
-            params['data[alerts][favourite]'] = favourite_events
-        if reblog_events is not None:
-            params['data[alerts][reblog]'] = reblog_events
-        if mention_events is not None:
-            params['data[alerts][mention]'] = mention_events
-        if poll_events is not None:
-            params['data[alerts][poll]'] = poll_events
-        if follow_request_events is not None:
-            params['data[alerts][follow_request]'] = follow_request_events
-        if follow_request_events is not None:
-            params['data[alerts][status]'] = status_events
-        # Canonicalize booleans
-        params = self.__generate_params(params)
-        return self.__api_request('POST', '/api/v1/push/subscription', params)
-    @api_version("2.4.0", "2.4.0", _DICT_VERSION_PUSH)
-    def push_subscription_update(self, follow_events=None,
-                                 favourite_events=None, reblog_events=None,
-                                 mention_events=None, poll_events=None,
-                                 follow_request_events=None):
-        """
-        Modifies what kind of events the app wishes to subscribe to.
-        Returns the updated :ref:`push subscription dict <push subscription dict>`.
-        """
-        params = {}
-        if follow_events is not None:
-            params['data[alerts][follow]'] = follow_events
-        if favourite_events is not None:
-            params['data[alerts][favourite]'] = favourite_events
-        if reblog_events is not None:
-            params['data[alerts][reblog]'] = reblog_events
-        if mention_events is not None:
-            params['data[alerts][mention]'] = mention_events
-        if poll_events is not None:
-            params['data[alerts][poll]'] = poll_events
-        if follow_request_events is not None:
-            params['data[alerts][follow_request]'] = follow_request_events
-        # Canonicalize booleans
-        params = self.__generate_params(params)
-        return self.__api_request('PUT', '/api/v1/push/subscription', params)
-    @api_version("2.4.0", "2.4.0", "2.4.0")
-    def push_subscription_delete(self):
-        """
-        Remove the current push subscription the logged-in user has for this app.
-        """
-        self.__api_request('DELETE', '/api/v1/push/subscription')
-    ###
-    # Writing data: Annoucements
-    ###
-    @api_version("3.1.0", "3.1.0", "3.1.0")
-    def announcement_dismiss(self, id):
-        """
-        Set the given annoucement to read.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/announcements/{0}/dismiss'.format(str(id))
-        self.__api_request('POST', url)
-    @api_version("3.1.0", "3.1.0", "3.1.0")
-    def announcement_reaction_create(self, id, reaction):
-        """
-        Add a reaction to an announcement. `reaction` can either be a unicode emoji
-        or the name of one of the instances custom emoji.
-        Will throw an API error if the reaction name is not one of the allowed things
-        or when trying to add a reaction that the user has already added (adding a
-        reaction that a different user added is legal and increments the count).
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/announcements/{0}/reactions/{1}'.format(
-            str(id), reaction)
-        self.__api_request('PUT', url)
-    @api_version("3.1.0", "3.1.0", "3.1.0")
-    def announcement_reaction_delete(self, id, reaction):
-        """
-        Remove a reaction to an announcement.
-        Will throw an API error if the reaction does not exist.
-        """
-        id = self.__unpack_id(id)
-        url = '/api/v1/announcements/{0}/reactions/{1}'.format(
-            str(id), reaction)
-        self.__api_request('DELETE', url)
-    ###
-    # Moderation API
-    ###
-    @api_version("2.9.1", "4.0.0", _DICT_VERSION_ADMIN_ACCOUNT)
-    def admin_accounts_v2(self, origin=None, by_domain=None, status=None, username=None, display_name=None, email=None, ip=None, 
-                            permissions=None, invited_by=None, role_ids=None, max_id=None, min_id=None, since_id=None, limit=None):
-        """
-        Fetches a list of accounts that match given criteria. By default, local accounts are returned.
-        * Set `origin` to "local" or "remote" to get only local or remote accounts.
-        * Set `by_domain` to a domain to get only accounts from that domain.
-        * Set `status` to one of "active", "pending", "disabled", "silenced" or "suspended" to get only accounts with that moderation status (default: active)
-        * Set `username` to a string to get only accounts whose username contains this string.
-        * Set `display_name` to a string to get only accounts whose display name contains this string.
-        * Set `email` to an email to get only accounts with that email (this only works on local accounts).
-        * Set `ip` to an ip (as a string, standard v4/v6 notation) to get only accounts whose last active ip is that ip (this only works on local accounts).
-        * Set `permissions` to "staff" to only get accounts with staff permissions.
-        * Set `invited_by` to an account id to get only accounts invited by this user.
-        * Set `role_ids` to a list of role IDs to get only accounts with those roles.
-        Returns a list of :ref:`admin account dicts <admin account dicts>`.
-        """
-        if max_id is not None:
-            max_id = self.__unpack_id(max_id, dateconv=True)
-        if min_id is not None:
-            min_id = self.__unpack_id(min_id, dateconv=True)
-        if since_id is not None:
-            since_id = self.__unpack_id(since_id, dateconv=True)
-        if role_ids is not None:
-            if not isinstance(role_ids, list):
-                role_ids = [role_ids]
-            role_ids = list(map(self.__unpack_id, role_ids))
-        if invited_by is not None:
-            invited_by = self.__unpack_id(invited_by)
-        if permissions is not None and not permissions in ["staff"]:
-            raise MastodonIllegalArgumentError("Permissions must be staff if passed")
-        if origin is not None and not origin in ["local", "remote"]:
-            raise MastodonIllegalArgumentError("Origin must be local or remote")
-        if status is not None and not status in ["active", "pending", "disabled", "silenced", "suspended"]:
-            raise MastodonIllegalArgumentError("Status must be local or active, pending, disabled, silenced or suspended")
-        if not by_domain is None:
-            by_domain = self.__deprotocolize(by_domain)
-        params = self.__generate_params(locals())
-        return self.__api_request('GET', '/api/v2/admin/accounts', params)
-    @api_version("2.9.1", "2.9.1", _DICT_VERSION_ADMIN_ACCOUNT)
-    def admin_accounts(self, remote=False, by_domain=None, status='active', username=None, display_name=None, email=None, ip=None, staff_only=False, max_id=None, min_id=None, since_id=None, limit=None):
-        """
-        Currently a synonym for admin_accounts_v1, now deprecated. You are strongly encouraged to use admin_accounts_v2 instead, since this one is kind of bad. 
-        
-        !!!!! This function may be switched to calling the v2 API in the future. This is your warning. If you want to keep using v1, use it explicitly. !!!!!
-        """
-        return self.admin_accounts_v1(
-            remote=remote,
-            by_domain=by_domain,
-            status=status,
-            username=username,
-            display_name=display_name,
-            email=email,
-            ip=ip,
-            staff_only=staff_only,
-            max_id=max_id,
-            min_id=min_id,
-            since_id=since_id
-        )
-    @api_version("2.9.1", "2.9.1", _DICT_VERSION_ADMIN_ACCOUNT)
-    def admin_accounts_v1(self, remote=False, by_domain=None, status='active', username=None, display_name=None, email=None, ip=None, staff_only=False, max_id=None, min_id=None, since_id=None, limit=None):
-        """
-        Fetches a list of accounts that match given criteria. By default, local accounts are returned.
-        * Set `remote` to True to get remote accounts, otherwise local accounts are returned (default: local accounts)
-        * Set `by_domain` to a domain to get only accounts from that domain.
-        * Set `status` to one of "active", "pending", "disabled", "silenced" or "suspended" to get only accounts with that moderation status (default: active)
-        * Set `username` to a string to get only accounts whose username contains this string.
-        * Set `display_name` to a string to get only accounts whose display name contains this string.
-        * Set `email` to an email to get only accounts with that email (this only works on local accounts).
-        * Set `ip` to an ip (as a string, standard v4/v6 notation) to get only accounts whose last active ip is that ip (this only works on local accounts).
-        * Set `staff_only` to True to only get staff accounts (this only works on local accounts).
-        Note that setting the boolean parameters to False does not mean "give me users to which this does not apply" but
-        instead means "I do not care if users have this attribute".
-        Deprecated in Mastodon version 3.5.0.
-        Returns a list of :ref:`admin account dicts <admin account dicts>`.
-        """
-        if max_id is not None:
-            max_id = self.__unpack_id(max_id, dateconv=True)
-        if min_id is not None:
-            min_id = self.__unpack_id(min_id, dateconv=True)
-        if since_id is not None:
-            since_id = self.__unpack_id(since_id, dateconv=True)
-        params = self.__generate_params(locals(), ['remote', 'status', 'staff_only'])
-        if remote:
-            params["remote"] = True
-        mod_statuses = ["active", "pending", "disabled", "silenced", "suspended"]
-        if not status in mod_statuses:
-            raise ValueError("Invalid moderation status requested.")
-        if staff_only:
-            params["staff"] = True
-        for mod_status in mod_statuses:
-            if status == mod_status:
-                params[status] = True
-        if not by_domain is None:
-            by_domain = self.__deprotocolize(by_domain)
-        return self.__api_request('GET', '/api/v1/admin/accounts', params)
-    @api_version("2.9.1", "2.9.1", _DICT_VERSION_ADMIN_ACCOUNT)
-    def admin_account(self, id):
-        """
-        Fetches a single :ref:`admin account dict <admin account dict>` for the user with the given id.
-        Returns that dict.
-        """
-        id = self.__unpack_id(id)
-        return self.__api_request('GET', '/api/v1/admin/accounts/{0}'.format(id))
-    @api_version("2.9.1", "2.9.1", _DICT_VERSION_ADMIN_ACCOUNT)
-    def admin_account_enable(self, id):
-        """
-        Reenables login for a local account for which login has been disabled.
-        Returns the updated :ref:`admin account dict <admin account dict>`.
-        """
-        id = self.__unpack_id(id)
-        return self.__api_request('POST', '/api/v1/admin/accounts/{0}/enable'.format(id))
-    @api_version("2.9.1", "2.9.1", _DICT_VERSION_ADMIN_ACCOUNT)
-    def admin_account_approve(self, id):
-        """
-        Approves a pending account.
-        Returns the updated :ref:`admin account dict <admin account dict>`.
-        """
-        id = self.__unpack_id(id)
-        return self.__api_request('POST', '/api/v1/admin/accounts/{0}/approve'.format(id))
-    @api_version("2.9.1", "2.9.1", _DICT_VERSION_ADMIN_ACCOUNT)
-    def admin_account_reject(self, id):
-        """
-        Rejects and deletes a pending account.
-        Returns the updated :ref:`admin account dict <admin account dict>` for the account that is now gone.
-        """
-        id = self.__unpack_id(id)
-        return self.__api_request('POST', '/api/v1/admin/accounts/{0}/reject'.format(id))
-    @api_version("2.9.1", "2.9.1", _DICT_VERSION_ADMIN_ACCOUNT)
-    def admin_account_unsilence(self, id):
-        """
-        Unsilences an account.
-        Returns the updated :ref:`admin account dict <admin account dict>`.
-        """
-        id = self.__unpack_id(id)
-        return self.__api_request('POST', '/api/v1/admin/accounts/{0}/unsilence'.format(id))
-    @api_version("2.9.1", "2.9.1", _DICT_VERSION_ADMIN_ACCOUNT)
-    def admin_account_unsuspend(self, id):
-        """
-        Unsuspends an account.
-        Returns the updated :ref:`admin account dict <admin account dict>`.
-        """
-        id = self.__unpack_id(id)
-        return self.__api_request('POST', '/api/v1/admin/accounts/{0}/unsuspend'.format(id))
-    @api_version("3.3.0", "3.3.0", _DICT_VERSION_ADMIN_ACCOUNT)
-    def admin_account_delete(self, id):
-        """
-        Delete a local user account.
-        The deleted accounts :ref:`admin account dict <admin account dict>`.
-        """
-        id = self.__unpack_id(id)
-        return self.__api_request('DELETE', '/api/v1/admin/accounts/{0}'.format(id))
-    @api_version("3.3.0", "3.3.0", _DICT_VERSION_ADMIN_ACCOUNT)
-    def admin_account_unsensitive(self, id):
-        """
-        Unmark an account as force-sensitive.
-        Returns the updated :ref:`admin account dict <admin account dict>`.
-        """
-        id = self.__unpack_id(id)
-        return self.__api_request('POST', '/api/v1/admin/accounts/{0}/unsensitive'.format(id))
-    @api_version("2.9.1", "2.9.1", "2.9.1")
-    def admin_account_moderate(self, id, action=None, report_id=None, warning_preset_id=None, text=None, send_email_notification=True):
-        """
-        Perform a moderation action on an account.
-        Valid actions are:
-            * "disable" - for a local user, disable login.
-            * "silence" - hide the users posts from all public timelines.
-            * "suspend" - irreversibly delete all the user's posts, past and future.
-            * "sensitive" - forcce an accounts media visibility to always be sensitive.
-        If no action is specified, the user is only issued a warning.
-        Specify the id of a report as `report_id` to close the report with this moderation action as the resolution.
-        Specify `warning_preset_id` to use a warning preset as the notification text to the user, or `text` to specify text directly.
-        If both are specified, they are concatenated (preset first). Note that there is currently no API to retrieve or create
-        warning presets.
-        Set `send_email_notification` to False to not send the user an email notification informing them of the moderation action.
-        """
-        if action is None:
-            action = "none"
-        if not send_email_notification:
-            send_email_notification = None
-        id = self.__unpack_id(id)
-        if report_id is not None:
-            report_id = self.__unpack_id(report_id)
-        params = self.__generate_params(locals(), ['id', 'action'])
-        params["type"] = action
-        self.__api_request(
-            'POST', '/api/v1/admin/accounts/{0}/action'.format(id), params)
-    @api_version("2.9.1", "2.9.1", _DICT_VERSION_REPORT)
-    def admin_reports(self, resolved=False, account_id=None, target_account_id=None, max_id=None, min_id=None, since_id=None, limit=None):
-        """
-        Fetches the list of reports.
-        Set `resolved` to True to search for resolved reports. `account_id` and `target_account_id`
-        can be used to get reports filed by or about a specific user.
-        Returns a list of :ref:`report dicts <report dicts>`.
-        """
-        if max_id is not None:
-            max_id = self.__unpack_id(max_id, dateconv=True)
-        if min_id is not None:
-            min_id = self.__unpack_id(min_id, dateconv=True)
-        if since_id is not None:
-            since_id = self.__unpack_id(since_id, dateconv=True)
-        if account_id is not None:
-            account_id = self.__unpack_id(account_id)
-        if target_account_id is not None:
-            target_account_id = self.__unpack_id(target_account_id)
-        if not resolved:
-            resolved = None
-        params = self.__generate_params(locals())
-        return self.__api_request('GET', '/api/v1/admin/reports', params)
-    @api_version("2.9.1", "2.9.1", _DICT_VERSION_REPORT)
-    def admin_report(self, id):
-        """
-        Fetches the report with the given id.
-        Returns a :ref:`report dict <report dict>`.
-        """
-        id = self.__unpack_id(id)
-        return self.__api_request('GET', '/api/v1/admin/reports/{0}'.format(id))
-    @api_version("2.9.1", "2.9.1", _DICT_VERSION_REPORT)
-    def admin_report_assign(self, id):
-        """
-        Assigns the given report to the logged-in user.
-        Returns the updated :ref:`report dict <report dict>`.
-        """
-        id = self.__unpack_id(id)
-        return self.__api_request('POST', '/api/v1/admin/reports/{0}/assign_to_self'.format(id))
-    @api_version("2.9.1", "2.9.1", _DICT_VERSION_REPORT)
-    def admin_report_unassign(self, id):
-        """
-        Unassigns the given report from the logged-in user.
-        Returns the updated :ref:`report dict <report dict>`.
-        """
-        id = self.__unpack_id(id)
-        return self.__api_request('POST', '/api/v1/admin/reports/{0}/unassign'.format(id))
-    @api_version("2.9.1", "2.9.1", _DICT_VERSION_REPORT)
-    def admin_report_reopen(self, id):
-        """
-        Reopens a closed report.
-        Returns the updated :ref:`report dict <report dict>`.
-        """
-        id = self.__unpack_id(id)
-        return self.__api_request('POST', '/api/v1/admin/reports/{0}/reopen'.format(id))
-    @api_version("2.9.1", "2.9.1", _DICT_VERSION_REPORT)
-    def admin_report_resolve(self, id):
-        """
-        Marks a report as resolved (without taking any action).
-        Returns the updated :ref:`report dict <report dict>`.
-        """
-        id = self.__unpack_id(id)
-        return self.__api_request('POST', '/api/v1/admin/reports/{0}/resolve'.format(id))
-    @api_version("3.5.0", "3.5.0", _DICT_VERSION_HASHTAG)
-    def admin_trending_tags(self, limit=None):
-        """
-        Admin version of :ref:`trending_tags() <trending_tags()>`. Includes unapproved tags.
-        Returns a list of :ref:`hashtag dicts <hashtag dicts>`, sorted by the instance's trending algorithm,
-        descending.
-        """
-        params = self.__generate_params(locals())
-        return self.__api_request('GET', '/api/v1/admin/trends/tags', params)
-    @api_version("3.5.0", "3.5.0", _DICT_VERSION_STATUS)
-    def admin_trending_statuses(self):
-        """
-        Admin version of :ref:`trending_statuses() <trending_statuses()>`. Includes unapproved tags.
-        Returns a list of :ref:`status dicts <status dicts>`, sorted by the instance's trending algorithm,
-        descending.
-        """
-        params = self.__generate_params(locals())
-        return self.__api_request('GET', '/api/v1/admin/trends/statuses', params)
-    @api_version("3.5.0", "3.5.0", _DICT_VERSION_CARD)
-    def admin_trending_links(self):
-        """
-        Admin version of :ref:`trending_links() <trending_links()>`. Includes unapproved tags.
-        Returns a list of :ref:`card dicts <card dicts>`, sorted by the instance's trending algorithm,
-        descending.
-        """
-        params = self.__generate_params(locals())
-        return self.__api_request('GET', '/api/v1/admin/trends/links', params)
-    @api_version("4.0.0", "4.0.0", _DICT_VERSION_ADMIN_DOMAIN_BLOCK)
-    def admin_domain_blocks(self, id=None, limit:int=None):
-        """
-        Fetches a list of blocked domains. Requires scope `admin:read:domain_blocks`.
-        Provide an `id` to fetch a specific domain block based on its database id.
-        Returns a list of :ref:`admin domain block dicts <admin domain block dicts>`, raises a `MastodonAPIError` if the specified block does not exist.
-        """
-        if id is not None:
-            id = self.__unpack_id(id)
-            return self.__api_request('GET', '/api/v1/admin/domain_blocks/{0}'.format(id))
-        else:
-            params = self.__generate_params(locals(),['limit'])
-            return self.__api_request('GET', '/api/v1/admin/domain_blocks/', params)
-    
-    @api_version("4.0.0", "4.0.0", _DICT_VERSION_ADMIN_DOMAIN_BLOCK)
-    def admin_create_domain_block(self, domain:str, severity:str=None, reject_media:bool=None, reject_reports:bool=None, private_comment:str=None, public_comment:str=None, obfuscate:bool=None):
-        """
-        Perform a moderation action on a domain. Requires scope `admin:write:domain_blocks`.
-        Valid severities are:
-            * "silence" - hide all posts from federated timelines and do not show notifications to local users from the remote instance's users unless they are following the remote user. 
-            * "suspend" - deny interactions with this instance going forward. This action is reversible.
-            * "limit" - generally used with reject_media=true to force reject media from an instance without silencing or suspending..
-        If no action is specified, the domain is only silenced.
-        `domain` is the domain to block. Note that using the top level domain will also imapct all subdomains. ie, example.com will also impact subdomain.example.com.
-        `reject_media` will not download remote media on to your local instance media storage.
-        `reject_reports` ignores all reports from the remote instance.
-        `private_comment` sets a private admin comment for the domain.
-        `public_comment` sets a publicly available comment for this domain, which will be available to local users and may be available to everyone depending on your settings.
-        `obfuscate` censors some part of the domain name. Useful if the domain name contains unwanted words like slurs.
-        Returns the new domain block as an :ref:`admin domain block dict <admin domain block dict>`.
-        """
-        if domain is None:
-            raise AttributeError("Must provide a domain to block a domain")
-        params = self.__generate_params(locals())
-        return self.__api_request('POST', '/api/v1/admin/domain_blocks/', params)
-    @api_version("4.0.0", "4.0.0", _DICT_VERSION_ADMIN_DOMAIN_BLOCK)
-    def admin_update_domain_block(self, id, severity:str=None, reject_media:bool=None, reject_reports:bool=None, private_comment:str=None, public_comment:str=None, obfuscate:bool=None):
-        """
-        Modify existing moderation action on a domain. Requires scope `admin:write:domain_blocks`.
-        Valid severities are:
-            * "silence" - hide all posts from federated timelines and do not show notifications to local users from the remote instance's users unless they are following the remote user. 
-            * "suspend" - deny interactions with this instance going forward. This action is reversible.
-            * "limit" - generally used with reject_media=true to force reject media from an instance without silencing or suspending.
-        If no action is specified, the domain is only silenced.
-        `domain` is the domain to block. Note that using the top level domain will also imapct all subdomains. ie, example.com will also impact subdomain.example.com.
-        `reject_media` will not download remote media on to your local instance media storage.
-        `reject_reports` ignores all reports from the remote instance.
-        `private_comment` sets a private admin comment for the domain.
-        `public_comment` sets a publicly available comment for this domain, which will be available to local users and may be available to everyone depending on your settings.
-        `obfuscate` censors some part of the domain name. Useful if the domain name contains unwanted words like slurs.
-        Returns the modified domain block as an :ref:`admin domain block dict <admin domain block dict>`, raises a `MastodonAPIError` if the specified block does not exist.
-        """
-        if id is None:
-            raise AttributeError("Must provide an id to modify the existing moderation actions on a given domain.")
-        id = self.__unpack_id(id)
-        params = self.__generate_params(locals(), ["id"])
-        return self.__api_request('PUT', '/api/v1/admin/domain_blocks/{0}'.format(id), params)
-    @api_version("4.0.0", "4.0.0", _DICT_VERSION_ADMIN_DOMAIN_BLOCK)
-    def admin_delete_domain_block(self, id=None):
-        """
-        Removes moderation action against a given domain. Requires scope `admin:write:domain_blocks`.
-        Provide an `id` to remove a specific domain block based on its database id.
-        Raises a `MastodonAPIError` if the specified block does not exist.
-        """
-        if id is not None:
-            id = self.__unpack_id(id)
-            self.__api_request('DELETE', '/api/v1/admin/domain_blocks/{0}'.format(id))
-        else:
-            raise AttributeError("You must provide an id of an existing domain block to remove it.")
-    @api_version("3.5.0", "3.5.0", _DICT_VERSION_ADMIN_MEASURE)
-    def admin_measures(self, start_at, end_at, active_users=False, new_users=False, interactions=False, opened_reports = False, resolved_reports=False,
-                        tag_accounts=None, tag_uses=None, tag_servers=None, instance_accounts=None, instance_media_attachments=None, instance_reports=None,
-                        instance_statuses=None, instance_follows=None, instance_followers=None):
-        """
-        Retrieves numerical instance information for the time period (at day granularity) between `start_at` and `end_at`.
-            * `active_users`: Pass true to retrieve the number of active users on your instance within the time period
-            * `new_users`: Pass true to retrieve the number of users who joined your instance within the time period
-            * `interactions`: Pass true to retrieve the number of interactions (favourites, boosts, replies) on local statuses within the time period
-            * `opened_reports`: Pass true to retrieve the number of reports filed within the time period
-            * `resolved_reports` = Pass true to retrieve the number of reports resolved within the time period
-            * `tag_accounts`: Pass a tag ID to get the number of accounts which used that tag in at least one status within the time period
-            * `tag_uses`: Pass a tag ID to get the number of statuses which used that tag within the time period
-            * `tag_servers`: Pass a tag ID to to get the number of remote origin servers for statuses which used that tag within the time period
-            * `instance_accounts`: Pass a domain to get the number of accounts originating from that remote domain within the time period
-            * `instance_media_attachments`: Pass a domain to get the amount of space used by media attachments from that remote domain within the time period
-            * `instance_reports`: Pass a domain to get the number of reports filed against accounts from that remote domain within the time period
-            * `instance_statuses`: Pass a domain to get the number of statuses originating from that remote domain within the time period
-            * `instance_follows`: Pass a domain to get the number of accounts from a remote domain followed by that local user within the time period
-            * `instance_followers`: Pass a domain to get the number of local accounts followed by accounts from that remote domain within the time period
-        This API call is relatively expensive - watch your servers load if you want to get a lot of statistical data. Especially the instance_statuses stats
-        might take a long time to compute and, in fact, time out.
-        There is currently no way to get tag IDs implemented in Mastodon.py, because the Mastodon public API does not implement one. This will be fixed in a future
-        release.
-        Returns a list of :ref:`admin measure dicts <admin measure dicts>`.
-        """
-        params_init = locals()
-        keys = []
-        for key in ["active_users", "new_users", "interactions", "opened_reports", "resolved_reports"]:
-            if params_init[key] == True:
-                keys.append(key)
-        
-        params = {}
-        for key in ["tag_accounts", "tag_uses", "tag_servers"]:
-            if params_init[key] is not None:
-                keys.append(key)
-                params[key] = {"id": self.__unpack_id(params_init[key])}
-        for key in ["instance_accounts", "instance_media_attachments", "instance_reports", "instance_statuses", "instance_follows", "instance_followers"]:
-            if params_init[key] is not None:
-                keys.append(key)
-                params[key] = {"domain": Mastodon.__deprotocolize(params_init[key]).split("/")[0]}
-        if len(keys) == 0:
-            raise MastodonIllegalArgumentError("Must request at least one metric.")
-        params["keys"] = keys
-        params["start_at"] = self.__consistent_isoformat_utc(start_at)
-        params["end_at"] = self.__consistent_isoformat_utc(end_at)
-        
-        return self.__api_request('POST', '/api/v1/admin/measures', params, use_json=True)
-    @api_version("3.5.0", "3.5.0", _DICT_VERSION_ADMIN_DIMENSION)
-    def admin_dimensions(self, start_at, end_at, limit=None, languages=False, sources=False, servers=False, space_usage=False, software_versions=False,
-                            tag_servers=None, tag_languages=None, instance_accounts=None, instance_languages=None):
-        """
-        Retrieves primarily categorical instance information for the time period (at day granularity) between `start_at` and `end_at`.
-            * `languages`: Pass true to get the most-used languages on this server
-            * `sources`: Pass true to get the most-used client apps on this server
-            * `servers`: Pass true to get the remote servers with the most statuses
-            * `space_usage`: Pass true to get the how much space is used by different components your software stack
-            * `software_versions`: Pass true to get the version numbers for your software stack
-            * `tag_servers`: Pass a tag ID to get the most-common servers for statuses including a trending tag
-            * `tag_languages`: Pass a tag ID to get the most-used languages for statuses including a trending tag
-            * `instance_accounts`: Pass a domain to get the most-followed accounts from a remote server
-            * `instance_languages`: Pass a domain to get the most-used languages from a remote server
-        Pass `limit` to set how many results you want on queries where that makes sense.
-        This API call is relatively expensive - watch your servers load if you want to get a lot of statistical data.
-        There is currently no way to get tag IDs implemented in Mastodon.py, because the Mastodon public API does not implement one. This will be fixed in a future
-        release.
-        Returns a list of :ref:`admin dimension dicts <admin dimension dicts>`.
-        """
-        params_init = locals()
-        keys = []
-        for key in ["languages", "sources", "servers", "space_usage", "software_versions"]:
-            if params_init[key] == True:
-                keys.append(key)
-        
-        params = {}
-        for key in ["tag_servers", "tag_languages"]:
-            if params_init[key] is not None:
-                keys.append(key)
-                params[key] = {"id": self.__unpack_id(params_init[key])}
-        for key in ["instance_accounts", "instance_languages"]:
-            if params_init[key] is not None:
-                keys.append(key)
-                params[key] = {"domain": Mastodon.__deprotocolize(params_init[key]).split("/")[0]}
-        if len(keys) == 0:
-            raise MastodonIllegalArgumentError("Must request at least one dimension.")
-        params["keys"] = keys
-        if limit is not None:
-            params["limit"] = limit
-        params["start_at"] = self.__consistent_isoformat_utc(start_at)
-        params["end_at"] = self.__consistent_isoformat_utc(end_at)
-        
-        return self.__api_request('POST', '/api/v1/admin/dimensions', params, use_json=True)
-    @api_version("3.5.0", "3.5.0", _DICT_VERSION_ADMIN_RETENTION)
-    def admin_retention(self, start_at, end_at, frequency="day"):
-        """
-        Gets user retention statistics (at `frequency` - "day" or "month" - granularity) between `start_at` and `end_at`.
-        Returns a list of :ref:`admin retention dicts <admin retention dicts>`
-        """
-        if not frequency in ["day", "month"]:
-            raise MastodonIllegalArgumentError("Frequency must be day or month")
-        params = {
-            "start_at": self.__consistent_isoformat_utc(start_at),
-            "end_at": self.__consistent_isoformat_utc(end_at),
-            "frequency": frequency
-        }
-        return self.__api_request('POST', '/api/v1/admin/retention', params)
-    ###
-    # Push subscription crypto utilities
-    ###
-    def push_subscription_generate_keys(self):
-        """
-        Generates a private key, public key and shared secret for use in webpush subscriptions.
-        Returns two dicts: One with the private key and shared secret and another with the
-        public key and shared secret.
-        """
-        if not IMPL_HAS_CRYPTO:
-            raise NotImplementedError(
-                'To use the crypto tools, please install the webpush feature dependencies.')
-        push_key_pair = ec.generate_private_key(ec.SECP256R1(), default_backend())
-        push_key_priv = push_key_pair.private_numbers().private_value
-        try: 
-            push_key_pub = push_key_pair.public_key().public_bytes(
-                serialization.Encoding.X962,
-                serialization.PublicFormat.UncompressedPoint,
-            )
-        except:
-            push_key_pub = push_key_pair.public_key().public_numbers().encode_point()
-            
-        push_shared_secret = os.urandom(16)
-        priv_dict = {
-            'privkey': push_key_priv,
-            'auth': push_shared_secret
-        }
-        pub_dict = {
-            'pubkey': push_key_pub,
-            'auth': push_shared_secret
-        }
-        return priv_dict, pub_dict
-    @api_version("2.4.0", "2.4.0", _DICT_VERSION_PUSH_NOTIF)
-    def push_subscription_decrypt_push(self, data, decrypt_params, encryption_header, crypto_key_header):
-        """
-        Decrypts `data` received in a webpush request. Requires the private key dict
-        from :ref:`push_subscription_generate_keys() <push_subscription_generate_keys()>` (`decrypt_params`) as well as the
-        Encryption and server Crypto-Key headers from the received webpush
-        Returns the decoded webpush as a :ref:`push notification dict <push notification dict>`.
-        """
-        if (not IMPL_HAS_ECE) or (not IMPL_HAS_CRYPTO):
-            raise NotImplementedError(
-                'To use the crypto tools, please install the webpush feature dependencies.')
-        salt = self.__decode_webpush_b64(encryption_header.split("salt=")[1].strip())
-        dhparams = self.__decode_webpush_b64(crypto_key_header.split("dh=")[1].split(";")[0].strip())
-        p256ecdsa = self.__decode_webpush_b64(crypto_key_header.split("p256ecdsa=")[1].strip())
-        dec_key = ec.derive_private_key(decrypt_params['privkey'], ec.SECP256R1(), default_backend())
-        decrypted = http_ece.decrypt(
-            data,
-            salt=salt,
-            key=p256ecdsa,
-            private_key=dec_key,
-            dh=dhparams,
-            auth_secret=decrypt_params['auth'],
-            keylabel="P-256",
-            version="aesgcm"
-        )
-        return json.loads(decrypted.decode('utf-8'), object_hook=Mastodon.__json_hooks)
-    ###
-    # Blurhash utilities
-    ###
-    def decode_blurhash(self, media_dict, out_size=(16, 16), size_per_component=True, return_linear=True):
-        """
-        Basic media-dict blurhash decoding.
-        out_size is the desired result size in pixels, either absolute or per blurhash
-        component (this is the default).
-        By default, this function will return the image as linear RGB, ready for further
-        scaling operations. If you want to display the image directly, set return_linear
-        to False.
-        Returns the decoded blurhash image as a three-dimensional list: [height][width][3],
-        with the last dimension being RGB colours.
-        For further info and tips for advanced usage, refer to the documentation for the
-        blurhash module: https://github.com/halcy/blurhash-python
-        """
-        if not IMPL_HAS_BLURHASH:
-            raise NotImplementedError(
-                'To use the blurhash functions, please install the blurhash Python module.')
-        # Figure out what size to decode to
-        decode_components_x, decode_components_y = blurhash.components(media_dict["blurhash"])
-        if size_per_component:
-            decode_size_x = decode_components_x * out_size[0]
-            decode_size_y = decode_components_y * out_size[1]
-        else:
-            decode_size_x = out_size[0]
-            decode_size_y = out_size[1]
-        # Decode
-        decoded_image = blurhash.decode(media_dict["blurhash"], decode_size_x, decode_size_y, linear=return_linear)
-        # And that's pretty much it.
-        return decoded_image
-    ###
-    # Pagination
-    ###
-    def fetch_next(self, previous_page):
-        """
-        Fetches the next page of results of a paginated request. Pass in the
-        previous page in its entirety, or the pagination information dict
-        returned as a part of that pages last status ('_pagination_next').
-        Returns the next page or None if no further data is available.
-        """
-        if isinstance(previous_page, list) and len(previous_page) != 0:
-            if hasattr(previous_page, '_pagination_next'):
-                params = copy.deepcopy(previous_page._pagination_next)
-            else:
-                return None
-        else:
-            params = copy.deepcopy(previous_page)
-        method = params['_pagination_method']
-        del params['_pagination_method']
-        endpoint = params['_pagination_endpoint']
-        del params['_pagination_endpoint']
-        return self.__api_request(method, endpoint, params)
-    def fetch_previous(self, next_page):
-        """
-        Fetches the previous page of results of a paginated request. Pass in the
-        previous page in its entirety, or the pagination information dict
-        returned as a part of that pages first status ('_pagination_prev').
-        Returns the previous page or None if no further data is available.
-        """
-        if isinstance(next_page, list) and len(next_page) != 0:
-            if hasattr(next_page, '_pagination_prev'):
-                params = copy.deepcopy(next_page._pagination_prev)
-            else:
-                return None
-        else:
-            params = copy.deepcopy(next_page)
-        method = params['_pagination_method']
-        del params['_pagination_method']
-        endpoint = params['_pagination_endpoint']
-        del params['_pagination_endpoint']
-        return self.__api_request(method, endpoint, params)
-    def fetch_remaining(self, first_page):
-        """
-        Fetches all the remaining pages of a paginated request starting from a
-        first page and returns the entire set of results (including the first page
-        that was passed in) as a big list.
-        Be careful, as this might generate a lot of requests, depending on what you are
-        fetching, and might cause you to run into rate limits very quickly.
-        """
-        first_page = copy.deepcopy(first_page)
-        all_pages = []
-        current_page = first_page
-        while current_page is not None and len(current_page) > 0:
-            all_pages.extend(current_page)
-            current_page = self.fetch_next(current_page)
-        return all_pages
-    ###
-    # Streaming
-    ###
-    @api_version("1.1.0", "1.4.2", _DICT_VERSION_STATUS)
-    def stream_user(self, listener, run_async=False, timeout=_DEFAULT_STREAM_TIMEOUT, reconnect_async=False, reconnect_async_wait_sec=_DEFAULT_STREAM_RECONNECT_WAIT_SEC):
-        """
-        Streams events that are relevant to the authorized user, i.e. home
-        timeline and notifications.
-        """
-        return self.__stream('/api/v1/streaming/user', listener, run_async=run_async, timeout=timeout, reconnect_async=reconnect_async, reconnect_async_wait_sec=reconnect_async_wait_sec)
-    @api_version("1.1.0", "1.4.2", _DICT_VERSION_STATUS)
-    def stream_public(self, listener, run_async=False, timeout=_DEFAULT_STREAM_TIMEOUT, reconnect_async=False, reconnect_async_wait_sec=_DEFAULT_STREAM_RECONNECT_WAIT_SEC):
-        """
-        Streams public events.
-        """
-        return self.__stream('/api/v1/streaming/public', listener, run_async=run_async, timeout=timeout, reconnect_async=reconnect_async, reconnect_async_wait_sec=reconnect_async_wait_sec)
-    @api_version("1.1.0", "1.4.2", _DICT_VERSION_STATUS)
-    def stream_local(self, listener, run_async=False, timeout=_DEFAULT_STREAM_TIMEOUT, reconnect_async=False, reconnect_async_wait_sec=_DEFAULT_STREAM_RECONNECT_WAIT_SEC):
-        """
-        Streams local public events.
-        """
-        return self.__stream('/api/v1/streaming/public/local', listener, run_async=run_async, timeout=timeout, reconnect_async=reconnect_async, reconnect_async_wait_sec=reconnect_async_wait_sec)
-    @api_version("1.1.0", "1.4.2", _DICT_VERSION_STATUS)
-    def stream_hashtag(self, tag, listener, local=False, run_async=False, timeout=_DEFAULT_STREAM_TIMEOUT, reconnect_async=False, reconnect_async_wait_sec=_DEFAULT_STREAM_RECONNECT_WAIT_SEC):
-        """
-        Stream for all public statuses for the hashtag 'tag' seen by the connected
-        instance.
-        Set local to True to only get local statuses.
-        """
-        if tag.startswith("#"):
-            raise MastodonIllegalArgumentError(
-                "Tag parameter should omit leading #")
-        base = '/api/v1/streaming/hashtag'
-        if local:
-            base += '/local'
-        return self.__stream("{}?tag={}".format(base, tag), listener, run_async=run_async, timeout=timeout, reconnect_async=reconnect_async, reconnect_async_wait_sec=reconnect_async_wait_sec)
-    @api_version("2.1.0", "2.1.0", _DICT_VERSION_STATUS)
-    def stream_list(self, id, listener, run_async=False, timeout=_DEFAULT_STREAM_TIMEOUT, reconnect_async=False, reconnect_async_wait_sec=_DEFAULT_STREAM_RECONNECT_WAIT_SEC):
-        """
-        Stream events for the current user, restricted to accounts on the given
-        list.
-        """
-        id = self.__unpack_id(id)
-        return self.__stream("/api/v1/streaming/list?list={}".format(id), listener, run_async=run_async, timeout=timeout, reconnect_async=reconnect_async, reconnect_async_wait_sec=reconnect_async_wait_sec)
-    @api_version("2.6.0", "2.6.0", _DICT_VERSION_STATUS)
-    def stream_direct(self, listener, run_async=False, timeout=_DEFAULT_STREAM_TIMEOUT, reconnect_async=False, reconnect_async_wait_sec=_DEFAULT_STREAM_RECONNECT_WAIT_SEC):
-        """
-        Streams direct message events for the logged-in user, as conversation events.
-        """
-        return self.__stream('/api/v1/streaming/direct', listener, run_async=run_async, timeout=timeout, reconnect_async=reconnect_async, reconnect_async_wait_sec=reconnect_async_wait_sec)
-    @api_version("2.5.0", "2.5.0", "2.5.0")
-    def stream_healthy(self):
-        """
-        Returns without True if streaming API is okay, False or raises an error otherwise.
-        """
-        api_okay = self.__api_request('GET', '/api/v1/streaming/health', base_url_override=self.__get_streaming_base(), parse=False)
-        if api_okay in [b'OK', b'success']:
-            return True
-        return False
diff --git a/mastodon/accounts.py b/mastodon/accounts.py
index 5ecdf93..219edac 100644
--- a/mastodon/accounts.py
+++ b/mastodon/accounts.py
@@ -1,5 +1,10 @@
+# accounts.py - account related endpoints
+import collections
+from .versions import _DICT_VERSION_ACCOUNT, _DICT_VERSION_STATUS, _DICT_VERSION_RELATIONSHIP, _DICT_VERSION_LIST, _DICT_VERSION_FAMILIAR_FOLLOWERS, _DICT_VERSION_HASHTAG
 from .defaults import _DEFAULT_SCOPES, _SCOPE_SETS
-from .error import MastodonIllegalArgumentError, MastodonAPIError
+from .errors import MastodonIllegalArgumentError, MastodonAPIError
 from .utility import api_version
 from .internals import Mastodon as Internals
@@ -105,3 +110,391 @@ class Mastodon(Internals):
        Only available to the app that the user originally signed up with.
        """
        self.__api_request('POST', '/api/v1/emails/confirmations')
+    ###
+    # Reading data: Accounts
+    ###
+    @api_version("1.0.0", "1.0.0", _DICT_VERSION_ACCOUNT)
+    def account(self, id):
+        """
+        Fetch account information by user `id`.
+        Does not require authentication for publicly visible accounts.
+        Returns a :ref:`account dict <account dict>`.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/accounts/{0}'.format(str(id))
+        return self.__api_request('GET', url)
+    @api_version("1.0.0", "2.1.0", _DICT_VERSION_ACCOUNT)
+    def account_verify_credentials(self):
+        """
+        Fetch logged-in user's account information.
+        Returns a :ref:`account dict <account dict>` (Starting from 2.1.0, with an additional "source" field).
+        """
+        return self.__api_request('GET', '/api/v1/accounts/verify_credentials')
+    @api_version("1.0.0", "2.1.0", _DICT_VERSION_ACCOUNT)
+    def me(self):
+        """
+        Get this user's account. Synonym for `account_verify_credentials()`, does exactly
+        the same thing, just exists becase `account_verify_credentials()` has a confusing
+        name.
+        """
+        return self.account_verify_credentials()
+    @api_version("1.0.0", "2.8.0", _DICT_VERSION_STATUS)
+    def account_statuses(self, id, only_media=False, pinned=False, exclude_replies=False, exclude_reblogs=False, tagged=None, max_id=None, min_id=None, since_id=None, limit=None):
+        """
+        Fetch statuses by user `id`. Same options as :ref:`timeline() <timeline()>` are permitted.
+        Returned toots are from the perspective of the logged-in user, i.e.
+        all statuses visible to the logged-in user (including DMs) are
+        included.
+        If `only_media` is set, return only statuses with media attachments.
+        If `pinned` is set, return only statuses that have been pinned. Note that
+        as of Mastodon 2.1.0, this only works properly for instance-local users.
+        If `exclude_replies` is set, filter out all statuses that are replies.
+        If `exclude_reblogs` is set, filter out all statuses that are reblogs.
+        If `tagged` is set, return only statuses that are tagged with `tagged`. Only a single tag without a '#' is valid.
+        Does not require authentication for Mastodon versions after 2.7.0 (returns
+        publicly visible statuses in that case), for publicly visible accounts.
+        Returns a list of :ref:`status dicts <status dicts>`.
+        """
+        id = self.__unpack_id(id)
+        if max_id is not None:
+            max_id = self.__unpack_id(max_id, dateconv=True)
+        if min_id is not None:
+            min_id = self.__unpack_id(min_id, dateconv=True)
+        if since_id is not None:
+            since_id = self.__unpack_id(since_id, dateconv=True)
+        params = self.__generate_params(locals(), ['id'])
+        if not pinned:
+            del params["pinned"]
+        if not only_media:
+            del params["only_media"]
+        if not exclude_replies:
+            del params["exclude_replies"]
+        if not exclude_reblogs:
+            del params["exclude_reblogs"]
+        url = '/api/v1/accounts/{0}/statuses'.format(str(id))
+        return self.__api_request('GET', url, params)
+    @api_version("1.0.0", "2.6.0", _DICT_VERSION_ACCOUNT)
+    def account_following(self, id, max_id=None, min_id=None, since_id=None, limit=None):
+        """
+        Fetch users the given user is following.
+        Returns a list of :ref:`account dicts <account dicts>`.
+        """
+        id = self.__unpack_id(id)
+        if max_id is not None:
+            max_id = self.__unpack_id(max_id, dateconv=True)
+        if min_id is not None:
+            min_id = self.__unpack_id(min_id, dateconv=True)
+        if since_id is not None:
+            since_id = self.__unpack_id(since_id, dateconv=True)
+        params = self.__generate_params(locals(), ['id'])
+        url = '/api/v1/accounts/{0}/following'.format(str(id))
+        return self.__api_request('GET', url, params)
+    @api_version("1.0.0", "2.6.0", _DICT_VERSION_ACCOUNT)
+    def account_followers(self, id, max_id=None, min_id=None, since_id=None, limit=None):
+        """
+        Fetch users the given user is followed by.
+        Returns a list of :ref:`account dicts <account dicts>`.
+        """
+        id = self.__unpack_id(id)
+        if max_id is not None:
+            max_id = self.__unpack_id(max_id, dateconv=True)
+        if min_id is not None:
+            min_id = self.__unpack_id(min_id, dateconv=True)
+        if since_id is not None:
+            since_id = self.__unpack_id(since_id, dateconv=True)
+        params = self.__generate_params(locals(), ['id'])
+        url = '/api/v1/accounts/{0}/followers'.format(str(id))
+        return self.__api_request('GET', url, params)
+    @api_version("1.0.0", "1.4.0", _DICT_VERSION_RELATIONSHIP)
+    def account_relationships(self, id):
+        """
+        Fetch relationship (following, followed_by, blocking, follow requested) of
+        the logged in user to a given account. `id` can be a list.
+        Returns a list of :ref:`relationship dicts <relationship dicts>`.
+        """
+        id = self.__unpack_id(id)
+        params = self.__generate_params(locals())
+        return self.__api_request('GET', '/api/v1/accounts/relationships',
+                                  params)
+    @api_version("1.0.0", "2.3.0", _DICT_VERSION_ACCOUNT)
+    def account_search(self, q, limit=None, following=False):
+        """
+        Fetch matching accounts. Will lookup an account remotely if the search term is
+        in the username@domain format and not yet in the database. Set `following` to
+        True to limit the search to users the logged-in user follows.
+        Returns a list of :ref:`account dicts <account dicts>`.
+        """
+        params = self.__generate_params(locals())
+        if params["following"] == False:
+            del params["following"]
+        return self.__api_request('GET', '/api/v1/accounts/search', params)
+    @api_version("2.1.0", "2.1.0", _DICT_VERSION_LIST)
+    def account_lists(self, id):
+        """
+        Get all of the logged-in user's lists which the specified user is
+        a member of.
+        Returns a list of :ref:`list dicts <list dicts>`.
+        """
+        id = self.__unpack_id(id)
+        params = self.__generate_params(locals(), ['id'])
+        url = '/api/v1/accounts/{0}/lists'.format(str(id))
+        return self.__api_request('GET', url, params)
+    @api_version("3.4.0", "3.4.0", _DICT_VERSION_ACCOUNT)
+    def account_lookup(self, acct):
+        """
+        Look up an account from user@instance form (@instance allowed but not required for
+        local accounts). Will only return accounts that the instance already knows about, 
+        and not do any webfinger requests. Use `account_search` if you need to resolve users 
+        through webfinger from remote.
+        Returns an :ref:`account dict <account dict>`.
+        """
+        return self.__api_request('GET', '/api/v1/accounts/lookup', self.__generate_params(locals()))
+    
+    @api_version("3.5.0", "3.5.0", _DICT_VERSION_FAMILIAR_FOLLOWERS)
+    def account_familiar_followers(self, id):
+        """
+        Find followers for the account given by id (can be a list) that also follow the
+        logged in account.
+        Returns a list of :ref:`familiar follower dicts <familiar follower dicts>`
+        """
+        if not isinstance(id, list):
+            id = [id]
+        for i in range(len(id)):
+            id[i] = self.__unpack_id(id[i])
+        return self.__api_request('GET', '/api/v1/accounts/familiar_followers', {'id': id}, use_json=True)
+    ###
+    # Writing data: Accounts
+    ###
+    @api_version("1.0.0", "3.3.0", _DICT_VERSION_RELATIONSHIP)
+    def account_follow(self, id, reblogs=True, notify=False):
+        """
+        Follow a user.
+        Set `reblogs` to False to hide boosts by the followed user.
+        Set `notify` to True to get a notification every time the followed user posts.
+        Returns a :ref:`relationship dict <relationship dict>` containing the updated relationship to the user.
+        """
+        id = self.__unpack_id(id)
+        params = self.__generate_params(locals(), ["id"])
+        if params["reblogs"] is None:
+            del params["reblogs"]
+        url = '/api/v1/accounts/{0}/follow'.format(str(id))
+        return self.__api_request('POST', url, params)
+    @api_version("1.0.0", "2.1.0", _DICT_VERSION_ACCOUNT)
+    def follows(self, uri):
+        """
+        Follow a remote user by uri (username@domain).
+        Returns a :ref:`account dict <account dict>`.
+        """
+        params = self.__generate_params(locals())
+        return self.__api_request('POST', '/api/v1/follows', params)
+    @api_version("1.0.0", "1.4.0", _DICT_VERSION_RELATIONSHIP)
+    def account_unfollow(self, id):
+        """
+        Unfollow a user.
+        Returns a :ref:`relationship dict <relationship dict>` containing the updated relationship to the user.
+        """
+        id = self.__unpack_id(id)
+        return self.__api_request('POST', '/api/v1/accounts/{0}/unfollow'.format(str(id)))
+    @api_version("3.5.0", "3.5.0", _DICT_VERSION_RELATIONSHIP)
+    def account_remove_from_followers(self, id):
+        """
+        Remove a user from the logged in users followers (i.e. make them unfollow the logged in
+        user / "softblock" them).
+        Returns a :ref:`relationship dict <relationship dict>` reflecting the updated following status.
+        """
+        id = self.__unpack_id(id)
+        return self.__api_request('POST', '/api/v1/accounts/{0}/remove_from_followers'.format(str(id)))
+    
+    @api_version("1.0.0", "1.4.0", _DICT_VERSION_RELATIONSHIP)
+    def account_block(self, id):
+        """
+        Block a user.
+        Returns a :ref:`relationship dict <relationship dict>` containing the updated relationship to the user.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/accounts/{0}/block'.format(str(id))
+        return self.__api_request('POST', url)
+    @api_version("1.0.0", "1.4.0", _DICT_VERSION_RELATIONSHIP)
+    def account_unblock(self, id):
+        """
+        Unblock a user.
+        Returns a :ref:`relationship dict <relationship dict>` containing the updated relationship to the user.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/accounts/{0}/unblock'.format(str(id))
+        return self.__api_request('POST', url)
+    @api_version("1.1.0", "2.4.3", _DICT_VERSION_RELATIONSHIP)
+    def account_mute(self, id, notifications=True, duration=None):
+        """
+        Mute a user.
+        Set `notifications` to False to receive notifications even though the user is
+        muted from timelines. Pass a `duration` in seconds to have Mastodon automatically
+        lift the mute after that many seconds.
+        Returns a :ref:`relationship dict <relationship dict>` containing the updated relationship to the user.
+        """
+        id = self.__unpack_id(id)
+        params = self.__generate_params(locals(), ['id'])
+        url = '/api/v1/accounts/{0}/mute'.format(str(id))
+        return self.__api_request('POST', url, params)
+    @api_version("1.1.0", "1.4.0", _DICT_VERSION_RELATIONSHIP)
+    def account_unmute(self, id):
+        """
+        Unmute a user.
+        Returns a :ref:`relationship dict <relationship dict>` containing the updated relationship to the user.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/accounts/{0}/unmute'.format(str(id))
+        return self.__api_request('POST', url)
+    @api_version("1.1.1", "3.1.0", _DICT_VERSION_ACCOUNT)
+    def account_update_credentials(self, display_name=None, note=None,
+                                   avatar=None, avatar_mime_type=None,
+                                   header=None, header_mime_type=None,
+                                   locked=None, bot=None,
+                                   discoverable=None, fields=None):
+        """
+        Update the profile for the currently logged-in user.
+        `note` is the user's bio.
+        `avatar` and 'header' are images. As with media uploads, it is possible to either
+        pass image data and a mime type, or a filename of an image file, for either.
+        `locked` specifies whether the user needs to manually approve follow requests.
+        `bot` specifies whether the user should be set to a bot.
+        `discoverable` specifies whether the user should appear in the user directory.
+        `fields` can be a list of up to four name-value pairs (specified as tuples) to
+        appear as semi-structured information in the user's profile.
+        Returns the updated `account dict` of the logged-in user.
+        """
+        params_initial = collections.OrderedDict(locals())
+        # Convert fields
+        if fields is not None:
+            if len(fields) > 4:
+                raise MastodonIllegalArgumentError(
+                    'A maximum of four fields are allowed.')
+            fields_attributes = []
+            for idx, (field_name, field_value) in enumerate(fields):
+                params_initial['fields_attributes[' +
+                               str(idx) + '][name]'] = field_name
+                params_initial['fields_attributes[' +
+                               str(idx) + '][value]'] = field_value
+        # Clean up params
+        for param in ["avatar", "avatar_mime_type", "header", "header_mime_type", "fields"]:
+            if param in params_initial:
+                del params_initial[param]
+        # Create file info
+        files = {}
+        if avatar is not None:
+            files["avatar"] = self.__load_media_file(avatar, avatar_mime_type)
+        if header is not None:
+            files["header"] = self.__load_media_file(header, header_mime_type)
+        params = self.__generate_params(params_initial)
+        return self.__api_request('PATCH', '/api/v1/accounts/update_credentials', params, files=files)
+    @api_version("2.5.0", "2.5.0", _DICT_VERSION_RELATIONSHIP)
+    def account_pin(self, id):
+        """
+        Pin / endorse a user.
+        Returns a :ref:`relationship dict <relationship dict>` containing the updated relationship to the user.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/accounts/{0}/pin'.format(str(id))
+        return self.__api_request('POST', url)
+    @api_version("2.5.0", "2.5.0", _DICT_VERSION_RELATIONSHIP)
+    def account_unpin(self, id):
+        """
+        Unpin / un-endorse a user.
+        Returns a :ref:`relationship dict <relationship dict>` containing the updated relationship to the user.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/accounts/{0}/unpin'.format(str(id))
+        return self.__api_request('POST', url)
+    @api_version("3.2.0", "3.2.0", _DICT_VERSION_RELATIONSHIP)
+    def account_note_set(self, id, comment):
+        """
+        Set a note (visible to the logged in user only) for the given account.
+        Returns a :ref:`status dict <status dict>` with the `note` updated.
+        """
+        id = self.__unpack_id(id)
+        params = self.__generate_params(locals(), ["id"])
+        return self.__api_request('POST', '/api/v1/accounts/{0}/note'.format(str(id)), params)
+    @api_version("3.3.0", "3.3.0", _DICT_VERSION_HASHTAG)
+    def account_featured_tags(self, id):
+        """
+        Get an account's featured hashtags.
+        Returns a list of :ref:`hashtag dicts <hashtag dicts>` (NOT `featured tag dicts`_).
+        """
+        id = self.__unpack_id(id)
+        return self.__api_request('GET', '/api/v1/accounts/{0}/featured_tags'.format(str(id)))
diff --git a/mastodon/admin.py b/mastodon/admin.py
new file mode 100644
index 0000000..e2f5f20
--- /dev/null
+++ b/mastodon/admin.py
@@ -0,0 +1,572 @@
+# admin.py - admin / moderation endpoints
+from .versions import _DICT_VERSION_ADMIN_ACCOUNT, _DICT_VERSION_REPORT, _DICT_VERSION_HASHTAG, _DICT_VERSION_STATUS, _DICT_VERSION_CARD, \
+                        _DICT_VERSION_ADMIN_DOMAIN_BLOCK, _DICT_VERSION_ADMIN_MEASURE, _DICT_VERSION_ADMIN_DIMENSION, _DICT_VERSION_ADMIN_RETENTION
+from .errors import MastodonIllegalArgumentError
+from .utility import api_version
+from .internals import Mastodon as Internals
+class Mastodon(Internals):
+    ###
+    # Moderation API
+    ###
+    @api_version("2.9.1", "4.0.0", _DICT_VERSION_ADMIN_ACCOUNT)
+    def admin_accounts_v2(self, origin=None, by_domain=None, status=None, username=None, display_name=None, email=None, ip=None, 
+                            permissions=None, invited_by=None, role_ids=None, max_id=None, min_id=None, since_id=None, limit=None):
+        """
+        Fetches a list of accounts that match given criteria. By default, local accounts are returned.
+        * Set `origin` to "local" or "remote" to get only local or remote accounts.
+        * Set `by_domain` to a domain to get only accounts from that domain.
+        * Set `status` to one of "active", "pending", "disabled", "silenced" or "suspended" to get only accounts with that moderation status (default: active)
+        * Set `username` to a string to get only accounts whose username contains this string.
+        * Set `display_name` to a string to get only accounts whose display name contains this string.
+        * Set `email` to an email to get only accounts with that email (this only works on local accounts).
+        * Set `ip` to an ip (as a string, standard v4/v6 notation) to get only accounts whose last active ip is that ip (this only works on local accounts).
+        * Set `permissions` to "staff" to only get accounts with staff permissions.
+        * Set `invited_by` to an account id to get only accounts invited by this user.
+        * Set `role_ids` to a list of role IDs to get only accounts with those roles.
+        Returns a list of :ref:`admin account dicts <admin account dicts>`.
+        """
+        if max_id is not None:
+            max_id = self.__unpack_id(max_id, dateconv=True)
+        if min_id is not None:
+            min_id = self.__unpack_id(min_id, dateconv=True)
+        if since_id is not None:
+            since_id = self.__unpack_id(since_id, dateconv=True)
+        if role_ids is not None:
+            if not isinstance(role_ids, list):
+                role_ids = [role_ids]
+            role_ids = list(map(self.__unpack_id, role_ids))
+        if invited_by is not None:
+            invited_by = self.__unpack_id(invited_by)
+        if permissions is not None and not permissions in ["staff"]:
+            raise MastodonIllegalArgumentError("Permissions must be staff if passed")
+        if origin is not None and not origin in ["local", "remote"]:
+            raise MastodonIllegalArgumentError("Origin must be local or remote")
+        if status is not None and not status in ["active", "pending", "disabled", "silenced", "suspended"]:
+            raise MastodonIllegalArgumentError("Status must be local or active, pending, disabled, silenced or suspended")
+        if not by_domain is None:
+            by_domain = self.__deprotocolize(by_domain)
+        params = self.__generate_params(locals())
+        return self.__api_request('GET', '/api/v2/admin/accounts', params)
+    @api_version("2.9.1", "2.9.1", _DICT_VERSION_ADMIN_ACCOUNT)
+    def admin_accounts(self, remote=False, by_domain=None, status='active', username=None, display_name=None, email=None, ip=None, staff_only=False, max_id=None, min_id=None, since_id=None, limit=None):
+        """
+        Currently a synonym for admin_accounts_v1, now deprecated. You are strongly encouraged to use admin_accounts_v2 instead, since this one is kind of bad. 
+        
+        !!!!! This function may be switched to calling the v2 API in the future. This is your warning. If you want to keep using v1, use it explicitly. !!!!!
+        """
+        return self.admin_accounts_v1(
+            remote=remote,
+            by_domain=by_domain,
+            status=status,
+            username=username,
+            display_name=display_name,
+            email=email,
+            ip=ip,
+            staff_only=staff_only,
+            max_id=max_id,
+            min_id=min_id,
+            since_id=since_id
+        )
+    @api_version("2.9.1", "2.9.1", _DICT_VERSION_ADMIN_ACCOUNT)
+    def admin_accounts_v1(self, remote=False, by_domain=None, status='active', username=None, display_name=None, email=None, ip=None, staff_only=False, max_id=None, min_id=None, since_id=None, limit=None):
+        """
+        Fetches a list of accounts that match given criteria. By default, local accounts are returned.
+        * Set `remote` to True to get remote accounts, otherwise local accounts are returned (default: local accounts)
+        * Set `by_domain` to a domain to get only accounts from that domain.
+        * Set `status` to one of "active", "pending", "disabled", "silenced" or "suspended" to get only accounts with that moderation status (default: active)
+        * Set `username` to a string to get only accounts whose username contains this string.
+        * Set `display_name` to a string to get only accounts whose display name contains this string.
+        * Set `email` to an email to get only accounts with that email (this only works on local accounts).
+        * Set `ip` to an ip (as a string, standard v4/v6 notation) to get only accounts whose last active ip is that ip (this only works on local accounts).
+        * Set `staff_only` to True to only get staff accounts (this only works on local accounts).
+        Note that setting the boolean parameters to False does not mean "give me users to which this does not apply" but
+        instead means "I do not care if users have this attribute".
+        Deprecated in Mastodon version 3.5.0.
+        Returns a list of :ref:`admin account dicts <admin account dicts>`.
+        """
+        if max_id is not None:
+            max_id = self.__unpack_id(max_id, dateconv=True)
+        if min_id is not None:
+            min_id = self.__unpack_id(min_id, dateconv=True)
+        if since_id is not None:
+            since_id = self.__unpack_id(since_id, dateconv=True)
+        params = self.__generate_params(locals(), ['remote', 'status', 'staff_only'])
+        if remote:
+            params["remote"] = True
+        mod_statuses = ["active", "pending", "disabled", "silenced", "suspended"]
+        if not status in mod_statuses:
+            raise ValueError("Invalid moderation status requested.")
+        if staff_only:
+            params["staff"] = True
+        for mod_status in mod_statuses:
+            if status == mod_status:
+                params[status] = True
+        if not by_domain is None:
+            by_domain = self.__deprotocolize(by_domain)
+        return self.__api_request('GET', '/api/v1/admin/accounts', params)
+    @api_version("2.9.1", "2.9.1", _DICT_VERSION_ADMIN_ACCOUNT)
+    def admin_account(self, id):
+        """
+        Fetches a single :ref:`admin account dict <admin account dict>` for the user with the given id.
+        Returns that dict.
+        """
+        id = self.__unpack_id(id)
+        return self.__api_request('GET', '/api/v1/admin/accounts/{0}'.format(id))
+    @api_version("2.9.1", "2.9.1", _DICT_VERSION_ADMIN_ACCOUNT)
+    def admin_account_enable(self, id):
+        """
+        Reenables login for a local account for which login has been disabled.
+        Returns the updated :ref:`admin account dict <admin account dict>`.
+        """
+        id = self.__unpack_id(id)
+        return self.__api_request('POST', '/api/v1/admin/accounts/{0}/enable'.format(id))
+    @api_version("2.9.1", "2.9.1", _DICT_VERSION_ADMIN_ACCOUNT)
+    def admin_account_approve(self, id):
+        """
+        Approves a pending account.
+        Returns the updated :ref:`admin account dict <admin account dict>`.
+        """
+        id = self.__unpack_id(id)
+        return self.__api_request('POST', '/api/v1/admin/accounts/{0}/approve'.format(id))
+    @api_version("2.9.1", "2.9.1", _DICT_VERSION_ADMIN_ACCOUNT)
+    def admin_account_reject(self, id):
+        """
+        Rejects and deletes a pending account.
+        Returns the updated :ref:`admin account dict <admin account dict>` for the account that is now gone.
+        """
+        id = self.__unpack_id(id)
+        return self.__api_request('POST', '/api/v1/admin/accounts/{0}/reject'.format(id))
+    @api_version("2.9.1", "2.9.1", _DICT_VERSION_ADMIN_ACCOUNT)
+    def admin_account_unsilence(self, id):
+        """
+        Unsilences an account.
+        Returns the updated :ref:`admin account dict <admin account dict>`.
+        """
+        id = self.__unpack_id(id)
+        return self.__api_request('POST', '/api/v1/admin/accounts/{0}/unsilence'.format(id))
+    @api_version("2.9.1", "2.9.1", _DICT_VERSION_ADMIN_ACCOUNT)
+    def admin_account_unsuspend(self, id):
+        """
+        Unsuspends an account.
+        Returns the updated :ref:`admin account dict <admin account dict>`.
+        """
+        id = self.__unpack_id(id)
+        return self.__api_request('POST', '/api/v1/admin/accounts/{0}/unsuspend'.format(id))
+    @api_version("3.3.0", "3.3.0", _DICT_VERSION_ADMIN_ACCOUNT)
+    def admin_account_delete(self, id):
+        """
+        Delete a local user account.
+        The deleted accounts :ref:`admin account dict <admin account dict>`.
+        """
+        id = self.__unpack_id(id)
+        return self.__api_request('DELETE', '/api/v1/admin/accounts/{0}'.format(id))
+    @api_version("3.3.0", "3.3.0", _DICT_VERSION_ADMIN_ACCOUNT)
+    def admin_account_unsensitive(self, id):
+        """
+        Unmark an account as force-sensitive.
+        Returns the updated :ref:`admin account dict <admin account dict>`.
+        """
+        id = self.__unpack_id(id)
+        return self.__api_request('POST', '/api/v1/admin/accounts/{0}/unsensitive'.format(id))
+    @api_version("2.9.1", "2.9.1", "2.9.1")
+    def admin_account_moderate(self, id, action=None, report_id=None, warning_preset_id=None, text=None, send_email_notification=True):
+        """
+        Perform a moderation action on an account.
+        Valid actions are:
+            * "disable" - for a local user, disable login.
+            * "silence" - hide the users posts from all public timelines.
+            * "suspend" - irreversibly delete all the user's posts, past and future.
+            * "sensitive" - forcce an accounts media visibility to always be sensitive.
+        If no action is specified, the user is only issued a warning.
+        Specify the id of a report as `report_id` to close the report with this moderation action as the resolution.
+        Specify `warning_preset_id` to use a warning preset as the notification text to the user, or `text` to specify text directly.
+        If both are specified, they are concatenated (preset first). Note that there is currently no API to retrieve or create
+        warning presets.
+        Set `send_email_notification` to False to not send the user an email notification informing them of the moderation action.
+        """
+        if action is None:
+            action = "none"
+        if not send_email_notification:
+            send_email_notification = None
+        id = self.__unpack_id(id)
+        if report_id is not None:
+            report_id = self.__unpack_id(report_id)
+        params = self.__generate_params(locals(), ['id', 'action'])
+        params["type"] = action
+        self.__api_request(
+            'POST', '/api/v1/admin/accounts/{0}/action'.format(id), params)
+    @api_version("2.9.1", "2.9.1", _DICT_VERSION_REPORT)
+    def admin_reports(self, resolved=False, account_id=None, target_account_id=None, max_id=None, min_id=None, since_id=None, limit=None):
+        """
+        Fetches the list of reports.
+        Set `resolved` to True to search for resolved reports. `account_id` and `target_account_id`
+        can be used to get reports filed by or about a specific user.
+        Returns a list of :ref:`report dicts <report dicts>`.
+        """
+        if max_id is not None:
+            max_id = self.__unpack_id(max_id, dateconv=True)
+        if min_id is not None:
+            min_id = self.__unpack_id(min_id, dateconv=True)
+        if since_id is not None:
+            since_id = self.__unpack_id(since_id, dateconv=True)
+        if account_id is not None:
+            account_id = self.__unpack_id(account_id)
+        if target_account_id is not None:
+            target_account_id = self.__unpack_id(target_account_id)
+        if not resolved:
+            resolved = None
+        params = self.__generate_params(locals())
+        return self.__api_request('GET', '/api/v1/admin/reports', params)
+    @api_version("2.9.1", "2.9.1", _DICT_VERSION_REPORT)
+    def admin_report(self, id):
+        """
+        Fetches the report with the given id.
+        Returns a :ref:`report dict <report dict>`.
+        """
+        id = self.__unpack_id(id)
+        return self.__api_request('GET', '/api/v1/admin/reports/{0}'.format(id))
+    @api_version("2.9.1", "2.9.1", _DICT_VERSION_REPORT)
+    def admin_report_assign(self, id):
+        """
+        Assigns the given report to the logged-in user.
+        Returns the updated :ref:`report dict <report dict>`.
+        """
+        id = self.__unpack_id(id)
+        return self.__api_request('POST', '/api/v1/admin/reports/{0}/assign_to_self'.format(id))
+    @api_version("2.9.1", "2.9.1", _DICT_VERSION_REPORT)
+    def admin_report_unassign(self, id):
+        """
+        Unassigns the given report from the logged-in user.
+        Returns the updated :ref:`report dict <report dict>`.
+        """
+        id = self.__unpack_id(id)
+        return self.__api_request('POST', '/api/v1/admin/reports/{0}/unassign'.format(id))
+    @api_version("2.9.1", "2.9.1", _DICT_VERSION_REPORT)
+    def admin_report_reopen(self, id):
+        """
+        Reopens a closed report.
+        Returns the updated :ref:`report dict <report dict>`.
+        """
+        id = self.__unpack_id(id)
+        return self.__api_request('POST', '/api/v1/admin/reports/{0}/reopen'.format(id))
+    @api_version("2.9.1", "2.9.1", _DICT_VERSION_REPORT)
+    def admin_report_resolve(self, id):
+        """
+        Marks a report as resolved (without taking any action).
+        Returns the updated :ref:`report dict <report dict>`.
+        """
+        id = self.__unpack_id(id)
+        return self.__api_request('POST', '/api/v1/admin/reports/{0}/resolve'.format(id))
+    @api_version("3.5.0", "3.5.0", _DICT_VERSION_HASHTAG)
+    def admin_trending_tags(self, limit=None):
+        """
+        Admin version of :ref:`trending_tags() <trending_tags()>`. Includes unapproved tags.
+        Returns a list of :ref:`hashtag dicts <hashtag dicts>`, sorted by the instance's trending algorithm,
+        descending.
+        """
+        params = self.__generate_params(locals())
+        return self.__api_request('GET', '/api/v1/admin/trends/tags', params)
+    @api_version("3.5.0", "3.5.0", _DICT_VERSION_STATUS)
+    def admin_trending_statuses(self):
+        """
+        Admin version of :ref:`trending_statuses() <trending_statuses()>`. Includes unapproved tags.
+        Returns a list of :ref:`status dicts <status dicts>`, sorted by the instance's trending algorithm,
+        descending.
+        """
+        params = self.__generate_params(locals())
+        return self.__api_request('GET', '/api/v1/admin/trends/statuses', params)
+    @api_version("3.5.0", "3.5.0", _DICT_VERSION_CARD)
+    def admin_trending_links(self):
+        """
+        Admin version of :ref:`trending_links() <trending_links()>`. Includes unapproved tags.
+        Returns a list of :ref:`card dicts <card dicts>`, sorted by the instance's trending algorithm,
+        descending.
+        """
+        params = self.__generate_params(locals())
+        return self.__api_request('GET', '/api/v1/admin/trends/links', params)
+    @api_version("4.0.0", "4.0.0", _DICT_VERSION_ADMIN_DOMAIN_BLOCK)
+    def admin_domain_blocks(self, id=None, limit:int=None):
+        """
+        Fetches a list of blocked domains. Requires scope `admin:read:domain_blocks`.
+        Provide an `id` to fetch a specific domain block based on its database id.
+        Returns a list of :ref:`admin domain block dicts <admin domain block dicts>`, raises a `MastodonAPIError` if the specified block does not exist.
+        """
+        if id is not None:
+            id = self.__unpack_id(id)
+            return self.__api_request('GET', '/api/v1/admin/domain_blocks/{0}'.format(id))
+        else:
+            params = self.__generate_params(locals(),['limit'])
+            return self.__api_request('GET', '/api/v1/admin/domain_blocks/', params)
+    
+    @api_version("4.0.0", "4.0.0", _DICT_VERSION_ADMIN_DOMAIN_BLOCK)
+    def admin_create_domain_block(self, domain:str, severity:str=None, reject_media:bool=None, reject_reports:bool=None, private_comment:str=None, public_comment:str=None, obfuscate:bool=None):
+        """
+        Perform a moderation action on a domain. Requires scope `admin:write:domain_blocks`.
+        Valid severities are:
+            * "silence" - hide all posts from federated timelines and do not show notifications to local users from the remote instance's users unless they are following the remote user. 
+            * "suspend" - deny interactions with this instance going forward. This action is reversible.
+            * "limit" - generally used with reject_media=true to force reject media from an instance without silencing or suspending..
+        If no action is specified, the domain is only silenced.
+        `domain` is the domain to block. Note that using the top level domain will also imapct all subdomains. ie, example.com will also impact subdomain.example.com.
+        `reject_media` will not download remote media on to your local instance media storage.
+        `reject_reports` ignores all reports from the remote instance.
+        `private_comment` sets a private admin comment for the domain.
+        `public_comment` sets a publicly available comment for this domain, which will be available to local users and may be available to everyone depending on your settings.
+        `obfuscate` censors some part of the domain name. Useful if the domain name contains unwanted words like slurs.
+        Returns the new domain block as an :ref:`admin domain block dict <admin domain block dict>`.
+        """
+        if domain is None:
+            raise AttributeError("Must provide a domain to block a domain")
+        params = self.__generate_params(locals())
+        return self.__api_request('POST', '/api/v1/admin/domain_blocks/', params)
+    @api_version("4.0.0", "4.0.0", _DICT_VERSION_ADMIN_DOMAIN_BLOCK)
+    def admin_update_domain_block(self, id, severity:str=None, reject_media:bool=None, reject_reports:bool=None, private_comment:str=None, public_comment:str=None, obfuscate:bool=None):
+        """
+        Modify existing moderation action on a domain. Requires scope `admin:write:domain_blocks`.
+        Valid severities are:
+            * "silence" - hide all posts from federated timelines and do not show notifications to local users from the remote instance's users unless they are following the remote user. 
+            * "suspend" - deny interactions with this instance going forward. This action is reversible.
+            * "limit" - generally used with reject_media=true to force reject media from an instance without silencing or suspending.
+        If no action is specified, the domain is only silenced.
+        `domain` is the domain to block. Note that using the top level domain will also imapct all subdomains. ie, example.com will also impact subdomain.example.com.
+        `reject_media` will not download remote media on to your local instance media storage.
+        `reject_reports` ignores all reports from the remote instance.
+        `private_comment` sets a private admin comment for the domain.
+        `public_comment` sets a publicly available comment for this domain, which will be available to local users and may be available to everyone depending on your settings.
+        `obfuscate` censors some part of the domain name. Useful if the domain name contains unwanted words like slurs.
+        Returns the modified domain block as an :ref:`admin domain block dict <admin domain block dict>`, raises a `MastodonAPIError` if the specified block does not exist.
+        """
+        if id is None:
+            raise AttributeError("Must provide an id to modify the existing moderation actions on a given domain.")
+        id = self.__unpack_id(id)
+        params = self.__generate_params(locals(), ["id"])
+        return self.__api_request('PUT', '/api/v1/admin/domain_blocks/{0}'.format(id), params)
+    @api_version("4.0.0", "4.0.0", _DICT_VERSION_ADMIN_DOMAIN_BLOCK)
+    def admin_delete_domain_block(self, id=None):
+        """
+        Removes moderation action against a given domain. Requires scope `admin:write:domain_blocks`.
+        Provide an `id` to remove a specific domain block based on its database id.
+        Raises a `MastodonAPIError` if the specified block does not exist.
+        """
+        if id is not None:
+            id = self.__unpack_id(id)
+            self.__api_request('DELETE', '/api/v1/admin/domain_blocks/{0}'.format(id))
+        else:
+            raise AttributeError("You must provide an id of an existing domain block to remove it.")
+    @api_version("3.5.0", "3.5.0", _DICT_VERSION_ADMIN_MEASURE)
+    def admin_measures(self, start_at, end_at, active_users=False, new_users=False, interactions=False, opened_reports = False, resolved_reports=False,
+                        tag_accounts=None, tag_uses=None, tag_servers=None, instance_accounts=None, instance_media_attachments=None, instance_reports=None,
+                        instance_statuses=None, instance_follows=None, instance_followers=None):
+        """
+        Retrieves numerical instance information for the time period (at day granularity) between `start_at` and `end_at`.
+            * `active_users`: Pass true to retrieve the number of active users on your instance within the time period
+            * `new_users`: Pass true to retrieve the number of users who joined your instance within the time period
+            * `interactions`: Pass true to retrieve the number of interactions (favourites, boosts, replies) on local statuses within the time period
+            * `opened_reports`: Pass true to retrieve the number of reports filed within the time period
+            * `resolved_reports` = Pass true to retrieve the number of reports resolved within the time period
+            * `tag_accounts`: Pass a tag ID to get the number of accounts which used that tag in at least one status within the time period
+            * `tag_uses`: Pass a tag ID to get the number of statuses which used that tag within the time period
+            * `tag_servers`: Pass a tag ID to to get the number of remote origin servers for statuses which used that tag within the time period
+            * `instance_accounts`: Pass a domain to get the number of accounts originating from that remote domain within the time period
+            * `instance_media_attachments`: Pass a domain to get the amount of space used by media attachments from that remote domain within the time period
+            * `instance_reports`: Pass a domain to get the number of reports filed against accounts from that remote domain within the time period
+            * `instance_statuses`: Pass a domain to get the number of statuses originating from that remote domain within the time period
+            * `instance_follows`: Pass a domain to get the number of accounts from a remote domain followed by that local user within the time period
+            * `instance_followers`: Pass a domain to get the number of local accounts followed by accounts from that remote domain within the time period
+        This API call is relatively expensive - watch your servers load if you want to get a lot of statistical data. Especially the instance_statuses stats
+        might take a long time to compute and, in fact, time out.
+        There is currently no way to get tag IDs implemented in Mastodon.py, because the Mastodon public API does not implement one. This will be fixed in a future
+        release.
+        Returns a list of :ref:`admin measure dicts <admin measure dicts>`.
+        """
+        params_init = locals()
+        keys = []
+        for key in ["active_users", "new_users", "interactions", "opened_reports", "resolved_reports"]:
+            if params_init[key] == True:
+                keys.append(key)
+        
+        params = {}
+        for key in ["tag_accounts", "tag_uses", "tag_servers"]:
+            if params_init[key] is not None:
+                keys.append(key)
+                params[key] = {"id": self.__unpack_id(params_init[key])}
+        for key in ["instance_accounts", "instance_media_attachments", "instance_reports", "instance_statuses", "instance_follows", "instance_followers"]:
+            if params_init[key] is not None:
+                keys.append(key)
+                params[key] = {"domain": Mastodon.__deprotocolize(params_init[key]).split("/")[0]}
+        if len(keys) == 0:
+            raise MastodonIllegalArgumentError("Must request at least one metric.")
+        params["keys"] = keys
+        params["start_at"] = self.__consistent_isoformat_utc(start_at)
+        params["end_at"] = self.__consistent_isoformat_utc(end_at)
+        
+        return self.__api_request('POST', '/api/v1/admin/measures', params, use_json=True)
+    @api_version("3.5.0", "3.5.0", _DICT_VERSION_ADMIN_DIMENSION)
+    def admin_dimensions(self, start_at, end_at, limit=None, languages=False, sources=False, servers=False, space_usage=False, software_versions=False,
+                            tag_servers=None, tag_languages=None, instance_accounts=None, instance_languages=None):
+        """
+        Retrieves primarily categorical instance information for the time period (at day granularity) between `start_at` and `end_at`.
+            * `languages`: Pass true to get the most-used languages on this server
+            * `sources`: Pass true to get the most-used client apps on this server
+            * `servers`: Pass true to get the remote servers with the most statuses
+            * `space_usage`: Pass true to get the how much space is used by different components your software stack
+            * `software_versions`: Pass true to get the version numbers for your software stack
+            * `tag_servers`: Pass a tag ID to get the most-common servers for statuses including a trending tag
+            * `tag_languages`: Pass a tag ID to get the most-used languages for statuses including a trending tag
+            * `instance_accounts`: Pass a domain to get the most-followed accounts from a remote server
+            * `instance_languages`: Pass a domain to get the most-used languages from a remote server
+        Pass `limit` to set how many results you want on queries where that makes sense.
+        This API call is relatively expensive - watch your servers load if you want to get a lot of statistical data.
+        There is currently no way to get tag IDs implemented in Mastodon.py, because the Mastodon public API does not implement one. This will be fixed in a future
+        release.
+        Returns a list of :ref:`admin dimension dicts <admin dimension dicts>`.
+        """
+        params_init = locals()
+        keys = []
+        for key in ["languages", "sources", "servers", "space_usage", "software_versions"]:
+            if params_init[key] == True:
+                keys.append(key)
+        
+        params = {}
+        for key in ["tag_servers", "tag_languages"]:
+            if params_init[key] is not None:
+                keys.append(key)
+                params[key] = {"id": self.__unpack_id(params_init[key])}
+        for key in ["instance_accounts", "instance_languages"]:
+            if params_init[key] is not None:
+                keys.append(key)
+                params[key] = {"domain": Mastodon.__deprotocolize(params_init[key]).split("/")[0]}
+        if len(keys) == 0:
+            raise MastodonIllegalArgumentError("Must request at least one dimension.")
+        params["keys"] = keys
+        if limit is not None:
+            params["limit"] = limit
+        params["start_at"] = self.__consistent_isoformat_utc(start_at)
+        params["end_at"] = self.__consistent_isoformat_utc(end_at)
+        
+        return self.__api_request('POST', '/api/v1/admin/dimensions', params, use_json=True)
+    @api_version("3.5.0", "3.5.0", _DICT_VERSION_ADMIN_RETENTION)
+    def admin_retention(self, start_at, end_at, frequency="day"):
+        """
+        Gets user retention statistics (at `frequency` - "day" or "month" - granularity) between `start_at` and `end_at`.
+        Returns a list of :ref:`admin retention dicts <admin retention dicts>`
+        """
+        if not frequency in ["day", "month"]:
+            raise MastodonIllegalArgumentError("Frequency must be day or month")
+        params = {
+            "start_at": self.__consistent_isoformat_utc(start_at),
+            "end_at": self.__consistent_isoformat_utc(end_at),
+            "frequency": frequency
+        }
+        return self.__api_request('POST', '/api/v1/admin/retention', params)
+\ No newline at end of file
diff --git a/mastodon/authentication.py b/mastodon/authentication.py
index b7f15c9..d4cb283 100644
--- a/mastodon/authentication.py
+++ b/mastodon/authentication.py
@@ -1,3 +1,5 @@
+# authentication.py - app and user creation, login, oauth, getting app info, and the constructor
 import requests
 from requests.models import urlencode
 import datetime
@@ -5,9 +7,11 @@ import os
 import time
 import collections
-from .error import MastodonIllegalArgumentError, MastodonNetworkError, MastodonVersionError, MastodonAPIError
+from .errors import MastodonIllegalArgumentError, MastodonNetworkError, MastodonVersionError, MastodonAPIError
+from .versions import _DICT_VERSION_APPLICATION
 from .defaults import _DEFAULT_SCOPES, _SCOPE_SETS, _DEFAULT_TIMEOUT
-from .utility import parse_version_string
+from .utility import parse_version_string, api_version
 from .internals import Mastodon as Internals
 class Mastodon(Internals):
@@ -367,4 +371,16 @@ class Mastodon(Internals):
        # We are now logged out, clear token and logged in id
        self.access_token = None
-        self.__logged_in_id = None
-\ No newline at end of file
+        self.__logged_in_id = None
+    ###
+    # Reading data: Apps
+    ###
+    @api_version("2.0.0", "2.7.2", _DICT_VERSION_APPLICATION)
+    def app_verify_credentials(self):
+        """
+        Fetch information about the current application.
+        Returns an :ref:`application dict <application dict>`.
+        """
+        return self.__api_request('GET', '/api/v1/apps/verify_credentials')
diff --git a/mastodon/conversations.py b/mastodon/conversations.py
new file mode 100644
index 0000000..ba3ee61
--- /dev/null
+++ b/mastodon/conversations.py
@@ -0,0 +1,43 @@
+# conversations.py - conversation endpoints
+from .versions import _DICT_VERSION_CONVERSATION
+from .utility import api_version
+from .internals import Mastodon as Internals
+class Mastodon(Internals):    
+    ###
+    # Reading data: Conversations
+    ###
+    @api_version("2.6.0", "2.6.0", _DICT_VERSION_CONVERSATION)
+    def conversations(self, max_id=None, min_id=None, since_id=None, limit=None):
+        """
+        Fetches a user's conversations.
+        Returns a list of :ref:`conversation dicts <conversation dicts>`.
+        """
+        if max_id is not None:
+            max_id = self.__unpack_id(max_id, dateconv=True)
+        if min_id is not None:
+            min_id = self.__unpack_id(min_id, dateconv=True)
+        if since_id is not None:
+            since_id = self.__unpack_id(since_id, dateconv=True)
+        params = self.__generate_params(locals())
+        return self.__api_request('GET', "/api/v1/conversations/", params)
+    ###
+    # Writing data: Conversations
+    ###
+    @api_version("2.6.0", "2.6.0", _DICT_VERSION_CONVERSATION)
+    def conversations_read(self, id):
+        """
+        Marks a single conversation as read.
+        Returns the updated :ref:`conversation dict <conversation dict>`.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/conversations/{0}/read'.format(str(id))
+        return self.__api_request('POST', url)
diff --git a/mastodon/endorsements.py b/mastodon/endorsements.py
new file mode 100644
index 0000000..b6c27a0
--- /dev/null
+++ b/mastodon/endorsements.py
@@ -0,0 +1,19 @@
+# notifications.py - endorsement endpoints
+from .versions import _DICT_VERSION_ACCOUNT
+from .utility import api_version
+from .internals import Mastodon as Internals
+class Mastodon(Internals):    
+    ###
+    # Reading data: Endorsements
+    ###
+    @api_version("2.5.0", "2.5.0", _DICT_VERSION_ACCOUNT)
+    def endorsements(self):
+        """
+        Fetch list of users endorsed by the logged-in user.
+        Returns a list of :ref:`account dicts <account dicts>`.
+        """
+        return self.__api_request('GET', '/api/v1/endorsements')
diff --git a/mastodon/error.py b/mastodon/errors.py
index 85cc313..85cc313 100644
--- a/mastodon/error.py
+++ b/mastodon/errors.py
diff --git a/mastodon/favourites.py b/mastodon/favourites.py
new file mode 100644
index 0000000..9d86424
--- /dev/null
+++ b/mastodon/favourites.py
@@ -0,0 +1,52 @@
+# favourites.py - favourites and also bookmarks
+from .versions import _DICT_VERSION_STATUS
+from .utility import api_version
+from .internals import Mastodon as Internals
+class Mastodon(Internals):
+    ###
+    # Reading data: Favourites
+    ###
+    @api_version("1.0.0", "2.6.0", _DICT_VERSION_STATUS)
+    def favourites(self, max_id=None, min_id=None, since_id=None, limit=None):
+        """
+        Fetch the logged-in user's favourited statuses.
+        Returns a list of :ref:`status dicts <status dicts>`.
+        """
+        if max_id is not None:
+            max_id = self.__unpack_id(max_id, dateconv=True)
+        if min_id is not None:
+            min_id = self.__unpack_id(min_id, dateconv=True)
+        if since_id is not None:
+            since_id = self.__unpack_id(since_id, dateconv=True)
+        params = self.__generate_params(locals())
+        return self.__api_request('GET', '/api/v1/favourites', params)
+    ###
+    # Reading data: Bookmarks
+    ###
+    @api_version("3.1.0", "3.1.0", _DICT_VERSION_STATUS)
+    def bookmarks(self, max_id=None, min_id=None, since_id=None, limit=None):
+        """
+        Get a list of statuses bookmarked by the logged-in user.
+        Returns a list of :ref:`status dicts <status dicts>`.
+        """
+        if max_id is not None:
+            max_id = self.__unpack_id(max_id, dateconv=True)
+        if min_id is not None:
+            min_id = self.__unpack_id(min_id, dateconv=True)
+        if since_id is not None:
+            since_id = self.__unpack_id(since_id, dateconv=True)
+        params = self.__generate_params(locals())
+        return self.__api_request('GET', '/api/v1/bookmarks', params)
+        
+\ No newline at end of file
diff --git a/mastodon/filters.py b/mastodon/filters.py
new file mode 100644
index 0000000..5f373d4
--- /dev/null
+++ b/mastodon/filters.py
@@ -0,0 +1,119 @@
+# filters.py - Filter-related endpoints
+import re
+from .versions import _DICT_VERSION_FILTER
+from .errors import MastodonIllegalArgumentError
+from .utility import api_version
+from .internals import Mastodon as Internals
+class Mastodon(Internals):
+    ###
+    # Reading data: Keyword filters
+    ###
+    @api_version("2.4.3", "2.4.3", _DICT_VERSION_FILTER)
+    def filters(self):
+        """
+        Fetch all of the logged-in user's filters.
+        Returns a list of :ref:`filter dicts <filter dicts>`. Not paginated.
+        """
+        return self.__api_request('GET', '/api/v1/filters')
+    @api_version("2.4.3", "2.4.3", _DICT_VERSION_FILTER)
+    def filter(self, id):
+        """
+        Fetches information about the filter with the specified `id`.
+        Returns a :ref:`filter dict <filter dict>`.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/filters/{0}'.format(str(id))
+        return self.__api_request('GET', url)
+    @api_version("2.4.3", "2.4.3", _DICT_VERSION_FILTER)
+    def filters_apply(self, objects, filters, context):
+        """
+        Helper function: Applies a list of filters to a list of either statuses
+        or notifications and returns only those matched by none. This function will
+        apply all filters that match the context provided in `context`, i.e.
+        if you want to apply only notification-relevant filters, specify
+        'notifications'. Valid contexts are 'home', 'notifications', 'public' and 'thread'.
+        """
+        # Build filter regex
+        filter_strings = []
+        for keyword_filter in filters:
+            if not context in keyword_filter["context"]:
+                continue
+            filter_string = re.escape(keyword_filter["phrase"])
+            if keyword_filter["whole_word"]:
+                filter_string = "\\b" + filter_string + "\\b"
+            filter_strings.append(filter_string)
+        filter_re = re.compile("|".join(filter_strings), flags=re.IGNORECASE)
+        # Apply
+        filter_results = []
+        for filter_object in objects:
+            filter_status = filter_object
+            if "status" in filter_object:
+                filter_status = filter_object["status"]
+            filter_text = filter_status["content"]
+            filter_text = re.sub(r"<.*?>", " ", filter_text)
+            filter_text = re.sub(r"\s+", " ", filter_text).strip()
+            if not filter_re.search(filter_text):
+                filter_results.append(filter_object)
+        return filter_results
+    ###
+    # Writing data: Keyword filters
+    ###
+    @api_version("2.4.3", "2.4.3", _DICT_VERSION_FILTER)
+    def filter_create(self, phrase, context, irreversible=False, whole_word=True, expires_in=None):
+        """
+        Creates a new keyword filter. `phrase` is the phrase that should be
+        filtered out, `context` specifies from where to filter the keywords.
+        Valid contexts are 'home', 'notifications', 'public' and 'thread'.
+        Set `irreversible` to True if you want the filter to just delete statuses
+        server side. This works only for the 'home' and 'notifications' contexts.
+        Set `whole_word` to False if you want to allow filter matches to
+        start or end within a word, not only at word boundaries.
+        Set `expires_in` to specify for how many seconds the filter should be
+        kept around.
+        Returns the :ref:`filter dict <filter dict>` of the newly created filter.
+        """
+        params = self.__generate_params(locals())
+        for context_val in context:
+            if not context_val in ['home', 'notifications', 'public', 'thread']:
+                raise MastodonIllegalArgumentError('Invalid filter context.')
+        return self.__api_request('POST', '/api/v1/filters', params)
+    @api_version("2.4.3", "2.4.3", _DICT_VERSION_FILTER)
+    def filter_update(self, id, phrase=None, context=None, irreversible=None, whole_word=None, expires_in=None):
+        """
+        Updates the filter with the given `id`. Parameters are the same
+        as in `filter_create()`.
+        Returns the :ref:`filter dict <filter dict>` of the updated filter.
+        """
+        id = self.__unpack_id(id)
+        params = self.__generate_params(locals(), ['id'])
+        url = '/api/v1/filters/{0}'.format(str(id))
+        return self.__api_request('PUT', url, params)
+    @api_version("2.4.3", "2.4.3", "2.4.3")
+    def filter_delete(self, id):
+        """
+        Deletes the filter with the given `id`.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/filters/{0}'.format(str(id))
+        self.__api_request('DELETE', url)        
+\ No newline at end of file
diff --git a/mastodon/hashtags.py b/mastodon/hashtags.py
new file mode 100644
index 0000000..89e8cac
--- /dev/null
+++ b/mastodon/hashtags.py
@@ -0,0 +1,52 @@
+# hashtags.py - hashtag and featured-hashtag endpoints
+from .versions import _DICT_VERSION_FEATURED_TAG, _DICT_VERSION_HASHTAG
+from .utility import api_version
+from .internals import Mastodon as Internals
+class Mastodon(Internals):
+    ###
+    # Reading data: Featured hashtags
+    ###
+    @api_version("3.0.0", "3.0.0", _DICT_VERSION_FEATURED_TAG)
+    def featured_tags(self):
+        """
+        Return the hashtags the logged-in user has set to be featured on
+        their profile as a list of :ref:`featured tag dicts <featured tag dicts>`.
+        Returns a list of :ref:`featured tag dicts <featured tag dicts>`.
+        """
+        return self.__api_request('GET', '/api/v1/featured_tags')
+    @api_version("3.0.0", "3.0.0", _DICT_VERSION_HASHTAG)
+    def featured_tag_suggestions(self):
+        """
+        Returns the logged-in user's 10 most commonly-used hashtags.
+        Returns a list of :ref:`hashtag dicts <hashtag dicts>`.
+        """
+        return self.__api_request('GET', '/api/v1/featured_tags/suggestions')
+    ###
+    # Writing data: Featured hashtags
+    ###
+    @api_version("3.0.0", "3.0.0", _DICT_VERSION_FEATURED_TAG)
+    def featured_tag_create(self, name):
+        """
+        Creates a new featured hashtag displayed on the logged-in user's profile.
+        Returns a :ref:`featured tag dict <featured tag dict>` with the newly featured tag.
+        """
+        params = self.__generate_params(locals())
+        return self.__api_request('POST', '/api/v1/featured_tags', params)
+    @api_version("3.0.0", "3.0.0", _DICT_VERSION_FEATURED_TAG)
+    def featured_tag_delete(self, id):
+        """
+        Deletes one of the logged-in user's featured hashtags.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/featured_tags/{0}'.format(str(id))
+        self.__api_request('DELETE', url)
+                
+\ No newline at end of file
diff --git a/mastodon/instance.py b/mastodon/instance.py
index 88445d1..dfbbefb 100644
--- a/mastodon/instance.py
+++ b/mastodon/instance.py
@@ -1,5 +1,7 @@
-from .versions import _DICT_VERSION_INSTANCE, _DICT_VERSION_ACTIVITY
+# instance.py - instance-level endpoints, directory, emoji, announcements
-from .error import MastodonIllegalArgumentError, MastodonNotFoundError
+from .versions import _DICT_VERSION_INSTANCE, _DICT_VERSION_ACTIVITY, _DICT_VERSION_ACCOUNT, _DICT_VERSION_EMOJI, _DICT_VERSION_ANNOUNCEMENT
+from .errors import MastodonIllegalArgumentError, MastodonNotFoundError
 from .utility import api_version
 from .compat import urlparse
@@ -94,3 +96,94 @@ class Mastodon(Internals):
        Returns a list of `id` + `text` dicts, same as the `rules` field in the :ref:`instance dicts <instance dicts>`.
        """
        return self.__api_request('GET', '/api/v1/instance/rules')
+    ###
+    # Reading data: Directory
+    ###
+    @api_version("3.0.0", "3.0.0", _DICT_VERSION_ACCOUNT)
+    def directory(self, offset=None, limit=None, order=None, local=None):
+        """
+        Fetch the contents of the profile directory, if enabled on the server.
+        `offset` how many accounts to skip before returning results. Default 0.
+        `limit` how many accounts to load. Default 40.
+        `order` "active" to sort by most recently posted statuses (default) or
+                "new" to sort by most recently created profiles.
+        `local` True to return only local accounts.
+        Returns a list of :ref:`account dicts <account dicts>`.
+        """
+        params = self.__generate_params(locals())
+        return self.__api_request('GET', '/api/v1/directory', params)
+    ###
+    # Reading data: Emoji
+    ###
+    @api_version("2.1.0", "2.1.0", _DICT_VERSION_EMOJI)
+    def custom_emojis(self):
+        """
+        Fetch the list of custom emoji the instance has installed.
+        Does not require authentication unless locked down by the administrator.
+        Returns a list of :ref:`emoji dicts <emoji dicts>`.
+        """
+        return self.__api_request('GET', '/api/v1/custom_emojis')
+    ##
+    # Reading data: Announcements
+    ##
+    @api_version("3.1.0", "3.1.0", _DICT_VERSION_ANNOUNCEMENT)
+    def announcements(self):
+        """
+        Fetch currently active announcements.
+        Returns a list of :ref:`announcement dicts <announcement dicts>`.
+        """
+        return self.__api_request('GET', '/api/v1/announcements')
+    ###
+    # Writing data: Annoucements
+    ###
+    @api_version("3.1.0", "3.1.0", "3.1.0")
+    def announcement_dismiss(self, id):
+        """
+        Set the given annoucement to read.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/announcements/{0}/dismiss'.format(str(id))
+        self.__api_request('POST', url)
+    @api_version("3.1.0", "3.1.0", "3.1.0")
+    def announcement_reaction_create(self, id, reaction):
+        """
+        Add a reaction to an announcement. `reaction` can either be a unicode emoji
+        or the name of one of the instances custom emoji.
+        Will throw an API error if the reaction name is not one of the allowed things
+        or when trying to add a reaction that the user has already added (adding a
+        reaction that a different user added is legal and increments the count).
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/announcements/{0}/reactions/{1}'.format(
+            str(id), reaction)
+        self.__api_request('PUT', url)
+    @api_version("3.1.0", "3.1.0", "3.1.0")
+    def announcement_reaction_delete(self, id, reaction):
+        """
+        Remove a reaction to an announcement.
+        Will throw an API error if the reaction does not exist.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/announcements/{0}/reactions/{1}'.format(
+            str(id), reaction)
+        self.__api_request('DELETE', url)
diff --git a/mastodon/internals.py b/mastodon/internals.py
index 0e77421..aa82553 100644
--- a/mastodon/internals.py
+++ b/mastodon/internals.py
@@ -1,3 +1,5 @@
+# internals.py - many internal helpers
 import datetime
 from contextlib import closing
 import mimetypes
@@ -14,7 +16,7 @@ import base64
 import os
 from .utility import AttribAccessDict, AttribAccessList, parse_version_string
-from .error import MastodonNetworkError, MastodonIllegalArgumentError, MastodonRatelimitError, MastodonNotFoundError, \
+from .errors import MastodonNetworkError, MastodonIllegalArgumentError, MastodonRatelimitError, MastodonNotFoundError, \
                    MastodonUnauthorizedError, MastodonInternalServerError, MastodonBadGatewayError, MastodonServiceUnavailableError, \
                    MastodonGatewayTimeoutError, MastodonServerError, MastodonAPIError, MastodonMalformedEventError
 from .compat import urlparse, magic, PurePath
diff --git a/mastodon/lists.py b/mastodon/lists.py
new file mode 100644
index 0000000..0882133
--- /dev/null
+++ b/mastodon/lists.py
@@ -0,0 +1,112 @@
+# list.py - list endpoints
+from .versions import _DICT_VERSION_LIST, _DICT_VERSION_ACCOUNT
+from .utility import api_version
+from .internals import Mastodon as Internals
+class Mastodon(Internals):
+    ###
+    # Reading data: Lists
+    ###
+    @api_version("2.1.0", "2.1.0", _DICT_VERSION_LIST)
+    def lists(self):
+        """
+        Fetch a list of all the Lists by the logged-in user.
+        Returns a list of :ref:`list dicts <list dicts>`.
+        """
+        return self.__api_request('GET', '/api/v1/lists')
+    @api_version("2.1.0", "2.1.0", _DICT_VERSION_LIST)
+    def list(self, id):
+        """
+        Fetch info about a specific list.
+        Returns a :ref:`list dict <list dict>`.
+        """
+        id = self.__unpack_id(id)
+        return self.__api_request('GET', '/api/v1/lists/{0}'.format(id))
+    @api_version("2.1.0", "2.6.0", _DICT_VERSION_ACCOUNT)
+    def list_accounts(self, id, max_id=None, min_id=None, since_id=None, limit=None):
+        """
+        Get the accounts that are on the given list.
+        Returns a list of :ref:`account dicts <account dicts>`.
+        """
+        id = self.__unpack_id(id)
+        if max_id is not None:
+            max_id = self.__unpack_id(max_id, dateconv=True)
+        if min_id is not None:
+            min_id = self.__unpack_id(min_id, dateconv=True)
+        if since_id is not None:
+            since_id = self.__unpack_id(since_id, dateconv=True)
+        params = self.__generate_params(locals(), ['id'])
+        return self.__api_request('GET', '/api/v1/lists/{0}/accounts'.format(id))
+    ###
+    # Writing data: Lists
+    ###
+    @api_version("2.1.0", "2.1.0", _DICT_VERSION_LIST)
+    def list_create(self, title):
+        """
+        Create a new list with the given `title`.
+        Returns the :ref:`list dict <list dict>` of the created list.
+        """
+        params = self.__generate_params(locals())
+        return self.__api_request('POST', '/api/v1/lists', params)
+    @api_version("2.1.0", "2.1.0", _DICT_VERSION_LIST)
+    def list_update(self, id, title):
+        """
+        Update info about a list, where "info" is really the lists `title`.
+        Returns the :ref:`list dict <list dict>` of the modified list.
+        """
+        id = self.__unpack_id(id)
+        params = self.__generate_params(locals(), ['id'])
+        return self.__api_request('PUT', '/api/v1/lists/{0}'.format(id), params)
+    @api_version("2.1.0", "2.1.0", "2.1.0")
+    def list_delete(self, id):
+        """
+        Delete a list.
+        """
+        id = self.__unpack_id(id)
+        self.__api_request('DELETE', '/api/v1/lists/{0}'.format(id))
+    @api_version("2.1.0", "2.1.0", "2.1.0")
+    def list_accounts_add(self, id, account_ids):
+        """
+        Add the account(s) given in `account_ids` to the list.
+        """
+        id = self.__unpack_id(id)
+        if not isinstance(account_ids, list):
+            account_ids = [account_ids]
+        account_ids = list(map(lambda x: self.__unpack_id(x), account_ids))
+        params = self.__generate_params(locals(), ['id'])
+        self.__api_request(
+            'POST', '/api/v1/lists/{0}/accounts'.format(id), params)
+    @api_version("2.1.0", "2.1.0", "2.1.0")
+    def list_accounts_delete(self, id, account_ids):
+        """
+        Remove the account(s) given in `account_ids` from the list.
+        """
+        id = self.__unpack_id(id)
+        if not isinstance(account_ids, list):
+            account_ids = [account_ids]
+        account_ids = list(map(lambda x: self.__unpack_id(x), account_ids))
+        params = self.__generate_params(locals(), ['id'])
+        self.__api_request(
+            'DELETE', '/api/v1/lists/{0}/accounts'.format(id), params)
+\ No newline at end of file
diff --git a/mastodon/media.py b/mastodon/media.py
new file mode 100644
index 0000000..3c815fb
--- /dev/null
+++ b/mastodon/media.py
@@ -0,0 +1,114 @@
+# admin.py - admin / moderation endpoints
+import time
+from .versions import _DICT_VERSION_MEDIA
+from .errors import MastodonVersionError, MastodonAPIError
+from .utility import api_version
+from .internals import Mastodon as Internals
+class Mastodon(Internals):
+    ###
+    # Reading data: Media
+    ###
+    @api_version("3.1.4", "3.1.4", _DICT_VERSION_MEDIA)
+    def media(self, id):
+        """
+        Get the updated JSON for one non-attached / in progress media upload belonging
+        to the logged-in user.
+        """
+        id = self.__unpack_id(id)
+        return self.__api_request('GET', '/api/v1/media/{0}'.format(str(id)))
+    ###
+    # Writing data: Media
+    ###
+    @api_version("1.0.0", "3.2.0", _DICT_VERSION_MEDIA)
+    def media_post(self, media_file, mime_type=None, description=None, focus=None, file_name=None, thumbnail=None, thumbnail_mime_type=None, synchronous=False):
+        """
+        Post an image, video or audio file. `media_file` can either be data or
+        a file name. If data is passed directly, the mime type has to be specified
+        manually, otherwise, it is determined from the file name. `focus` should be a tuple
+        of floats between -1 and 1, giving the x and y coordinates of the images
+        focus point for cropping (with the origin being the images center).
+        Throws a `MastodonIllegalArgumentError` if the mime type of the
+        passed data or file can not be determined properly.
+        `file_name` can be specified to upload a file with the given name,
+        which is ignored by Mastodon, but some other Fediverse server software
+        will display it. If no name is specified, a random name will be generated.
+        The filename of a file specified in media_file will be ignored.
+        Starting with Mastodon 3.2.0, `thumbnail` can be specified in the same way as `media_file`
+        to upload a custom thumbnail image for audio and video files.
+        Returns a :ref:`media dict <media dict>`. This contains the id that can be used in
+        status_post to attach the media file to a toot.
+        When using the v2 API (post Mastodon version 3.1.4), the `url` in the
+        returned dict will be `null`, since attachments are processed
+        asynchronously. You can fetch an updated dict using `media`. Pass
+        "synchronous" to emulate the old behaviour. Not recommended, inefficient
+        and deprecated, will eat your API quota, you know the deal.
+        """
+        files = {'file': self.__load_media_file(
+            media_file, mime_type, file_name)}
+        if focus is not None:
+            focus = str(focus[0]) + "," + str(focus[1])
+        if thumbnail is not None:
+            if not self.verify_minimum_version("3.2.0", cached=True):
+                raise MastodonVersionError('Thumbnail requires version > 3.2.0')
+            files["thumbnail"] = self.__load_media_file(
+                thumbnail, thumbnail_mime_type)
+        # Disambiguate URL by version
+        if self.verify_minimum_version("3.1.4", cached=True):
+            ret_dict = self.__api_request(
+                'POST', '/api/v2/media', files=files, params={'description': description, 'focus': focus})
+        else:
+            ret_dict = self.__api_request(
+                'POST', '/api/v1/media', files=files, params={'description': description, 'focus': focus})
+        # Wait for processing?
+        if synchronous:
+            if self.verify_minimum_version("3.1.4"):
+                while not "url" in ret_dict or ret_dict.url is None:
+                    try:
+                        ret_dict = self.media(ret_dict)
+                        time.sleep(5.0)
+                    except:
+                        raise MastodonAPIError("Attachment could not be processed")
+            else:
+                # Old version always waits
+                return ret_dict
+        return ret_dict
+    @api_version("2.3.0", "3.2.0", _DICT_VERSION_MEDIA)
+    def media_update(self, id, description=None, focus=None, thumbnail=None, thumbnail_mime_type=None):
+        """
+        Update the metadata of the media file with the given `id`. `description` and
+        `focus` and `thumbnail` are as in :ref:`media_post() <media_post()>` .
+        Returns the updated :ref:`media dict <media dict>`.
+        """
+        id = self.__unpack_id(id)
+        if focus is not None:
+            focus = str(focus[0]) + "," + str(focus[1])
+        params = self.__generate_params(
+            locals(), ['id', 'thumbnail', 'thumbnail_mime_type'])
+        if thumbnail is not None:
+            if not self.verify_minimum_version("3.2.0", cached=True):
+                raise MastodonVersionError('Thumbnail requires version > 3.2.0')
+            files = {"thumbnail": self.__load_media_file(
+                thumbnail, thumbnail_mime_type)}
+            return self.__api_request('PUT', '/api/v1/media/{0}'.format(str(id)), params, files=files)
+        else:
+            return self.__api_request('PUT', '/api/v1/media/{0}'.format(str(id)), params)
diff --git a/mastodon/notifications.py b/mastodon/notifications.py
new file mode 100644
index 0000000..f65b3fb
--- /dev/null
+++ b/mastodon/notifications.py
@@ -0,0 +1,92 @@
+# notifications.py - notification endpoints
+from .versions import _DICT_VERSION_NOTIFICATION
+from .errors import MastodonIllegalArgumentError
+from .utility import api_version
+from .internals import Mastodon as Internals
+class Mastodon(Internals):
+    ###
+    # Reading data: Notifications
+    ###
+    @api_version("1.0.0", "3.5.0", _DICT_VERSION_NOTIFICATION)
+    def notifications(self, id=None, account_id=None, max_id=None, min_id=None, since_id=None, limit=None, exclude_types=None, types=None, mentions_only=None):
+        """
+        Fetch notifications (mentions, favourites, reblogs, follows) for the logged-in
+        user. Pass `account_id` to get only notifications originating from the given account.
+        There are different types of notifications: 
+            * `follow` - A user followed the logged in user
+            * `follow_request` - A user has requested to follow the logged in user (for locked accounts)
+            * `favourite` - A user favourited a post by the logged in user
+            * `reblog` - A user reblogged a post by the logged in user
+            * `mention` - A user mentioned the logged in user
+            * `poll` - A poll the logged in user created or voted in has ended
+            * `update` - A status the logged in user has reblogged (and only those, as of 4.0.0) has been edited
+            * `status` - A user that the logged in user has enabned notifications for has enabled `notify` (see :ref:`account_follow() <account_follow()>`)
+            * `admin.sign_up` - For accounts with appropriate permissions (TODO: document which those are when adding the permission API): A new user has signed up
+            * `admin.report` - For accounts with appropriate permissions (TODO: document which those are when adding the permission API): A new report has been received
+        Parameters `exclude_types` and `types` are array of these types, specifying them will in- or exclude the
+        types of notifications given. It is legal to give both parameters at the same tine, the result will then
+        be the intersection of the results of both filters. Specifying `mentions_only` is a deprecated way to set 
+        `exclude_types` to all but mentions.
+        Can be passed an `id` to fetch a single notification.
+        Returns a list of :ref:`notification dicts <notification dicts>`.
+        """
+        if mentions_only is not None:
+            if exclude_types is None and types is None:
+                if mentions_only:
+                    if self.verify_minimum_version("3.5.0", cached=True):
+                        types = ["mention"]
+                    else:
+                        exclude_types = ["follow", "favourite", "reblog", "poll", "follow_request"]
+            else:
+                raise MastodonIllegalArgumentError('Cannot specify exclude_types/types when mentions_only is present')
+            del mentions_only
+        if max_id is not None:
+            max_id = self.__unpack_id(max_id, dateconv=True)
+        if min_id is not None:
+            min_id = self.__unpack_id(min_id, dateconv=True)
+        if since_id is not None:
+            since_id = self.__unpack_id(since_id, dateconv=True)
+        if account_id is not None:
+            account_id = self.__unpack_id(account_id)
+        if id is None:
+            params = self.__generate_params(locals(), ['id'])
+            return self.__api_request('GET', '/api/v1/notifications', params)
+        else:
+            id = self.__unpack_id(id)
+            url = '/api/v1/notifications/{0}'.format(str(id))
+            return self.__api_request('GET', url)
+    ###
+    # Writing data: Notifications
+    ###
+    @api_version("1.0.0", "1.0.0", "1.0.0")
+    def notifications_clear(self):
+        """
+        Clear out a user's notifications
+        """
+        self.__api_request('POST', '/api/v1/notifications/clear')
+    @api_version("1.3.0", "2.9.2", "2.9.2")
+    def notifications_dismiss(self, id):
+        """
+        Deletes a single notification
+        """
+        id = self.__unpack_id(id)
+        if self.verify_minimum_version("2.9.2", cached=True):
+            url = '/api/v1/notifications/{0}/dismiss'.format(str(id))
+            self.__api_request('POST', url)
+        else:
+            params = self.__generate_params(locals())
+            self.__api_request('POST', '/api/v1/notifications/dismiss', params)
diff --git a/mastodon/polls.py b/mastodon/polls.py
new file mode 100644
index 0000000..d974531
--- /dev/null
+++ b/mastodon/polls.py
@@ -0,0 +1,61 @@
+# polls.py - poll related endpoints and tooling
+from .versions import _DICT_VERSION_POLL
+from .utility import api_version
+from .internals import Mastodon as Internals
+class Mastodon(Internals):
+    ###
+    # Reading data: Polls
+    ###
+    @api_version("2.8.0", "2.8.0", _DICT_VERSION_POLL)
+    def poll(self, id):
+        """
+        Fetch information about the poll with the given id
+        Returns a :ref:`poll dict <poll dict>`.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/polls/{0}'.format(str(id))
+        return self.__api_request('GET', url)
+    ###
+    # Writing data: Polls
+    ###
+    @api_version("2.8.0", "2.8.0", _DICT_VERSION_POLL)
+    def poll_vote(self, id, choices):
+        """
+        Vote in the given poll.
+        `choices` is the index of the choice you wish to register a vote for
+        (i.e. its index in the corresponding polls `options` field. In case
+        of a poll that allows selection of more than one option, a list of
+        indices can be passed.
+        You can only submit choices for any given poll once in case of
+        single-option polls, or only once per option in case of multi-option
+        polls.
+        Returns the updated :ref:`poll dict <poll dict>`
+        """
+        id = self.__unpack_id(id)
+        if not isinstance(choices, list):
+            choices = [choices]
+        params = self.__generate_params(locals(), ['id'])
+        url = '/api/v1/polls/{0}/votes'.format(id)
+        self.__api_request('POST', url, params)
+    
+    def make_poll(self, options, expires_in, multiple=False, hide_totals=False):
+        """
+        Generate a poll object that can be passed as the `poll` option when posting a status.
+        options is an array of strings with the poll options (Maximum, by default: 4),
+        expires_in is the time in seconds for which the poll should be open.
+        Set multiple to True to allow people to choose more than one answer. Set
+        hide_totals to True to hide the results of the poll until it has expired.
+        """
+        poll_params = locals()
+        del poll_params["self"]
+        return poll_params        
+\ No newline at end of file
diff --git a/mastodon/preferences.py b/mastodon/preferences.py
new file mode 100644
index 0000000..5e7435f
--- /dev/null
+++ b/mastodon/preferences.py
@@ -0,0 +1,71 @@
+# preferences.py - user preferences, markers
+import collections
+from .versions import _DICT_VERSION_PREFERENCES, _DICT_VERSION_MARKER
+from .errors import MastodonIllegalArgumentError
+from .utility import api_version
+from .internals import Mastodon as Internals
+class Mastodon(Internals):
+    ###
+    # Reading data: Preferences
+    ###
+    @api_version("2.8.0", "2.8.0", _DICT_VERSION_PREFERENCES)
+    def preferences(self):
+        """
+        Fetch the user's preferences, which can be used to set some default options.
+        As of 2.8.0, apps can only fetch, not update preferences.
+        Returns a :ref:`preference dict <preference dict>`.
+        """
+        return self.__api_request('GET', '/api/v1/preferences')
+    ##
+    # Reading data: Read markers
+    ##
+    @api_version("3.0.0", "3.0.0", _DICT_VERSION_MARKER)
+    def markers_get(self, timeline=["home"]):
+        """
+        Get the last-read-location markers for the specified timelines. Valid timelines
+        are the same as in :ref:`timeline() <timeline()>`
+        Note that despite the singular name, `timeline` can be a list.
+        Returns a dict of :ref:`read marker dicts <read marker dicts>`, keyed by timeline name.
+        """
+        if not isinstance(timeline, (list, tuple)):
+            timeline = [timeline]
+        params = self.__generate_params(locals())
+        return self.__api_request('GET', '/api/v1/markers', params)
+    ##
+    # Writing data: Read markers
+    ##
+    @api_version("3.0.0", "3.0.0", _DICT_VERSION_MARKER)
+    def markers_set(self, timelines, last_read_ids):
+        """
+        Set the "last read" marker(s) for the given timeline(s) to the given id(s)
+        Note that if you give an invalid timeline name, this will silently do nothing.
+        Returns a dict with the updated :ref:`read marker dicts <read marker dicts>`, keyed by timeline name.
+        """
+        if not isinstance(timelines, (list, tuple)):
+            timelines = [timelines]
+        if not isinstance(last_read_ids, (list, tuple)):
+            last_read_ids = [last_read_ids]
+        if len(last_read_ids) != len(timelines):
+            raise MastodonIllegalArgumentError("Number of specified timelines and ids must be the same")
+        params = collections.OrderedDict()
+        for timeline, last_read_id in zip(timelines, last_read_ids):
+            params[timeline] = collections.OrderedDict()
+            params[timeline]["last_read_id"] = self.__unpack_id(last_read_id)
+        return self.__api_request('POST', '/api/v1/markers', params, use_json=True)
+                
+\ No newline at end of file
diff --git a/mastodon/push.py b/mastodon/push.py
new file mode 100644
index 0000000..def348a
--- /dev/null
+++ b/mastodon/push.py
@@ -0,0 +1,201 @@
+# push.py - webpush endpoints and tooling
+import base64
+import os
+import json
+from .versions import _DICT_VERSION_PUSH, _DICT_VERSION_PUSH_NOTIF
+from .errors import MastodonIllegalArgumentError
+from .utility import api_version
+from .compat import IMPL_HAS_CRYPTO, ec, serialization, default_backend
+from .compat import IMPL_HAS_ECE, http_ece
+from .internals import Mastodon as Internals
+class Mastodon(Internals):
+    ###
+    # Reading data: Webpush subscriptions
+    ###
+    @api_version("2.4.0", "2.4.0", _DICT_VERSION_PUSH)
+    def push_subscription(self):
+        """
+        Fetch the current push subscription the logged-in user has for this app.
+        Returns a :ref:`push subscription dict <push subscription dict>`.
+        """
+        return self.__api_request('GET', '/api/v1/push/subscription')
+    ###
+    # Writing data: Push subscriptions
+    ###
+    @api_version("2.4.0", "2.4.0", _DICT_VERSION_PUSH)
+    def push_subscription_set(self, endpoint, encrypt_params, follow_events=None,
+                              favourite_events=None, reblog_events=None,
+                              mention_events=None, poll_events=None,
+                              follow_request_events=None, status_events=None, policy='all'):
+        """
+        Sets up or modifies the push subscription the logged-in user has for this app.
+        `endpoint` is the endpoint URL mastodon should call for pushes. Note that mastodon
+        requires https for this URL. `encrypt_params` is a dict with key parameters that allow
+        the server to encrypt data for you: A public key `pubkey` and a shared secret `auth`.
+        You can generate this as well as the corresponding private key using the
+        :ref:`push_subscription_generate_keys() <push_subscription_generate_keys()>` function.
+        `policy` controls what sources will generate webpush events. Valid values are
+        `all`, `none`, `follower` and `followed`.
+        The rest of the parameters controls what kind of events you wish to subscribe to.
+        Returns a :ref:`push subscription dict <push subscription dict>`.
+        """
+        if not policy in ['all', 'none', 'follower', 'followed']:
+            raise MastodonIllegalArgumentError("Valid values for policy are 'all', 'none', 'follower' or 'followed'.")
+        endpoint = Mastodon.__protocolize(endpoint)
+        push_pubkey_b64 = base64.b64encode(encrypt_params['pubkey'])
+        push_auth_b64 = base64.b64encode(encrypt_params['auth'])
+        params = {
+            'subscription[endpoint]': endpoint,
+            'subscription[keys][p256dh]': push_pubkey_b64,
+            'subscription[keys][auth]': push_auth_b64,
+            'policy': policy
+        }
+        if follow_events is not None:
+            params['data[alerts][follow]'] = follow_events
+        if favourite_events is not None:
+            params['data[alerts][favourite]'] = favourite_events
+        if reblog_events is not None:
+            params['data[alerts][reblog]'] = reblog_events
+        if mention_events is not None:
+            params['data[alerts][mention]'] = mention_events
+        if poll_events is not None:
+            params['data[alerts][poll]'] = poll_events
+        if follow_request_events is not None:
+            params['data[alerts][follow_request]'] = follow_request_events
+        if follow_request_events is not None:
+            params['data[alerts][status]'] = status_events
+        # Canonicalize booleans
+        params = self.__generate_params(params)
+        return self.__api_request('POST', '/api/v1/push/subscription', params)
+    @api_version("2.4.0", "2.4.0", _DICT_VERSION_PUSH)
+    def push_subscription_update(self, follow_events=None,
+                                 favourite_events=None, reblog_events=None,
+                                 mention_events=None, poll_events=None,
+                                 follow_request_events=None):
+        """
+        Modifies what kind of events the app wishes to subscribe to.
+        Returns the updated :ref:`push subscription dict <push subscription dict>`.
+        """
+        params = {}
+        if follow_events is not None:
+            params['data[alerts][follow]'] = follow_events
+        if favourite_events is not None:
+            params['data[alerts][favourite]'] = favourite_events
+        if reblog_events is not None:
+            params['data[alerts][reblog]'] = reblog_events
+        if mention_events is not None:
+            params['data[alerts][mention]'] = mention_events
+        if poll_events is not None:
+            params['data[alerts][poll]'] = poll_events
+        if follow_request_events is not None:
+            params['data[alerts][follow_request]'] = follow_request_events
+        # Canonicalize booleans
+        params = self.__generate_params(params)
+        return self.__api_request('PUT', '/api/v1/push/subscription', params)
+    @api_version("2.4.0", "2.4.0", "2.4.0")
+    def push_subscription_delete(self):
+        """
+        Remove the current push subscription the logged-in user has for this app.
+        """
+        self.__api_request('DELETE', '/api/v1/push/subscription')
+    ###
+    # Push subscription crypto utilities
+    ###
+    def push_subscription_generate_keys(self):
+        """
+        Generates a private key, public key and shared secret for use in webpush subscriptions.
+        Returns two dicts: One with the private key and shared secret and another with the
+        public key and shared secret.
+        """
+        if not IMPL_HAS_CRYPTO:
+            raise NotImplementedError(
+                'To use the crypto tools, please install the webpush feature dependencies.')
+        push_key_pair = ec.generate_private_key(ec.SECP256R1(), default_backend())
+        push_key_priv = push_key_pair.private_numbers().private_value
+        try: 
+            push_key_pub = push_key_pair.public_key().public_bytes(
+                serialization.Encoding.X962,
+                serialization.PublicFormat.UncompressedPoint,
+            )
+        except:
+            push_key_pub = push_key_pair.public_key().public_numbers().encode_point()
+            
+        push_shared_secret = os.urandom(16)
+        priv_dict = {
+            'privkey': push_key_priv,
+            'auth': push_shared_secret
+        }
+        pub_dict = {
+            'pubkey': push_key_pub,
+            'auth': push_shared_secret
+        }
+        return priv_dict, pub_dict
+    @api_version("2.4.0", "2.4.0", _DICT_VERSION_PUSH_NOTIF)
+    def push_subscription_decrypt_push(self, data, decrypt_params, encryption_header, crypto_key_header):
+        """
+        Decrypts `data` received in a webpush request. Requires the private key dict
+        from :ref:`push_subscription_generate_keys() <push_subscription_generate_keys()>` (`decrypt_params`) as well as the
+        Encryption and server Crypto-Key headers from the received webpush
+        Returns the decoded webpush as a :ref:`push notification dict <push notification dict>`.
+        """
+        if (not IMPL_HAS_ECE) or (not IMPL_HAS_CRYPTO):
+            raise NotImplementedError(
+                'To use the crypto tools, please install the webpush feature dependencies.')
+        salt = self.__decode_webpush_b64(encryption_header.split("salt=")[1].strip())
+        dhparams = self.__decode_webpush_b64(crypto_key_header.split("dh=")[1].split(";")[0].strip())
+        p256ecdsa = self.__decode_webpush_b64(crypto_key_header.split("p256ecdsa=")[1].strip())
+        dec_key = ec.derive_private_key(decrypt_params['privkey'], ec.SECP256R1(), default_backend())
+        decrypted = http_ece.decrypt(
+            data,
+            salt=salt,
+            key=p256ecdsa,
+            private_key=dec_key,
+            dh=dhparams,
+            auth_secret=decrypt_params['auth'],
+            keylabel="P-256",
+            version="aesgcm"
+        )
+        return json.loads(decrypted.decode('utf-8'), object_hook=Mastodon.__json_hooks)
diff --git a/mastodon/relationships.py b/mastodon/relationships.py
new file mode 100644
index 0000000..9cf15db
--- /dev/null
+++ b/mastodon/relationships.py
@@ -0,0 +1,136 @@
+# relationships.py - endpoints for user and domain blocks and mutes as well as follow requests
+from .versions import _DICT_VERSION_ACCOUNT, _DICT_VERSION_RELATIONSHIP
+from .utility import api_version
+from .internals import Mastodon as Internals
+class Mastodon(Internals):
+    ###
+    # Reading data: Mutes and Blocks
+    ###
+    @api_version("1.1.0", "2.6.0", _DICT_VERSION_ACCOUNT)
+    def mutes(self, max_id=None, min_id=None, since_id=None, limit=None):
+        """
+        Fetch a list of users muted by the logged-in user.
+        Returns a list of :ref:`account dicts <account dicts>`.
+        """
+        if max_id is not None:
+            max_id = self.__unpack_id(max_id, dateconv=True)
+        if min_id is not None:
+            min_id = self.__unpack_id(min_id, dateconv=True)
+        if since_id is not None:
+            since_id = self.__unpack_id(since_id, dateconv=True)
+        params = self.__generate_params(locals())
+        return self.__api_request('GET', '/api/v1/mutes', params)
+    @api_version("1.0.0", "2.6.0", _DICT_VERSION_ACCOUNT)
+    def blocks(self, max_id=None, min_id=None, since_id=None, limit=None):
+        """
+        Fetch a list of users blocked by the logged-in user.
+        Returns a list of :ref:`account dicts <account dicts>`.
+        """
+        if max_id is not None:
+            max_id = self.__unpack_id(max_id, dateconv=True)
+        if min_id is not None:
+            min_id = self.__unpack_id(min_id, dateconv=True)
+        if since_id is not None:
+            since_id = self.__unpack_id(since_id, dateconv=True)
+        params = self.__generate_params(locals())
+        return self.__api_request('GET', '/api/v1/blocks', params)
+    ###
+    # Reading data: Follow requests
+    ###
+    @api_version("1.0.0", "2.6.0", _DICT_VERSION_ACCOUNT)
+    def follow_requests(self, max_id=None, min_id=None, since_id=None, limit=None):
+        """
+        Fetch the logged-in user's incoming follow requests.
+        Returns a list of :ref:`account dicts <account dicts>`.
+        """
+        if max_id is not None:
+            max_id = self.__unpack_id(max_id, dateconv=True)
+        if min_id is not None:
+            min_id = self.__unpack_id(min_id, dateconv=True)
+        if since_id is not None:
+            since_id = self.__unpack_id(since_id, dateconv=True)
+        params = self.__generate_params(locals())
+        return self.__api_request('GET', '/api/v1/follow_requests', params)
+    ###
+    # Reading data: Domain blocks
+    ###
+    @api_version("1.4.0", "2.6.0", "1.4.0")
+    def domain_blocks(self, max_id=None, min_id=None, since_id=None, limit=None):
+        """
+        Fetch the logged-in user's blocked domains.
+        Returns a list of blocked domain URLs (as strings, without protocol specifier).
+        """
+        if max_id is not None:
+            max_id = self.__unpack_id(max_id, dateconv=True)
+        if min_id is not None:
+            min_id = self.__unpack_id(min_id, dateconv=True)
+        if since_id is not None:
+            since_id = self.__unpack_id(since_id, dateconv=True)
+        params = self.__generate_params(locals())
+        return self.__api_request('GET', '/api/v1/domain_blocks', params)
+    ###
+    # Writing data: Follow requests
+    ###
+    @api_version("1.0.0", "3.0.0", _DICT_VERSION_RELATIONSHIP)
+    def follow_request_authorize(self, id):
+        """
+        Accept an incoming follow request.
+        Returns the updated :ref:`relationship dict <relationship dict>` for the requesting account.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/follow_requests/{0}/authorize'.format(str(id))
+        return self.__api_request('POST', url)
+    @api_version("1.0.0", "3.0.0", _DICT_VERSION_RELATIONSHIP)
+    def follow_request_reject(self, id):
+        """
+        Reject an incoming follow request.
+        Returns the updated :ref:`relationship dict <relationship dict>` for the requesting account.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/follow_requests/{0}/reject'.format(str(id))
+        return self.__api_request('POST', url)
+    ###
+    # Writing data: Domain blocks
+    ###
+    @api_version("1.4.0", "1.4.0", "1.4.0")
+    def domain_block(self, domain=None):
+        """
+        Add a block for all statuses originating from the specified domain for the logged-in user.
+        """
+        params = self.__generate_params(locals())
+        self.__api_request('POST', '/api/v1/domain_blocks', params)
+    @api_version("1.4.0", "1.4.0", "1.4.0")
+    def domain_unblock(self, domain=None):
+        """
+        Remove a domain block for the logged-in user.
+        """
+        params = self.__generate_params(locals())
+        self.__api_request('DELETE', '/api/v1/domain_blocks', params)        
+\ No newline at end of file
diff --git a/mastodon/reports.py b/mastodon/reports.py
new file mode 100644
index 0000000..3d6380e
--- /dev/null
+++ b/mastodon/reports.py
@@ -0,0 +1,62 @@
+# reports.py - report endpoints
+from .versions import _DICT_VERSION_REPORT
+from .errors import MastodonVersionError
+from .utility import api_version
+from .internals import Mastodon as Internals
+class Mastodon(Internals):
+    ###
+    # Reading data: Reports
+    ###
+    @api_version("1.1.0", "1.1.0", _DICT_VERSION_REPORT)
+    def reports(self):
+        """
+        Fetch a list of reports made by the logged-in user.
+        Returns a list of :ref:`report dicts <report dicts>`.
+        Warning: This method has now finally been removed, and will not
+        work on Mastodon versions 2.5.0 and above.
+        """
+        if self.verify_minimum_version("2.5.0", cached=True):
+            raise MastodonVersionError("API removed in Mastodon 2.5.0")
+        return self.__api_request('GET', '/api/v1/reports')
+    ###
+    # Writing data: Reports
+    ###
+    @api_version("1.1.0", "3.5.0", _DICT_VERSION_REPORT)
+    def report(self, account_id, status_ids=None, comment=None, forward=False, category=None, rule_ids=None):
+        """
+        Report statuses to the instances administrators.
+        Accepts a list of toot IDs associated with the report, and a comment.
+        Starting with Mastodon 3.5.0, you can also pass a `category` (one out of
+        "spam", "violation" or "other") and `rule_ids` (a list of rule IDs corresponding
+        to the rules returned by the :ref:`instance() <instance()>` API).
+        Set `forward` to True to forward a report of a remote user to that users
+        instance as well as sending it to the instance local administrators.
+        Returns a :ref:`report dict <report dict>`.
+        """
+        if category is not None and not category in ["spam", "violation", "other"]:
+            raise MastodonIllegalArgumentError("Invalid report category (must be spam, violation or other)")
+        account_id = self.__unpack_id(account_id)
+        if status_ids is not None:
+            if not isinstance(status_ids, list):
+                status_ids = [status_ids]
+            status_ids = list(map(lambda x: self.__unpack_id(x), status_ids))
+        params_initial = locals()
+        if not forward:
+            del params_initial['forward']
+        params = self.__generate_params(params_initial)
+        return self.__api_request('POST', '/api/v1/reports/', params)
+\ No newline at end of file
diff --git a/mastodon/search.py b/mastodon/search.py
new file mode 100644
index 0000000..b77002f
--- /dev/null
+++ b/mastodon/search.py
@@ -0,0 +1,91 @@
+# search.py - search endpoints
+from .versions import _DICT_VERSION_SEARCHRESULT
+from .errors import MastodonVersionError
+from .utility import api_version
+from .internals import Mastodon as Internals
+class Mastodon(Internals):
+    ###
+    # Reading data: Searching
+    ###
+    def __ensure_search_params_acceptable(self, account_id, offset, min_id, max_id):
+        """
+        Internal Helper: Throw a MastodonVersionError if version is < 2.8.0 but parameters
+        for search that are available only starting with 2.8.0 are specified.
+        """
+        if any(item is not None for item in (account_id, offset, min_id, max_id)):
+            if not self.verify_minimum_version("2.8.0", cached=True):
+                raise MastodonVersionError("Advanced search parameters require Mastodon 2.8.0+")
+    @api_version("1.1.0", "2.8.0", _DICT_VERSION_SEARCHRESULT)
+    def search(self, q, resolve=True, result_type=None, account_id=None, offset=None, min_id=None, max_id=None, exclude_unreviewed=True):
+        """
+        Fetch matching hashtags, accounts and statuses. Will perform webfinger
+        lookups if resolve is True. Full-text search is only enabled if
+        the instance supports it, and is restricted to statuses the logged-in
+        user wrote or was mentioned in.
+        `result_type` can be one of "accounts", "hashtags" or "statuses", to only
+        search for that type of object.
+        Specify `account_id` to only get results from the account with that id.
+        `offset`, `min_id` and `max_id` can be used to paginate.
+        `exclude_unreviewed` can be used to restrict search results for hashtags to only
+        those that have been reviewed by moderators. It is on by default. When using the
+        v1 search API (pre 2.4.1), it is ignored.
+        Will use search_v1 (no tag dicts in return values) on Mastodon versions before
+        2.4.1), search_v2 otherwise. Parameters other than resolve are only available
+        on Mastodon 2.8.0 or above - this function will throw a MastodonVersionError
+        if you try to use them on versions before that. Note that the cached version
+        number will be used for this to avoid uneccesary requests.
+        Returns a :ref:`search result dict <search result dict>`, with tags as `hashtag dicts`_.
+        """
+        if self.verify_minimum_version("2.4.1", cached=True):
+            return self.search_v2(q, resolve=resolve, result_type=result_type, account_id=account_id, offset=offset, min_id=min_id, max_id=max_id, exclude_unreviewed=exclude_unreviewed)
+        else:
+            self.__ensure_search_params_acceptable(account_id, offset, min_id, max_id)
+            return self.search_v1(q, resolve=resolve)
+    @api_version("1.1.0", "2.1.0", "2.1.0")
+    def search_v1(self, q, resolve=False):
+        """
+        Identical to `search_v2()`, except in that it does not return
+        tags as :ref:`hashtag dicts <hashtag dicts>`.
+        Returns a :ref:`search result dict <search result dict>`.
+        """
+        params = self.__generate_params(locals())
+        if not resolve:
+            del params['resolve']
+        return self.__api_request('GET', '/api/v1/search', params)
+    @api_version("2.4.1", "2.8.0", _DICT_VERSION_SEARCHRESULT)
+    def search_v2(self, q, resolve=True, result_type=None, account_id=None, offset=None, min_id=None, max_id=None, exclude_unreviewed=True):
+        """
+        Identical to `search_v1()`, except in that it returns tags as
+        :ref:`hashtag dicts <hashtag dicts>`, has more parameters, and resolves by default.
+        For more details documentation, please see `search()`
+        Returns a :ref:`search result dict <search result dict>`.
+        """
+        self.__ensure_search_params_acceptable(account_id, offset, min_id, max_id)
+        params = self.__generate_params(locals())
+        if not resolve:
+            del params["resolve"]
+        if not exclude_unreviewed or not self.verify_minimum_version("3.0.0", cached=True):
+            del params["exclude_unreviewed"]
+        if "result_type" in params:
+            params["type"] = params["result_type"]
+            del params["result_type"]
+        return self.__api_request('GET', '/api/v2/search', params)
diff --git a/mastodon/statuses.py b/mastodon/statuses.py
index ae891d5..36a7d2b 100644
--- a/mastodon/statuses.py
+++ b/mastodon/statuses.py
@@ -1,10 +1,14 @@
-    
+# statuses.py - status endpoints (regular and scheduled)
-from .versions import _DICT_VERSION_STATUS, _DICT_VERSION_CARD, _DICT_VERSION_CONTEXT, _DICT_VERSION_ACCOUNT, _DICT_VERSION_SCHEDULED_STATUS
+import collections
+from .versions import _DICT_VERSION_STATUS, _DICT_VERSION_CARD, _DICT_VERSION_CONTEXT, _DICT_VERSION_ACCOUNT, _DICT_VERSION_SCHEDULED_STATUS, \
+                        _DICT_VERSION_STATUS_EDIT
+from .errors import MastodonIllegalArgumentError
 from .utility import api_version
 from .internals import Mastodon as Internals
 class Mastodon(Internals):    
    ###
    # Reading data: Statuses
@@ -105,4 +109,416 @@ class Mastodon(Internals):
        id = self.__unpack_id(id)
        url = '/api/v1/scheduled_statuses/{0}'.format(str(id))
        return self.__api_request('GET', url)
-        
-\ No newline at end of file
+        
+    ###
+    # Writing data: Statuses
+    ###
+    def __status_internal(self, status, in_reply_to_id=None, media_ids=None,
+                    sensitive=False, visibility=None, spoiler_text=None,
+                    language=None, idempotency_key=None, content_type=None,
+                    scheduled_at=None, poll=None, quote_id=None, edit=False):
+        if quote_id is not None:
+            if self.feature_set != "fedibird":
+                raise MastodonIllegalArgumentError('quote_id is only available with feature set fedibird')
+            quote_id = self.__unpack_id(quote_id)
+        if content_type is not None:
+            if self.feature_set != "pleroma":
+                raise MastodonIllegalArgumentError('content_type is only available with feature set pleroma')
+            # It would be better to read this from nodeinfo and cache, but this is easier
+            if not content_type in ["text/plain", "text/html", "text/markdown", "text/bbcode"]:
+                raise MastodonIllegalArgumentError('Invalid content type specified')
+        if in_reply_to_id is not None:
+            in_reply_to_id = self.__unpack_id(in_reply_to_id)
+        if scheduled_at is not None:
+            scheduled_at = self.__consistent_isoformat_utc(scheduled_at)
+        params_initial = locals()
+        # Validate poll/media exclusivity
+        if poll is not None:
+            if media_ids is not None and len(media_ids) != 0:
+                raise ValueError(
+                    'Status can have media or poll attached - not both.')
+        # Validate visibility parameter
+        valid_visibilities = ['private', 'public', 'unlisted', 'direct']
+        if params_initial['visibility'] is None:
+            del params_initial['visibility']
+        else:
+            params_initial['visibility'] = params_initial['visibility'].lower()
+            if params_initial['visibility'] not in valid_visibilities:
+                raise ValueError('Invalid visibility value! Acceptable values are %s' % valid_visibilities)
+        if params_initial['language'] is None:
+            del params_initial['language']
+        if params_initial['sensitive'] is False:
+            del [params_initial['sensitive']]
+        headers = {}
+        if idempotency_key is not None:
+            headers['Idempotency-Key'] = idempotency_key
+        if media_ids is not None:
+            try:
+                media_ids_proper = []
+                if not isinstance(media_ids, (list, tuple)):
+                    media_ids = [media_ids]
+                for media_id in media_ids:
+                    media_ids_proper.append(self.__unpack_id(media_id))
+            except Exception as e:
+                raise MastodonIllegalArgumentError("Invalid media dict: %s" % e)
+            params_initial["media_ids"] = media_ids_proper
+        if params_initial['content_type'] is None:
+            del params_initial['content_type']
+        use_json = False
+        if poll is not None:
+            use_json = True
+        params = self.__generate_params(params_initial, ['idempotency_key', 'edit'])
+        if edit is None:
+            # Post
+            return self.__api_request('POST', '/api/v1/statuses', params, headers=headers, use_json=use_json)
+        else:
+            # Edit
+            return self.__api_request('PUT', '/api/v1/statuses/{0}'.format(str(self.__unpack_id(edit))), params, headers=headers, use_json=use_json)
+    @api_version("1.0.0", "2.8.0", _DICT_VERSION_STATUS)
+    def status_post(self, status, in_reply_to_id=None, media_ids=None,
+                    sensitive=False, visibility=None, spoiler_text=None,
+                    language=None, idempotency_key=None, content_type=None,
+                    scheduled_at=None, poll=None, quote_id=None):
+        """
+        Post a status. Can optionally be in reply to another status and contain
+        media.
+        `media_ids` should be a list. (If it's not, the function will turn it
+        into one.) It can contain up to four pieces of media (uploaded via
+        :ref:`media_post() <media_post()>`). `media_ids` can also be the `media dicts`_ returned
+        by :ref:`media_post() <media_post()>` - they are unpacked automatically.
+        The `sensitive` boolean decides whether or not media attached to the post
+        should be marked as sensitive, which hides it by default on the Mastodon
+        web front-end.
+        The visibility parameter is a string value and accepts any of:
+        'direct' - post will be visible only to mentioned users
+        'private' - post will be visible only to followers
+        'unlisted' - post will be public but not appear on the public timeline
+        'public' - post will be public
+        If not passed in, visibility defaults to match the current account's
+        default-privacy setting (starting with Mastodon version 1.6) or its
+        locked setting - private if the account is locked, public otherwise
+        (for Mastodon versions lower than 1.6).
+        The `spoiler_text` parameter is a string to be shown as a warning before
+        the text of the status.  If no text is passed in, no warning will be
+        displayed.
+        Specify `language` to override automatic language detection. The parameter
+        accepts all valid ISO 639-1 (2-letter) or for languages where that do not
+        have one, 639-3 (three letter) language codes.
+        You can set `idempotency_key` to a value to uniquely identify an attempt
+        at posting a status. Even if you call this function more than once,
+        if you call it with the same `idempotency_key`, only one status will
+        be created.
+        Pass a datetime as `scheduled_at` to schedule the toot for a specific time
+        (the time must be at least 5 minutes into the future). If this is passed,
+        status_post returns a :ref:`scheduled status dict <scheduled status dict>` instead.
+        Pass `poll` to attach a poll to the status. An appropriate object can be
+        constructed using :ref:`make_poll() <make_poll()>` . Note that as of Mastodon version
+        2.8.2, you can only have either media or a poll attached, not both at
+        the same time.
+        **Specific to "pleroma" feature set:**: Specify `content_type` to set
+        the content type of your post on Pleroma. It accepts 'text/plain' (default),
+        'text/markdown', 'text/html' and 'text/bbcode'. This parameter is not
+        supported on Mastodon servers, but will be safely ignored if set.
+        **Specific to "fedibird" feature set:**: The `quote_id` parameter is
+        a non-standard extension that specifies the id of a quoted status.
+        Returns a :ref:`status dict <status dict>` with the new status.
+        """
+        return self.__status_internal( 
+            status, 
+            in_reply_to_id, 
+            media_ids, 
+            sensitive, 
+            visibility, 
+            spoiler_text, 
+            language, 
+            idempotency_key, 
+            content_type, 
+            scheduled_at, 
+            poll, 
+            quote_id, 
+            edit=None
+        )
+    @api_version("1.0.0", "2.8.0", _DICT_VERSION_STATUS)
+    def toot(self, status):
+        """
+        Synonym for :ref:`status_post() <status_post()>` that only takes the status text as input.
+        Usage in production code is not recommended.
+        Returns a :ref:`status dict <status dict>` with the new status.
+        """
+        return self.status_post(status)
+    @api_version("3.5.0", "3.5.0", _DICT_VERSION_STATUS)
+    def status_update(self, id, status = None, spoiler_text = None, sensitive = None, media_ids = None, poll = None):
+        """
+        Edit a status. The meanings of the fields are largely the same as in :ref:`status_post() <status_post()>`,
+        though not every field can be edited.
+        Note that editing a poll will reset the votes.
+        """
+        return self.__status_internal(
+            status = status, 
+            media_ids = media_ids, 
+            sensitive = sensitive, 
+            spoiler_text = spoiler_text, 
+            poll = poll, 
+            edit = id
+        ) 
+    @api_version("3.5.0", "3.5.0", _DICT_VERSION_STATUS_EDIT)
+    def status_history(self, id):
+        """
+        Returns the edit history of a status as a list of :ref:`status edit dicts <status edit dicts>`, starting
+        from the original form. Note that this means that a status that has been edited
+        once will have *two* entries in this list, a status that has been edited twice
+        will have three, and so on.
+        """
+        id = self.__unpack_id(id)
+        return self.__api_request('GET', "/api/v1/statuses/{0}/history".format(str(id)))
+    def status_source(self, id):
+        """
+        Returns the source of a status for editing.
+        Return value is a dictionary containing exactly the parameters you could pass to
+        :ref:`status_update() <status_update()>` to change nothing about the status, except `status` is `text`
+        instead.
+        """
+        id = self.__unpack_id(id)
+        return self.__api_request('GET', "/api/v1/statuses/{0}/source".format(str(id)))
+    @api_version("1.0.0", "2.8.0", _DICT_VERSION_STATUS)
+    def status_reply(self, to_status, status, in_reply_to_id=None, media_ids=None,
+                     sensitive=False, visibility=None, spoiler_text=None,
+                     language=None, idempotency_key=None, content_type=None,
+                     scheduled_at=None, poll=None, untag=False):
+        """
+        Helper function - acts like status_post, but prepends the name of all
+        the users that are being replied to to the status text and retains
+        CW and visibility if not explicitly overridden.
+        Set `untag` to True if you want the reply to only go to the user you
+        are replying to, removing every other mentioned user from the
+        conversation.
+        """
+        keyword_args = locals()
+        del keyword_args["self"]
+        del keyword_args["to_status"]
+        del keyword_args["untag"]
+        user_id = self.__get_logged_in_id()
+        # Determine users to mention
+        mentioned_accounts = collections.OrderedDict()
+        mentioned_accounts[to_status.account.id] = to_status.account.acct
+        if not untag:
+            for account in to_status.mentions:
+                if account.id != user_id and not account.id in mentioned_accounts.keys():
+                    mentioned_accounts[account.id] = account.acct
+        # Join into one piece of text. The space is added inside because of self-replies.
+        status = "".join(map(lambda x: "@" + x + " ",
+                         mentioned_accounts.values())) + status
+        # Retain visibility / cw
+        if visibility is None and 'visibility' in to_status:
+            visibility = to_status.visibility
+        if spoiler_text is None and 'spoiler_text' in to_status:
+            spoiler_text = to_status.spoiler_text
+        keyword_args["status"] = status
+        keyword_args["visibility"] = visibility
+        keyword_args["spoiler_text"] = spoiler_text
+        keyword_args["in_reply_to_id"] = to_status.id
+        return self.status_post(**keyword_args)
+    @api_version("1.0.0", "1.0.0", "1.0.0")
+    def status_delete(self, id):
+        """
+        Delete a status
+        Returns the now-deleted status, with an added "source" attribute that contains
+        the text that was used to compose this status (this can be used to power
+        "delete and redraft" functionality)
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/statuses/{0}'.format(str(id))
+        return self.__api_request('DELETE', url)
+    @api_version("1.0.0", "2.0.0", _DICT_VERSION_STATUS)
+    def status_reblog(self, id, visibility=None):
+        """
+        Reblog / boost a status.
+        The visibility parameter functions the same as in :ref:`status_post() <status_post()>` and
+        allows you to reduce the visibility of a reblogged status.
+        Returns a :ref:`status dict <status dict>` with a new status that wraps around the reblogged one.
+        """
+        params = self.__generate_params(locals(), ['id'])
+        valid_visibilities = ['private', 'public', 'unlisted', 'direct']
+        if 'visibility' in params:
+            params['visibility'] = params['visibility'].lower()
+            if params['visibility'] not in valid_visibilities:
+                raise ValueError('Invalid visibility value! Acceptable '
+                                 'values are %s' % valid_visibilities)
+        id = self.__unpack_id(id)
+        url = '/api/v1/statuses/{0}/reblog'.format(str(id))
+        return self.__api_request('POST', url, params)
+    @api_version("1.0.0", "2.0.0", _DICT_VERSION_STATUS)
+    def status_unreblog(self, id):
+        """
+        Un-reblog a status.
+        Returns a :ref:`status dict <status dict>` with the status that used to be reblogged.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/statuses/{0}/unreblog'.format(str(id))
+        return self.__api_request('POST', url)
+    @api_version("1.0.0", "2.0.0", _DICT_VERSION_STATUS)
+    def status_favourite(self, id):
+        """
+        Favourite a status.
+        Returns a :ref:`status dict <status dict>` with the favourited status.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/statuses/{0}/favourite'.format(str(id))
+        return self.__api_request('POST', url)
+    @api_version("1.0.0", "2.0.0", _DICT_VERSION_STATUS)
+    def status_unfavourite(self, id):
+        """
+        Un-favourite a status.
+        Returns a :ref:`status dict <status dict>` with the un-favourited status.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/statuses/{0}/unfavourite'.format(str(id))
+        return self.__api_request('POST', url)
+    @api_version("1.4.0", "2.0.0", _DICT_VERSION_STATUS)
+    def status_mute(self, id):
+        """
+        Mute notifications for a status.
+        Returns a :ref:`status dict <status dict>` with the now muted status
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/statuses/{0}/mute'.format(str(id))
+        return self.__api_request('POST', url)
+    @api_version("1.4.0", "2.0.0", _DICT_VERSION_STATUS)
+    def status_unmute(self, id):
+        """
+        Unmute notifications for a status.
+        Returns a :ref:`status dict <status dict>` with the status that used to be muted.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/statuses/{0}/unmute'.format(str(id))
+        return self.__api_request('POST', url)
+    @api_version("2.1.0", "2.1.0", _DICT_VERSION_STATUS)
+    def status_pin(self, id):
+        """
+        Pin a status for the logged-in user.
+        Returns a :ref:`status dict <status dict>` with the now pinned status
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/statuses/{0}/pin'.format(str(id))
+        return self.__api_request('POST', url)
+    @api_version("2.1.0", "2.1.0", _DICT_VERSION_STATUS)
+    def status_unpin(self, id):
+        """
+        Unpin a pinned status for the logged-in user.
+        Returns a :ref:`status dict <status dict>` with the status that used to be pinned.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/statuses/{0}/unpin'.format(str(id))
+        return self.__api_request('POST', url)
+    @api_version("3.1.0", "3.1.0", _DICT_VERSION_STATUS)
+    def status_bookmark(self, id):
+        """
+        Bookmark a status as the logged-in user.
+        Returns a :ref:`status dict <status dict>` with the now bookmarked status
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/statuses/{0}/bookmark'.format(str(id))
+        return self.__api_request('POST', url)
+    @api_version("3.1.0", "3.1.0", _DICT_VERSION_STATUS)
+    def status_unbookmark(self, id):
+        """
+        Unbookmark a bookmarked status for the logged-in user.
+        Returns a :ref:`status dict <status dict>` with the status that used to be bookmarked.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/statuses/{0}/unbookmark'.format(str(id))
+        return self.__api_request('POST', url)
+    ###
+    # Writing data: Scheduled statuses
+    ###
+    @api_version("2.7.0", "2.7.0", _DICT_VERSION_SCHEDULED_STATUS)
+    def scheduled_status_update(self, id, scheduled_at):
+        """
+        Update the scheduled time of a scheduled status.
+        New time must be at least 5 minutes into the future.
+        Returns a :ref:`scheduled status dict <scheduled status dict>`
+        """
+        scheduled_at = self.__consistent_isoformat_utc(scheduled_at)
+        id = self.__unpack_id(id)
+        params = self.__generate_params(locals(), ['id'])
+        url = '/api/v1/scheduled_statuses/{0}'.format(str(id))
+        return self.__api_request('PUT', url, params)
+    @api_version("2.7.0", "2.7.0", "2.7.0")
+    def scheduled_status_delete(self, id):
+        """
+        Deletes a scheduled status.
+        """
+        id = self.__unpack_id(id)
+        url = '/api/v1/scheduled_statuses/{0}'.format(str(id))
+        self.__api_request('DELETE', url)
diff --git a/mastodon/streaming_endpoints.py b/mastodon/streaming_endpoints.py
new file mode 100644
index 0000000..9ff72f5
--- /dev/null
+++ b/mastodon/streaming_endpoints.py
@@ -0,0 +1,75 @@
+    # relationships.py - endpoints for user and domain blocks and mutes as well as follow requests
+from .versions import _DICT_VERSION_STATUS
+from .errors import MastodonIllegalArgumentError
+from .defaults import _DEFAULT_STREAM_TIMEOUT, _DEFAULT_STREAM_RECONNECT_WAIT_SEC
+from .utility import api_version
+from .internals import Mastodon as Internals
+class Mastodon(Internals):
+    ###
+    # Streaming
+    ###
+    @api_version("1.1.0", "1.4.2", _DICT_VERSION_STATUS)
+    def stream_user(self, listener, run_async=False, timeout=_DEFAULT_STREAM_TIMEOUT, reconnect_async=False, reconnect_async_wait_sec=_DEFAULT_STREAM_RECONNECT_WAIT_SEC):
+        """
+        Streams events that are relevant to the authorized user, i.e. home
+        timeline and notifications.
+        """
+        return self.__stream('/api/v1/streaming/user', listener, run_async=run_async, timeout=timeout, reconnect_async=reconnect_async, reconnect_async_wait_sec=reconnect_async_wait_sec)
+    @api_version("1.1.0", "1.4.2", _DICT_VERSION_STATUS)
+    def stream_public(self, listener, run_async=False, timeout=_DEFAULT_STREAM_TIMEOUT, reconnect_async=False, reconnect_async_wait_sec=_DEFAULT_STREAM_RECONNECT_WAIT_SEC):
+        """
+        Streams public events.
+        """
+        return self.__stream('/api/v1/streaming/public', listener, run_async=run_async, timeout=timeout, reconnect_async=reconnect_async, reconnect_async_wait_sec=reconnect_async_wait_sec)
+    @api_version("1.1.0", "1.4.2", _DICT_VERSION_STATUS)
+    def stream_local(self, listener, run_async=False, timeout=_DEFAULT_STREAM_TIMEOUT, reconnect_async=False, reconnect_async_wait_sec=_DEFAULT_STREAM_RECONNECT_WAIT_SEC):
+        """
+        Streams local public events.
+        """
+        return self.__stream('/api/v1/streaming/public/local', listener, run_async=run_async, timeout=timeout, reconnect_async=reconnect_async, reconnect_async_wait_sec=reconnect_async_wait_sec)
+    @api_version("1.1.0", "1.4.2", _DICT_VERSION_STATUS)
+    def stream_hashtag(self, tag, listener, local=False, run_async=False, timeout=_DEFAULT_STREAM_TIMEOUT, reconnect_async=False, reconnect_async_wait_sec=_DEFAULT_STREAM_RECONNECT_WAIT_SEC):
+        """
+        Stream for all public statuses for the hashtag 'tag' seen by the connected
+        instance.
+        Set local to True to only get local statuses.
+        """
+        if tag.startswith("#"):
+            raise MastodonIllegalArgumentError("Tag parameter should omit leading #")
+        base = '/api/v1/streaming/hashtag'
+        if local:
+            base += '/local'
+        return self.__stream("{}?tag={}".format(base, tag), listener, run_async=run_async, timeout=timeout, reconnect_async=reconnect_async, reconnect_async_wait_sec=reconnect_async_wait_sec)
+    @api_version("2.1.0", "2.1.0", _DICT_VERSION_STATUS)
+    def stream_list(self, id, listener, run_async=False, timeout=_DEFAULT_STREAM_TIMEOUT, reconnect_async=False, reconnect_async_wait_sec=_DEFAULT_STREAM_RECONNECT_WAIT_SEC):
+        """
+        Stream events for the current user, restricted to accounts on the given
+        list.
+        """
+        id = self.__unpack_id(id)
+        return self.__stream("/api/v1/streaming/list?list={}".format(id), listener, run_async=run_async, timeout=timeout, reconnect_async=reconnect_async, reconnect_async_wait_sec=reconnect_async_wait_sec)
+    @api_version("2.6.0", "2.6.0", _DICT_VERSION_STATUS)
+    def stream_direct(self, listener, run_async=False, timeout=_DEFAULT_STREAM_TIMEOUT, reconnect_async=False, reconnect_async_wait_sec=_DEFAULT_STREAM_RECONNECT_WAIT_SEC):
+        """
+        Streams direct message events for the logged-in user, as conversation events.
+        """
+        return self.__stream('/api/v1/streaming/direct', listener, run_async=run_async, timeout=timeout, reconnect_async=reconnect_async, reconnect_async_wait_sec=reconnect_async_wait_sec)
+    @api_version("2.5.0", "2.5.0", "2.5.0")
+    def stream_healthy(self):
+        """
+        Returns without True if streaming API is okay, False or raises an error otherwise.
+        """
+        api_okay = self.__api_request('GET', '/api/v1/streaming/health', base_url_override=self.__get_streaming_base(), parse=False)
+        if api_okay in [b'OK', b'success']:
+            return True
+        return False
diff --git a/mastodon/suggestions.py b/mastodon/suggestions.py
new file mode 100644
index 0000000..ab55993
--- /dev/null
+++ b/mastodon/suggestions.py
@@ -0,0 +1,32 @@
+# suggestions.py - follow suggestion endpoints
+from .versions import _DICT_VERSION_ACCOUNT
+from .utility import api_version
+from .internals import Mastodon as Internals
+class Mastodon(Internals):
+    ###
+    # Reading data: Follow suggestions
+    ###
+    @api_version("2.4.3", "2.4.3", _DICT_VERSION_ACCOUNT)
+    def suggestions(self):
+        """
+        Fetch follow suggestions for the logged-in user.
+        Returns a list of :ref:`account dicts <account dicts>`.
+        """
+        return self.__api_request('GET', '/api/v1/suggestions')
+    ###
+    # Writing data: Follow suggestions
+    ###
+    @api_version("2.4.3", "2.4.3", _DICT_VERSION_ACCOUNT)
+    def suggestion_delete(self, account_id):
+        """
+        Remove the user with the given `account_id` from the follow suggestions.
+        """
+        account_id = self.__unpack_id(account_id)
+        url = '/api/v1/suggestions/{0}'.format(str(account_id))
+        self.__api_request('DELETE', url)        
+\ No newline at end of file
diff --git a/mastodon/timeline.py b/mastodon/timeline.py
index b5a4068..04406ed 100644
--- a/mastodon/timeline.py
+++ b/mastodon/timeline.py
@@ -1,5 +1,7 @@
+# timeline.py - endpoints for reading various different timelines
 from .versions import _DICT_VERSION_STATUS, _DICT_VERSION_CONVERSATION
-from .error import MastodonIllegalArgumentError, MastodonNotFoundError
+from .errors import MastodonIllegalArgumentError, MastodonNotFoundError
 from .utility import api_version
 from .internals import Mastodon as Internals
@@ -101,21 +103,3 @@ class Mastodon(Internals):
        id = self.__unpack_id(id)
        return self.timeline('list/{0}'.format(id), max_id=max_id, min_id=min_id, since_id=since_id, limit=limit, only_media=only_media, local=local, remote=remote)
-    @api_version("2.6.0", "2.6.0", _DICT_VERSION_CONVERSATION)
-    def conversations(self, max_id=None, min_id=None, since_id=None, limit=None):
-        """
-        Fetches a user's conversations.
-        Returns a list of :ref:`conversation dicts <conversation dicts>`.
-        """
-        if max_id is not None:
-            max_id = self.__unpack_id(max_id, dateconv=True)
-        if min_id is not None:
-            min_id = self.__unpack_id(min_id, dateconv=True)
-        if since_id is not None:
-            since_id = self.__unpack_id(since_id, dateconv=True)
-        params = self.__generate_params(locals())
-        return self.__api_request('GET', "/api/v1/conversations/", params)
diff --git a/mastodon/trends.py b/mastodon/trends.py
new file mode 100644
index 0000000..09a0ae5
--- /dev/null
+++ b/mastodon/trends.py
@@ -0,0 +1,72 @@
+# trends.py - trend-related endpoints
+from .versions import _DICT_VERSION_HASHTAG, _DICT_VERSION_STATUS, _DICT_VERSION_CARD
+from .utility import api_version
+from .internals import Mastodon as Internals
+class Mastodon(Internals):
+    ###
+    # Reading data: Trends
+    ###
+    @api_version("2.4.3", "3.5.0", _DICT_VERSION_HASHTAG)
+    def trends(self, limit=None):
+        """
+        Alias for :ref:`trending_tags() <trending_tags()>`
+        """
+        return self.trending_tags(limit=limit) 
+    @api_version("3.5.0", "3.5.0", _DICT_VERSION_HASHTAG)
+    def trending_tags(self, limit=None, lang=None):
+        """
+        Fetch trending-hashtag information, if the instance provides such information.
+        Specify `limit` to limit how many results are returned (the maximum number
+        of results is 10, the endpoint is not paginated).
+        Does not require authentication unless locked down by the administrator.
+        Important versioning note: This endpoint does not exist for Mastodon versions
+        between 2.8.0 (inclusive) and 3.0.0 (exclusive). 
+        Pass `lang` to override the global locale parameter, which may affect trend ordering.
+        Returns a list of :ref:`hashtag dicts <hashtag dicts>`, sorted by the instance's trending algorithm,
+        descending.
+        """
+        params = self.__generate_params(locals())
+        if self.verify_minimum_version("3.5.0", cached=True):
+            # Starting 3.5.0, old version is deprecated
+            return self.__api_request('GET', '/api/v1/trends/tags', params)
+        else:
+            return self.__api_request('GET', '/api/v1/trends', params)
+    @api_version("3.5.0", "3.5.0", _DICT_VERSION_STATUS)
+    def trending_statuses(self):
+        """
+        Fetch trending-status information, if the instance provides such information.
+        Specify `limit` to limit how many results are returned (the maximum number
+        of results is 10, the endpoint is not paginated).
+        Pass `lang` to override the global locale parameter, which may affect trend ordering.
+        Returns a list of :ref:`status dicts <status dicts>`, sorted by the instances's trending algorithm,
+        descending.
+        """
+        params = self.__generate_params(locals())
+        return self.__api_request('GET', '/api/v1/trends/statuses', params)
+    @api_version("3.5.0", "3.5.0", _DICT_VERSION_CARD)
+    def trending_links(self):
+        """
+        Fetch trending-link information, if the instance provides such information.
+        Specify `limit` to limit how many results are returned (the maximum number
+        of results is 10, the endpoint is not paginated).
+        Returns a list of :ref:`card dicts <card dicts>`, sorted by the instances's trending algorithm,
+        descending.
+        """
+        params = self.__generate_params(locals())
+        return self.__api_request('GET', '/api/v1/trends/links', params)
diff --git a/mastodon/utility.py b/mastodon/utility.py
index 53980b6..2510dca 100644
--- a/mastodon/utility.py
+++ b/mastodon/utility.py
@@ -1,10 +1,13 @@
 # utility.py - utility functions, externally usable
 import re
-from decorator import decorate
-from .error import MastodonVersionError, MastodonAPIError
 import dateutil
 import datetime
+import copy
+from decorator import decorate
+from .errors import MastodonVersionError, MastodonAPIError
+from .compat import IMPL_HAS_BLURHASH, blurhash
 # Module level:
@@ -141,3 +144,112 @@ class Mastodon():
            return datetime.datetime.fromtimestamp(epoch_time)
        else:
            raise MastodonAPIError("No server time in response.")
+    ###
+    # Blurhash utilities
+    ###
+    def decode_blurhash(self, media_dict, out_size=(16, 16), size_per_component=True, return_linear=True):
+        """
+        Basic media-dict blurhash decoding.
+        out_size is the desired result size in pixels, either absolute or per blurhash
+        component (this is the default).
+        By default, this function will return the image as linear RGB, ready for further
+        scaling operations. If you want to display the image directly, set return_linear
+        to False.
+        Returns the decoded blurhash image as a three-dimensional list: [height][width][3],
+        with the last dimension being RGB colours.
+        For further info and tips for advanced usage, refer to the documentation for the
+        blurhash module: https://github.com/halcy/blurhash-python
+        """
+        if not IMPL_HAS_BLURHASH:
+            raise NotImplementedError(
+                'To use the blurhash functions, please install the blurhash Python module.')
+        # Figure out what size to decode to
+        decode_components_x, decode_components_y = blurhash.components(media_dict["blurhash"])
+        if size_per_component:
+            decode_size_x = decode_components_x * out_size[0]
+            decode_size_y = decode_components_y * out_size[1]
+        else:
+            decode_size_x = out_size[0]
+            decode_size_y = out_size[1]
+        # Decode
+        decoded_image = blurhash.decode(media_dict["blurhash"], decode_size_x, decode_size_y, linear=return_linear)
+        # And that's pretty much it.
+        return decoded_image
+    ###
+    # Pagination
+    ###
+    def fetch_next(self, previous_page):
+        """
+        Fetches the next page of results of a paginated request. Pass in the
+        previous page in its entirety, or the pagination information dict
+        returned as a part of that pages last status ('_pagination_next').
+        Returns the next page or None if no further data is available.
+        """
+        if isinstance(previous_page, list) and len(previous_page) != 0:
+            if hasattr(previous_page, '_pagination_next'):
+                params = copy.deepcopy(previous_page._pagination_next)
+            else:
+                return None
+        else:
+            params = copy.deepcopy(previous_page)
+        method = params['_pagination_method']
+        del params['_pagination_method']
+        endpoint = params['_pagination_endpoint']
+        del params['_pagination_endpoint']
+        return self.__api_request(method, endpoint, params)
+    def fetch_previous(self, next_page):
+        """
+        Fetches the previous page of results of a paginated request. Pass in the
+        previous page in its entirety, or the pagination information dict
+        returned as a part of that pages first status ('_pagination_prev').
+        Returns the previous page or None if no further data is available.
+        """
+        if isinstance(next_page, list) and len(next_page) != 0:
+            if hasattr(next_page, '_pagination_prev'):
+                params = copy.deepcopy(next_page._pagination_prev)
+            else:
+                return None
+        else:
+            params = copy.deepcopy(next_page)
+        method = params['_pagination_method']
+        del params['_pagination_method']
+        endpoint = params['_pagination_endpoint']
+        del params['_pagination_endpoint']
+        return self.__api_request(method, endpoint, params)
+    def fetch_remaining(self, first_page):
+        """
+        Fetches all the remaining pages of a paginated request starting from a
+        first page and returns the entire set of results (including the first page
+        that was passed in) as a big list.
+        Be careful, as this might generate a lot of requests, depending on what you are
+        fetching, and might cause you to run into rate limits very quickly.
+        """
+        first_page = copy.deepcopy(first_page)
+        all_pages = []
+        current_page = first_page
+        while current_page is not None and len(current_page) > 0:
+            all_pages.extend(current_page)
+            current_page = self.fetch_next(current_page)
+        return all_pages