cocorum.servicephp

The primary use from this module is the ServicePHP class, a wrapper for Rumble's internal service.php API. Login is performed via this API, as well as most Rumble functions other than chat messaging and video upload. All other classes are supporting sub-classes.

Service.PHP interactions

Control Rumble via Service.PHP S.D.G.

APIComment

Bases: JSONObj

A comment on a video as returned by a successful attempt to make it

Source code in cocorum/servicephp.py

class APIComment(JSONObj):
    """A comment on a video as returned by a successful attempt to make it"""
    def __init__(self, jsondata):
        """A comment on a video as returned by a successful attempt to make it

    Args:
        jsondata (dict): The JSON block for a single comment.
        """

        super().__init__(jsondata)

        #Badges of the user who commented if we have them
        if self.get("comment_user_badges"):
            self.user_badges = {slug : APIUserBadge(slug, data) for slug, data in self["comment_user_badges"].items()}

    def __int__(self):
        """The comment in integer form (its ID)"""
        return self.comment_id

    def __str__(self):
        """The comment as a string (its text)"""
        return self.text

    def __eq__(self, other):
        """Determine if this comment is equal to another

    Args:
        other (int, str, APIComment): Object to compare to.

    Returns:
        Comparison (bool, None): Did it fit the criteria?
        """

        #Check for direct matches first
        if isinstance(other, int):
            return self.comment_id_b10 == other
        if isinstance(other, str):
            return str(self) == other

        #Check for object attributes to match to
        if hasattr(other, "comment_id"):
            return self.comment_id_b10 == utils.ensure_b10(other.comment_id)

        #Check conversion to integer last
        if hasattr(other, "__int__"):
            return self.comment_id_b10 == int(other)

    @property
    def comment_id(self):
        """The numeric ID of the comment"""
        return int(self["comment_id"])

    @property
    def comment_id_b10(self):
        """The base 10 ID of the comment"""
        return self.comment_id

    @property
    def comment_id_b36(self):
        """The base 36 ID of the comment"""
        return utils.base_10_to_36(self.comment_id)

    @property
    def text(self):
        """The text of the comment"""
        return self["comment_text"]

    @property
    def user_display(self):
        """The display name of the user who commented"""
        return self["comment_user_display"]

    @property
    def tree_size(self):
        """TODO"""
        return self["comment_tree_size"]

comment_id property

The numeric ID of the comment

comment_id_b10 property

The base 10 ID of the comment

comment_id_b36 property

The base 36 ID of the comment

text property

The text of the comment

tree_size property

TODO

user_display property

The display name of the user who commented

__eq__(other)

Determine if this comment is equal to another

Parameters:

Name	Type	Description	Default
other	(int, str, APIComment)	Object to compare to.	required

Returns:

Name	Type	Description
Comparison	(bool, None)	Did it fit the criteria?

Source code in cocorum/servicephp.py

def __eq__(self, other):
    """Determine if this comment is equal to another

Args:
    other (int, str, APIComment): Object to compare to.

Returns:
    Comparison (bool, None): Did it fit the criteria?
    """

    #Check for direct matches first
    if isinstance(other, int):
        return self.comment_id_b10 == other
    if isinstance(other, str):
        return str(self) == other

    #Check for object attributes to match to
    if hasattr(other, "comment_id"):
        return self.comment_id_b10 == utils.ensure_b10(other.comment_id)

    #Check conversion to integer last
    if hasattr(other, "__int__"):
        return self.comment_id_b10 == int(other)

__init__(jsondata)

A comment on a video as returned by a successful attempt to make it

Parameters:

Name	Type	Description	Default
jsondata	dict	The JSON block for a single comment.	required

Source code in cocorum/servicephp.py

def __init__(self, jsondata):
    """A comment on a video as returned by a successful attempt to make it

Args:
    jsondata (dict): The JSON block for a single comment.
    """

    super().__init__(jsondata)

    #Badges of the user who commented if we have them
    if self.get("comment_user_badges"):
        self.user_badges = {slug : APIUserBadge(slug, data) for slug, data in self["comment_user_badges"].items()}

__int__()

The comment in integer form (its ID)

Source code in cocorum/servicephp.py

def __int__(self):
    """The comment in integer form (its ID)"""
    return self.comment_id

__str__()

The comment as a string (its text)

Source code in cocorum/servicephp.py

def __str__(self):
    """The comment as a string (its text)"""
    return self.text

APIContentVotes

Bases: JSONObj

Votes made on content

Source code in cocorum/servicephp.py

class APIContentVotes(JSONObj):
    """Votes made on content"""
    def __int__(self):
        """The integer form of the content votes"""
        return self.score

    def __str__(self):
        """The string form of the content votes"""
        return self.score_formatted

    def __eq__(self, other):
        """Determine if this content votes is equal to another

    Args:
        other (int, str, APIContentVotes): Object to compare to.

    Returns:
        Comparison (bool, None): Did it fit the criteria?
        """

        #Check for direct matches first
        if isinstance(other, int):
            return self.score == other
        if isinstance(other, str):
            return other in (str(self.score), self.score_formatted)

        #Check for object attributes to match to
        if hasattr(other, "score"):
            #if hasattr(other, "content_id") and hasattr(other, "content_type"):
            #    return self.score, self.content_id, self.content_type == other.score, other.content_id, other.content_type
            return self.score == other.score

        #Check conversion to integer last
        if hasattr(other, "__int__"):
            return self.score == int(other)

    @property
    def num_votes_up(self):
        """Upvotes on the content"""
        return self._jsondata.get("num_votes_up", 0)

    @property
    def num_votes_down(self):
        """Downvotes on the content"""
        return self._jsondata.get("num_votes_down", 0)

    @property
    def score(self):
        """Summed score of the content"""
        return self["score"]

    @property
    def votes(self):
        """The total number of votes on the content"""
        if not self["votes"]:
            return 0
        return self["votes"]

    @property
    def num_votes_up_formatted(self):
        """The upvotes on the content, formatted into a string"""
        return self._jsondata.get("num_votes_up_formatted", "0")

    @property
    def num_votes_down_formatted(self):
        """The downvotes on the content, formatted into a string"""
        return self._jsondata.get("num_votes_down_formatted", "0")

    @property
    def score_formatted(self):
        """The total votes on the content, formatted into a string"""
        return self._jsondata.get("score_formatted", "0")

    @property
    def content_type(self):
        """The type of content being voted on"""
        return self["content_type"]

    @property
    def content_id(self):
        """The numerical ID of the content being voted on"""
        return self["content_id"]

content_id property

The numerical ID of the content being voted on

content_type property

The type of content being voted on

num_votes_down property

Downvotes on the content

num_votes_down_formatted property

The downvotes on the content, formatted into a string

num_votes_up property

Upvotes on the content

num_votes_up_formatted property

The upvotes on the content, formatted into a string

score property

Summed score of the content

score_formatted property

The total votes on the content, formatted into a string

votes property

The total number of votes on the content

__eq__(other)

Determine if this content votes is equal to another

Parameters:

Name	Type	Description	Default
other	(int, str, APIContentVotes)	Object to compare to.	required

Returns:

Name	Type	Description
Comparison	(bool, None)	Did it fit the criteria?

Source code in cocorum/servicephp.py

def __eq__(self, other):
    """Determine if this content votes is equal to another

Args:
    other (int, str, APIContentVotes): Object to compare to.

Returns:
    Comparison (bool, None): Did it fit the criteria?
    """

    #Check for direct matches first
    if isinstance(other, int):
        return self.score == other
    if isinstance(other, str):
        return other in (str(self.score), self.score_formatted)

    #Check for object attributes to match to
    if hasattr(other, "score"):
        #if hasattr(other, "content_id") and hasattr(other, "content_type"):
        #    return self.score, self.content_id, self.content_type == other.score, other.content_id, other.content_type
        return self.score == other.score

    #Check conversion to integer last
    if hasattr(other, "__int__"):
        return self.score == int(other)

__int__()

The integer form of the content votes

Source code in cocorum/servicephp.py

def __int__(self):
    """The integer form of the content votes"""
    return self.score

__str__()

The string form of the content votes

Source code in cocorum/servicephp.py

def __str__(self):
    """The string form of the content votes"""
    return self.score_formatted

APIPlaylist

Bases: JSONObj

Playlist as returned by the API

Source code in cocorum/servicephp.py

class APIPlaylist(JSONObj):
    """Playlist as returned by the API"""
    def __init__(self, jsondata):
        """Playlist as returned by the API.

    Args:
        jsondata (dict): The JSON data block of a playlist.
        """

        super().__init__(jsondata)
        self.user = APIUser(jsondata["user"])

    def __int__(self):
        """The playlist as an integer (it's ID in base 10)"""
        return self.playlist_id_b10

    def __str__(self):
        """The playlist as a string (it's ID in base 36)"""
        return self.playlist_id_b36

    def __eq__(self, other):
        """Determine if this playlist is equal to another.

    Args:
        other (int, str, APIPlaylist): Object to compare to.

    Returns:
        Comparison (bool, None): Did it fit the criteria?
        """

        #Check for direct matches first
        if isinstance(other, int):
            return self.playlist_id_b10 == other
        if isinstance(other, str):
            return str(other) == self.playlist_id_b36

        #Check for object attributes to match to
        if hasattr(other, "playlist_id"):
            return self.playlist_id_b10 == utils.ensure_b10(other.playlist_id)

        #Check conversion to integer last, in case another ID or something happens to match
        if hasattr(other, "__int__"):
            return self.playlist_id_b10 == int(other)

    @property
    def playlist_id(self):
        """The numeric playlist ID in base 36"""
        return self["id"]

    @property
    def playlist_id_b36(self):
        """The numeric ID of the playlist in base 36"""
        return self.playlist_id

    @property
    def playlist_id_b10(self):
        """The numeric ID of the playlist in base 10"""
        return utils.base_36_to_10(self.playlist_id)

    @property
    def title(self):
        """The title of the playlist"""
        return self["title"]

    @property
    def description(self):
        """The description of the playlist"""
        return self["description"]

    @property
    def visibility(self):
        """The visibility of the playlist"""
        return self["visibility"]

    @property
    def url(self):
        """The URL of the playlist"""
        return self["url"]

    @property
    def channel(self):
        """The channel the playlist is under, can be None"""
        return self["channel"]

    @property
    def created_on(self):
        """The time the playlist was created in seconds since epoch"""
        return utils.parse_timestamp(self["created_on"])

    @property
    def updated_on(self):
        """The time the playlist was last updated in seconds since epoch"""
        return utils.parse_timestamp(self["updated_on"])

    @property
    def permissions(self):
        """The permissions the ServicePHP user has on this playlist"""
        return self["permissions"]

    @property
    def num_items(self):
        """The number of items in the playlist"""
        return self["num_items"]

    @property
    def is_following(self):
        """TODO -> Bool"""
        return self["is_following"]

    @property
    def items(self):
        """The items of the playlist. TODO"""
        return self["items"]

    @property
    def extra(self):
        """TODO -> None, unknown"""
        return self["extra"]

channel property

The channel the playlist is under, can be None

created_on property

The time the playlist was created in seconds since epoch

description property

The description of the playlist

extra property

TODO -> None, unknown

is_following property

TODO -> Bool

items property

The items of the playlist. TODO

num_items property

The number of items in the playlist

permissions property

The permissions the ServicePHP user has on this playlist

playlist_id property

The numeric playlist ID in base 36

playlist_id_b10 property

The numeric ID of the playlist in base 10

playlist_id_b36 property

The numeric ID of the playlist in base 36

title property

The title of the playlist

updated_on property

The time the playlist was last updated in seconds since epoch

url property

The URL of the playlist

visibility property

The visibility of the playlist

__eq__(other)

Determine if this playlist is equal to another.

Parameters:

Name	Type	Description	Default
other	(int, str, APIPlaylist)	Object to compare to.	required

Returns:

Name	Type	Description
Comparison	(bool, None)	Did it fit the criteria?

Source code in cocorum/servicephp.py

def __eq__(self, other):
    """Determine if this playlist is equal to another.

Args:
    other (int, str, APIPlaylist): Object to compare to.

Returns:
    Comparison (bool, None): Did it fit the criteria?
    """

    #Check for direct matches first
    if isinstance(other, int):
        return self.playlist_id_b10 == other
    if isinstance(other, str):
        return str(other) == self.playlist_id_b36

    #Check for object attributes to match to
    if hasattr(other, "playlist_id"):
        return self.playlist_id_b10 == utils.ensure_b10(other.playlist_id)

    #Check conversion to integer last, in case another ID or something happens to match
    if hasattr(other, "__int__"):
        return self.playlist_id_b10 == int(other)

__init__(jsondata)

Playlist as returned by the API.

Parameters:

Name	Type	Description	Default
jsondata	dict	The JSON data block of a playlist.	required

Source code in cocorum/servicephp.py

def __init__(self, jsondata):
    """Playlist as returned by the API.

Args:
    jsondata (dict): The JSON data block of a playlist.
    """

    super().__init__(jsondata)
    self.user = APIUser(jsondata["user"])

__int__()

The playlist as an integer (it's ID in base 10)

Source code in cocorum/servicephp.py

def __int__(self):
    """The playlist as an integer (it's ID in base 10)"""
    return self.playlist_id_b10

__str__()

The playlist as a string (it's ID in base 36)

Source code in cocorum/servicephp.py

def __str__(self):
    """The playlist as a string (it's ID in base 36)"""
    return self.playlist_id_b36

APIUser

Bases: JSONObj

User data as returned by the API

Source code in cocorum/servicephp.py

class APIUser(JSONObj):
    """User data as returned by the API"""
    def __init__(self, jsondata):
        """User data as returned by the API.

    Args:
        jsondata (dict): The JSON data block of a single user.
        """

        super().__init__(jsondata)

        #Our profile picture data
        self.__picture = None

    def __int__(self):
        """The user as an integer (it's ID in base 10)"""
        return self.user_id_b10

    def __eq__(self, other):
        """Determine if this user is equal to another.

    Args:
        other (int, str, APIUser): Object to compare to.

    Returns:
        Comparison (bool, None): Did it fit the criteria?
        """

        #Check for direct matches first
        if isinstance(other, int):
            return self.user_id_b10 == other
        if isinstance(other, str):
            return str(other) in (self.user_id_b36, self.username)

        #Check for object attributes to match to
        if hasattr(other, "user_id"):
            return self.user_id_b10 == utils.ensure_b10(other.user_id)

        #Check conversion to integer last, in case another ID or something happens to match
        if hasattr(other, "__int__"):
            return self.user_id_b10 == int(other)

    @property
    def user_id(self):
        """The numeric ID of the user in base 10"""
        return self["id"]

    @property
    def user_id_b10(self):
        """The numeric ID of the user in base 10"""
        return self.user_id

    @property
    def user_id_b36(self):
        """The numeric ID of the user in base 36"""
        return utils.base_10_to_36(self.user_id)

    @property
    def username(self):
        """The username of the user"""
        return self["username"]

    @property
    def picture_url(self):
        """The URL of the user's profile picture"""
        return self["picture"]

    @property
    def picture(self):
        """The user's profile picture as a bytes string"""
        if not self.picture_url: #The profile picture is blank
            return b''

        if not self.__picture: #We never queried the profile pic before
            response = requests.get(self.picture_url, timeout = static.Delays.request_timeout)
            assert response.status_code == 200, "Status code " + str(response.status_code)

            self.__picture = response.content

        return self.__picture

    @property
    def verified_badge(self):
        """Is the user verified?"""
        return self["verified_badge"]

    @property
    def followers(self):
        """The number of followers this user has"""
        return self["followers"]

    @property
    def followed(self):
        """TODO -> Bool"""
        return self["followed"]

followed property

TODO -> Bool

followers property

The number of followers this user has

picture property

The user's profile picture as a bytes string

picture_url property

The URL of the user's profile picture

user_id property

The numeric ID of the user in base 10

user_id_b10 property

The numeric ID of the user in base 10

user_id_b36 property

The numeric ID of the user in base 36

username property

The username of the user

verified_badge property

Is the user verified?

__eq__(other)

Determine if this user is equal to another.

Parameters:

Name	Type	Description	Default
other	(int, str, APIUser)	Object to compare to.	required

Returns:

Name	Type	Description
Comparison	(bool, None)	Did it fit the criteria?

Source code in cocorum/servicephp.py

def __eq__(self, other):
    """Determine if this user is equal to another.

Args:
    other (int, str, APIUser): Object to compare to.

Returns:
    Comparison (bool, None): Did it fit the criteria?
    """

    #Check for direct matches first
    if isinstance(other, int):
        return self.user_id_b10 == other
    if isinstance(other, str):
        return str(other) in (self.user_id_b36, self.username)

    #Check for object attributes to match to
    if hasattr(other, "user_id"):
        return self.user_id_b10 == utils.ensure_b10(other.user_id)

    #Check conversion to integer last, in case another ID or something happens to match
    if hasattr(other, "__int__"):
        return self.user_id_b10 == int(other)

__init__(jsondata)

User data as returned by the API.

Parameters:

Name	Type	Description	Default
jsondata	dict	The JSON data block of a single user.	required

Source code in cocorum/servicephp.py

def __init__(self, jsondata):
    """User data as returned by the API.

Args:
    jsondata (dict): The JSON data block of a single user.
    """

    super().__init__(jsondata)

    #Our profile picture data
    self.__picture = None

__int__()

The user as an integer (it's ID in base 10)

Source code in cocorum/servicephp.py

def __int__(self):
    """The user as an integer (it's ID in base 10)"""
    return self.user_id_b10

APIUserBadge

Bases: JSONObj

A badge of a user as returned by the API

Source code in cocorum/servicephp.py

class APIUserBadge(JSONObj):
    """A badge of a user as returned by the API"""
    def __init__(self, slug, jsondata):
        """A badge of a user as returned by the API.

    Args:
        slug (str): The string identifier of the badge.
        jsondata (dict): The JSON data block of the badge.
        """

        super().__init__(jsondata)
        self.slug = slug #The unique identification for this badge
        self.__icon = None

    def __eq__(self, other):
        """Check if this badge is equal to another.

    Args:
        other (str, APIUserBadge): Object to compare to.

    Returns:
        Comparison (bool, None): Did it fit the criteria?
        """

        #Check if the string is either our slug or our label in any language
        if isinstance(other, str):
            return other in (self.slug, self.label.values())

        #Check if the compared object has the same slug, if it has one
        if hasattr(other, "slug"):
            return self.slug == other.slug

    def __str__(self):
        """The chat user badge in string form (its slug)"""
        return self.slug

    @property
    def label(self):
        """A dictionary of lang:label pairs"""
        return self["label"]

    @property
    def icon_url(self):
        """The URL of the badge's icon"""
        return static.URI.rumble_base + self["icons"][static.Misc.badge_icon_size]

    @property
    def icon(self):
        """The badge's icon as a bytestring"""
        if not self.__icon: #We never queried the icon before
            response = requests.get(self.icon_url, timeout = static.Delays.request_timeout)
            assert response.status_code == 200, "Status code " + str(response.status_code)

            self.__icon = response.content

        return self.__icon

icon property

The badge's icon as a bytestring

icon_url property

The URL of the badge's icon

label property

A dictionary of lang:label pairs

__eq__(other)

Check if this badge is equal to another.

Parameters:

Name	Type	Description	Default
other	(str, APIUserBadge)	Object to compare to.	required

Returns:

Name	Type	Description
Comparison	(bool, None)	Did it fit the criteria?

Source code in cocorum/servicephp.py

def __eq__(self, other):
    """Check if this badge is equal to another.

Args:
    other (str, APIUserBadge): Object to compare to.

Returns:
    Comparison (bool, None): Did it fit the criteria?
    """

    #Check if the string is either our slug or our label in any language
    if isinstance(other, str):
        return other in (self.slug, self.label.values())

    #Check if the compared object has the same slug, if it has one
    if hasattr(other, "slug"):
        return self.slug == other.slug

__init__(slug, jsondata)

A badge of a user as returned by the API.

Parameters:

Name	Type	Description	Default
slug	str	The string identifier of the badge.	required
jsondata	dict	The JSON data block of the badge.	required

Source code in cocorum/servicephp.py

def __init__(self, slug, jsondata):
    """A badge of a user as returned by the API.

Args:
    slug (str): The string identifier of the badge.
    jsondata (dict): The JSON data block of the badge.
    """

    super().__init__(jsondata)
    self.slug = slug #The unique identification for this badge
    self.__icon = None

__str__()

The chat user badge in string form (its slug)

Source code in cocorum/servicephp.py

def __str__(self):
    """The chat user badge in string form (its slug)"""
    return self.slug

ServicePHP

Interact with Rumble's service.php API

Source code in cocorum/servicephp.py

class ServicePHP:
    """Interact with Rumble's service.php API"""
    def __init__(self, username: str, password: str = None, session = None):
        """Interact with Rumble's service.php API.

    Args:
        username (str): The username we will be under.
        password (str): The password to use at login.
            Defaults to using the session token/cookie instead.
        session (str, dict): The session token or cookie dict to authenticate with.
            Defaults to using the password instead.
            """

        #Save the username
        self.username = username

        #Session is the token directly
        if isinstance(session, str):
            self.session_cookie = {static.Misc.session_token_key, session}

        #Session is a cookie dict
        elif isinstance(session, dict):
            assert session.get(static.Misc.session_token_key), f"Session cookie dict must have '{static.Misc.session_token_key}' as key."
            self.session_cookie = session

        #Session was passed but it is not anything we can use
        elif session is not None:
            raise ValueError(f"Session must be a token str or cookie dict, got {type(session)}")

        #Session was not passed, but credentials were
        elif username and password:
            self.session_cookie = self.login(username, password)

        #Neither session nor credentials were passed:
        else:
            raise ValueError("Must pass either userame and password, or a session token")

        assert utils.test_session_cookie(self.session_cookie), "Session cookie is invalid."

        #Stored ID of the logged in user
        self.__user_id = None

    @property
    def user_id(self):
        """The numeric ID of the logged in user in base 10"""
        #We do not have a user ID, extract it from the unread notifications response
        if self.__user_id is None:
            j = self.sphp_request(
                "user.has_unread_notifications",
                method = "GET",
                ).json()
            self.__user_id = utils.base_36_to_10(j["user"]["id"].removeprefix("_"))

        return self.__user_id

    @property
    def user_id_b10(self):
        """The numeric ID of the logged in user in base 10"""
        return self.user_id

    @property
    def user_id_b36(self):
        """The numeric ID of the logged in user in base 36"""
        return utils.base_10_to_36(self.user_id)

    def sphp_request(self, service_name: str, data: dict = {}, additional_params: dict = {}, logged_in = True, method = "POST"):
        """Make a request to Service.PHP with common settings
        service_name: The name parameter of the specific PHP service
        data: Form data
        additional_params: Any additional query string parameters
        logged_in: The request should use the session cookie"""
        params = {"name" : service_name}
        params.update(additional_params)
        r = requests.request(
                method,
                static.URI.servicephp,
                params = params,
                data = data,
                headers = static.RequestHeaders.user_agent,
                cookies = self.session_cookie if logged_in else None,
                timeout = static.Delays.request_timeout,
                )
        assert r.status_code == 200, f"Service.PHP request for {service_name} failed: {r}\n{r.text}"
        #If the request json has a data -> success value, make sure it is True
        d = r.json().get("data")
        if isinstance(d, dict):
            assert d.get("success", True), f"Service.PHP request for {service_name} failed: \n{r.text}"
        #Data was not a dict but was not empty
        elif d:
            print(f"Service.PHP request for {service_name} did not fail but returned unknown data type {type(d)}: {d}")

        return r

    def login(self, username: str, password: str):
        """Log in to Rumble

    Args:
        username (str): Username to sign in with.
        password (str): Password to sign in with.

    Returns:
        Cookie (dict): Cookie dict to be passed with requests, which authenticates them.
        """

        #Get salts
        r = self.sphp_request(
                "user.get_salts",
                data = {"username": username},
                logged_in = False,
                )
        salts = r.json()["data"]["salts"]

        #Get session token
        r = self.sphp_request(
                "user.login",
                data = {
                    "username": username,

                    #Hash the password using the salts
                    "password_hashes": ",".join(utils.calc_password_hashes(password, salts)),
                    },
                logged_in = False,
                )
        j = r.json()
        session_token = j["data"]["session"]
        assert session_token, f"Login failed: No token returned\n{r.json()}"

        return {static.Misc.session_token_key: session_token}

    def chat_pin(self, stream_id, message, unpin: bool = False):
        """Pin or unpin a message in a chat.

    Args:
        stream_id (int, str): ID of the stream in base 10 or 36.
        message (int): Converting this to int must return a chat message ID.
        unpin (bool): If true, unpins a message instead of pinning it.
        """

        self.sphp_request(
            f"chat.message.{"un" * unpin}pin",
            data = {
                "video_id": utils.ensure_b10(stream_id),
                "message_id": int(message),
                },
            )

    def mute_user(self, username: str, is_channel: bool = False, video: int = None, duration: int = None, total: bool = False):
        """Mute a user or channel by name.

    Args:
        username (str): The user to mute.
        is_channel (bool): Is this a channel name rather than a username?
        video (int): The video to mute the user on.
            Defaults to None.
        duration (int): How long the user will be muted for, in seconds.
            Defaults to infinity.
        total (bool): Is this a mute across all videos?
            Defaults to False, requires video if False.
            """

        self.sphp_request(
            "moderation.mute",
            data = {
                "user_to_mute": username,
                "entity_type": ("user", "channel")[is_channel],
                "video": int(video),
                "duration": duration,
                "type": ("video", "total")[total],
                },
            )

    def unmute_user(self, record_id: int):
        """Unmute a user.

    Args:
        record_id: The numeric ID of the mute record to undo.
        """

        self.sphp_request(
            "moderation.unmute",
            data = {
                "record_id" : record_id,
                }
            )

    def _is_comment_elem(self, e):
        """Check if a beautifulsoup element is a comment.

    Args:
        e (bs4.Tag): The BeautifulSoup element to test.

    Returns:
        Result (bool): Did the element fit the criteria for being a comment?
        """

        return e.name == "li" and "comment-item" in e.get("class") and "comments-create" not in e.get("class")

    def comment_list(self, video_id):
        """Get the list of comments under a video.

    Args:
        video_id (str, int): The numeric ID of a video in base 10 or 36.

    Returns:
        Comments (list): A list of scraping.HTMLComment objects.
        """

        r = self.sphp_request(
            "comment.list",
            additional_params = {
                "video" : utils.ensure_b36(video_id),
                },
            method = "GET",
            )
        soup = bs4.BeautifulSoup(r.json()["html"], features = "html.parser")
        comment_elems = soup.find_all(self._is_comment_elem)
        return [scraping.HTMLComment(e) for e in comment_elems]

    def comment_add(self, video_id, comment: str, reply_id: int = 0):
        """Post a comment on a video.

    Args:
        video_id (int, str): The numeric ID of a video / stream in base 10 or 36.
        comment (str): What to say.
        reply_id (int): The ID of the comment to reply to.
            Defaults to zero (don't reply to anybody).

    Returns:
        Comment (APIComment): The comment, as parsed from the response data.
        """

        r = self.sphp_request(
                "comment.add",
                data = {
                    "video": int(utils.ensure_b10(video_id)),
                    "reply_id": int(reply_id),
                    "comment": str(comment),
                    "target": "comment-create-1",
                    },
                )
        return APIComment(r.json()["data"])

    def comment_pin(self, comment_id: int, unpin: bool = False):
        """Pin or unpin a comment by ID.

    Args:
        comment_id (int): The numeric ID of the comment to pin/unpin.
        unpin (bool): If true, unpins instead of pinning comment.
        """

        self.sphp_request(
            f"comment.{"un" * unpin}pin",
            data = {"comment_id": int(comment_id)},
            )

    def comment_delete(self, comment_id: int):
        """Delete a comment by ID.

    Args:
        comment_id (int): The numeric ID of the comment to delete.
        """

        self.sphp_request(
            "comment.delete",
            data = {"comment_id": int(comment_id)},
            )

    def comment_restore(self, comment_id: int):
        """Restore a deleted comment by ID.

    Args:
        comment_id (int): The numeric ID of the comment to restore.
        """

        r = self.sphp_request(
            "comment.restore",
            data = {"comment_id": int(comment_id)},
            )
        return APIComment(r.json()["data"])

    def rumbles(self, vote: int, item_id, item_type: int):
        """Post a like or dislike.

    Args:
        vote (int): -1, 0, or 1 (0 means clear vote).
        item_id (int): The numeric ID of whatever we are liking or disliking.
        item_type (int): 1 for video, 2 for comment.
        """

        r = self.sphp_request(
            "user.rumbles",
            data = {
                "type" : int(item_type),
                "id" : utils.ensure_b10(item_id),
                "vote" : int(vote),
                },
            )
        return APIContentVotes(r.json()["data"])

    def get_video_url(self, video_id):
        """Get the URL of a Rumble video.

    Args:
        video_id (int, str): The numeric ID of the video.

    Returns:
        URL (str): The URL of the video.
        """

        r = self.sphp_request(
            "media.share",
            additional_params = {
                "video" : utils.ensure_b36(video_id),
                "start" : 0,
                },
            method = "GET",
            )
        soup = bs4.BeautifulSoup(r.json()["html"], features = "html.parser")
        elem = soup.find("div", attrs = {"class" : "fb-share-button share-fb"})
        return elem.attrs["data-url"]

    def playlist_add_video(self, playlist_id: str, video_id):
        """Add a video to a playlist.

    Args:
        playlist_id (str): The numeric ID of the playlist in base 36.
        video_id (int, str): The numeric ID of the video to add, in base 10 or 36.
        """

        print(self.sphp_request(
            "playlist.add_video",
            data = {
                "playlist_id": str(playlist_id),
                "video_id": utils.ensure_b10(video_id),
                }
            ).text)

    def playlist_delete_video(self, playlist_id: str, video_id: int):
        """Remove a video from a playlist.

    Args:
        playlist_id (str): The numeric ID of the playlist in base 36.
        video_id (int, str): The numeric ID of the video to remove, in base 10 or 36.
        """

        print(self.sphp_request(
            "playlist.delete_video",
            data = {
                "playlist_id": str(playlist_id),
                "video_id": utils.ensure_b10(video_id),
                }
            ).text)

    def playlist_add(self, title: str, description: str = "", visibility: str = "public", channel_id = None):
        """Create a new playlist.

    Args:
        title (str): The title of the playlist.
        description (str): Describe the playlist.
            Defaults to nothing.
        visibility (str): Set to public, unlisted, or private via string.
            Defaults to 'public'.
        channel_id (int, str): The ID of the channel to create the playlist under.
            Defaults to none.

    Returns:
        Playlist (APIPlaylist): The playlist as parsed from the response data.
        """

        r = self.sphp_request(
            "playlist.add",
            data = {
                "title": str(title),
                "description": str(description),
                "visibility": str(visibility),
                "channel_id": str(utils.ensure_b10(channel_id)) if channel_id else None,
            }
        )
        return APIPlaylist(r.json()["data"])

    def playlist_edit(self, playlist_id: str, title: str, description: str = "", visibility: str = "public", channel_id = None):
        """Edit the details of an existing playlist

    Args:
        playlist_id (str): The numeric ID of the playlist to edit in base 36.
        title (str): The title of the playlist.
        description (str): Describe the playlist.
            Defaults to nothing.
        visibility (str): Set to public, unlisted, or private via string.
            Defaults to 'public'.
        channel_id (int, str): The ID of the channel to create the playlist under.
            Defaults to none.

    Returns:
        Playlist (APIPlaylist): The playlist as parsed from the response data.
        """

        r = self.sphp_request(
            "playlist.edit",
            data = {
                "title": str(title),
                "description": str(description),
                "visibility": str(visibility),
                "channel_id": str(utils.ensure_b10(channel_id)) if channel_id else None,
                "playlist_id": utils.ensure_b36(playlist_id),
            }
        )
        return APIPlaylist(r.json()["data"])

    def playlist_delete(self, playlist_id: str):
        """Delete a playlist.

    Args:
        playlist_id (str): The numeric ID of the playlist to delete in base 36.
        """

        print(self.sphp_request(
            "playlist.delete",
            data = {"playlist_id" : utils.ensure_b36(playlist_id)},
            ).text)

    def raid_confirm(self, stream_id):
        """Confirm a raid, previously set up by command.

    Args:
        stream_id (int, str): The numeric ID of the stream to confirm the raid from, in base 10 or 36.
        """

        self.sphp_request(
            "raid.confirm",
            data = {"video_id" : utils.ensure_b10(stream_id)},
            )

user_id property

The numeric ID of the logged in user in base 10

user_id_b10 property

The numeric ID of the logged in user in base 10

user_id_b36 property

The numeric ID of the logged in user in base 36

__init__(username, password=None, session=None)

Interact with Rumble's service.php API.

Parameters:

Name	Type	Description	Default
username	str	The username we will be under.	required
password	str	The password to use at login. Defaults to using the session token/cookie instead.	None
session	(str, dict)	The session token or cookie dict to authenticate with. Defaults to using the password instead.	None

Source code in cocorum/servicephp.py

def __init__(self, username: str, password: str = None, session = None):
    """Interact with Rumble's service.php API.

Args:
    username (str): The username we will be under.
    password (str): The password to use at login.
        Defaults to using the session token/cookie instead.
    session (str, dict): The session token or cookie dict to authenticate with.
        Defaults to using the password instead.
        """

    #Save the username
    self.username = username

    #Session is the token directly
    if isinstance(session, str):
        self.session_cookie = {static.Misc.session_token_key, session}

    #Session is a cookie dict
    elif isinstance(session, dict):
        assert session.get(static.Misc.session_token_key), f"Session cookie dict must have '{static.Misc.session_token_key}' as key."
        self.session_cookie = session

    #Session was passed but it is not anything we can use
    elif session is not None:
        raise ValueError(f"Session must be a token str or cookie dict, got {type(session)}")

    #Session was not passed, but credentials were
    elif username and password:
        self.session_cookie = self.login(username, password)

    #Neither session nor credentials were passed:
    else:
        raise ValueError("Must pass either userame and password, or a session token")

    assert utils.test_session_cookie(self.session_cookie), "Session cookie is invalid."

    #Stored ID of the logged in user
    self.__user_id = None

chat_pin(stream_id, message, unpin=False)

Pin or unpin a message in a chat.

Parameters:

Name	Type	Description	Default
stream_id	(int, str)	ID of the stream in base 10 or 36.	required
message	int	Converting this to int must return a chat message ID.	required
unpin	bool	If true, unpins a message instead of pinning it.	False

Source code in cocorum/servicephp.py

def chat_pin(self, stream_id, message, unpin: bool = False):
    """Pin or unpin a message in a chat.

Args:
    stream_id (int, str): ID of the stream in base 10 or 36.
    message (int): Converting this to int must return a chat message ID.
    unpin (bool): If true, unpins a message instead of pinning it.
    """

    self.sphp_request(
        f"chat.message.{"un" * unpin}pin",
        data = {
            "video_id": utils.ensure_b10(stream_id),
            "message_id": int(message),
            },
        )

comment_add(video_id, comment, reply_id=0)

Post a comment on a video.

Parameters:

Name	Type	Description	Default
video_id	(int, str)	The numeric ID of a video / stream in base 10 or 36.	required
comment	str	What to say.	required
reply_id	int	The ID of the comment to reply to. Defaults to zero (don't reply to anybody).	0

Returns:

Name	Type	Description
Comment	APIComment	The comment, as parsed from the response data.

Source code in cocorum/servicephp.py

def comment_add(self, video_id, comment: str, reply_id: int = 0):
    """Post a comment on a video.

Args:
    video_id (int, str): The numeric ID of a video / stream in base 10 or 36.
    comment (str): What to say.
    reply_id (int): The ID of the comment to reply to.
        Defaults to zero (don't reply to anybody).

Returns:
    Comment (APIComment): The comment, as parsed from the response data.
    """

    r = self.sphp_request(
            "comment.add",
            data = {
                "video": int(utils.ensure_b10(video_id)),
                "reply_id": int(reply_id),
                "comment": str(comment),
                "target": "comment-create-1",
                },
            )
    return APIComment(r.json()["data"])

comment_delete(comment_id)

Delete a comment by ID.

Parameters:

Name	Type	Description	Default
comment_id	int	The numeric ID of the comment to delete.	required

Source code in cocorum/servicephp.py

def comment_delete(self, comment_id: int):
    """Delete a comment by ID.

Args:
    comment_id (int): The numeric ID of the comment to delete.
    """

    self.sphp_request(
        "comment.delete",
        data = {"comment_id": int(comment_id)},
        )

comment_list(video_id)

Get the list of comments under a video.

Parameters:

Name	Type	Description	Default
video_id	(str, int)	The numeric ID of a video in base 10 or 36.	required

Returns:

Name	Type	Description
Comments	list	A list of scraping.HTMLComment objects.

Source code in cocorum/servicephp.py

def comment_list(self, video_id):
    """Get the list of comments under a video.

Args:
    video_id (str, int): The numeric ID of a video in base 10 or 36.

Returns:
    Comments (list): A list of scraping.HTMLComment objects.
    """

    r = self.sphp_request(
        "comment.list",
        additional_params = {
            "video" : utils.ensure_b36(video_id),
            },
        method = "GET",
        )
    soup = bs4.BeautifulSoup(r.json()["html"], features = "html.parser")
    comment_elems = soup.find_all(self._is_comment_elem)
    return [scraping.HTMLComment(e) for e in comment_elems]

comment_pin(comment_id, unpin=False)

Pin or unpin a comment by ID.

Parameters:

Name	Type	Description	Default
comment_id	int	The numeric ID of the comment to pin/unpin.	required
unpin	bool	If true, unpins instead of pinning comment.	False

Source code in cocorum/servicephp.py

def comment_pin(self, comment_id: int, unpin: bool = False):
    """Pin or unpin a comment by ID.

Args:
    comment_id (int): The numeric ID of the comment to pin/unpin.
    unpin (bool): If true, unpins instead of pinning comment.
    """

    self.sphp_request(
        f"comment.{"un" * unpin}pin",
        data = {"comment_id": int(comment_id)},
        )

comment_restore(comment_id)

Restore a deleted comment by ID.

Parameters:

Name	Type	Description	Default
comment_id	int	The numeric ID of the comment to restore.	required

Source code in cocorum/servicephp.py

def comment_restore(self, comment_id: int):
    """Restore a deleted comment by ID.

Args:
    comment_id (int): The numeric ID of the comment to restore.
    """

    r = self.sphp_request(
        "comment.restore",
        data = {"comment_id": int(comment_id)},
        )
    return APIComment(r.json()["data"])

get_video_url(video_id)

Get the URL of a Rumble video.

Parameters:

Name	Type	Description	Default
video_id	(int, str)	The numeric ID of the video.	required

Returns:

Name	Type	Description
URL	str	The URL of the video.

Source code in cocorum/servicephp.py

def get_video_url(self, video_id):
    """Get the URL of a Rumble video.

Args:
    video_id (int, str): The numeric ID of the video.

Returns:
    URL (str): The URL of the video.
    """

    r = self.sphp_request(
        "media.share",
        additional_params = {
            "video" : utils.ensure_b36(video_id),
            "start" : 0,
            },
        method = "GET",
        )
    soup = bs4.BeautifulSoup(r.json()["html"], features = "html.parser")
    elem = soup.find("div", attrs = {"class" : "fb-share-button share-fb"})
    return elem.attrs["data-url"]

login(username, password)

Log in to Rumble

Parameters:

Name	Type	Description	Default
username	str	Username to sign in with.	required
password	str	Password to sign in with.	required

Returns:

Name	Type	Description
Cookie	dict	Cookie dict to be passed with requests, which authenticates them.

Source code in cocorum/servicephp.py

def login(self, username: str, password: str):
    """Log in to Rumble

Args:
    username (str): Username to sign in with.
    password (str): Password to sign in with.

Returns:
    Cookie (dict): Cookie dict to be passed with requests, which authenticates them.
    """

    #Get salts
    r = self.sphp_request(
            "user.get_salts",
            data = {"username": username},
            logged_in = False,
            )
    salts = r.json()["data"]["salts"]

    #Get session token
    r = self.sphp_request(
            "user.login",
            data = {
                "username": username,

                #Hash the password using the salts
                "password_hashes": ",".join(utils.calc_password_hashes(password, salts)),
                },
            logged_in = False,
            )
    j = r.json()
    session_token = j["data"]["session"]
    assert session_token, f"Login failed: No token returned\n{r.json()}"

    return {static.Misc.session_token_key: session_token}

mute_user(username, is_channel=False, video=None, duration=None, total=False)

Mute a user or channel by name.

Parameters:

Name	Type	Description	Default
username	str	The user to mute.	required
is_channel	bool	Is this a channel name rather than a username?	False
video	int	The video to mute the user on. Defaults to None.	None
duration	int	How long the user will be muted for, in seconds. Defaults to infinity.	None
total	bool	Is this a mute across all videos? Defaults to False, requires video if False.	False

Source code in cocorum/servicephp.py

def mute_user(self, username: str, is_channel: bool = False, video: int = None, duration: int = None, total: bool = False):
    """Mute a user or channel by name.

Args:
    username (str): The user to mute.
    is_channel (bool): Is this a channel name rather than a username?
    video (int): The video to mute the user on.
        Defaults to None.
    duration (int): How long the user will be muted for, in seconds.
        Defaults to infinity.
    total (bool): Is this a mute across all videos?
        Defaults to False, requires video if False.
        """

    self.sphp_request(
        "moderation.mute",
        data = {
            "user_to_mute": username,
            "entity_type": ("user", "channel")[is_channel],
            "video": int(video),
            "duration": duration,
            "type": ("video", "total")[total],
            },
        )

playlist_add(title, description='', visibility='public', channel_id=None)

Create a new playlist.

Parameters:

Name	Type	Description	Default
title	str	The title of the playlist.	required
description	str	Describe the playlist. Defaults to nothing.	''
visibility	str	Set to public, unlisted, or private via string. Defaults to 'public'.	'public'
channel_id	(int, str)	The ID of the channel to create the playlist under. Defaults to none.	None

Returns:

Name	Type	Description
Playlist	APIPlaylist	The playlist as parsed from the response data.

Source code in cocorum/servicephp.py

def playlist_add(self, title: str, description: str = "", visibility: str = "public", channel_id = None):
    """Create a new playlist.

Args:
    title (str): The title of the playlist.
    description (str): Describe the playlist.
        Defaults to nothing.
    visibility (str): Set to public, unlisted, or private via string.
        Defaults to 'public'.
    channel_id (int, str): The ID of the channel to create the playlist under.
        Defaults to none.

Returns:
    Playlist (APIPlaylist): The playlist as parsed from the response data.
    """

    r = self.sphp_request(
        "playlist.add",
        data = {
            "title": str(title),
            "description": str(description),
            "visibility": str(visibility),
            "channel_id": str(utils.ensure_b10(channel_id)) if channel_id else None,
        }
    )
    return APIPlaylist(r.json()["data"])

playlist_add_video(playlist_id, video_id)

Add a video to a playlist.

Parameters:

Name	Type	Description	Default
playlist_id	str	The numeric ID of the playlist in base 36.	required
video_id	(int, str)	The numeric ID of the video to add, in base 10 or 36.	required

Source code in cocorum/servicephp.py

def playlist_add_video(self, playlist_id: str, video_id):
    """Add a video to a playlist.

Args:
    playlist_id (str): The numeric ID of the playlist in base 36.
    video_id (int, str): The numeric ID of the video to add, in base 10 or 36.
    """

    print(self.sphp_request(
        "playlist.add_video",
        data = {
            "playlist_id": str(playlist_id),
            "video_id": utils.ensure_b10(video_id),
            }
        ).text)

playlist_delete(playlist_id)

Delete a playlist.

Parameters:

Name	Type	Description	Default
playlist_id	str	The numeric ID of the playlist to delete in base 36.	required

Source code in cocorum/servicephp.py

def playlist_delete(self, playlist_id: str):
    """Delete a playlist.

Args:
    playlist_id (str): The numeric ID of the playlist to delete in base 36.
    """

    print(self.sphp_request(
        "playlist.delete",
        data = {"playlist_id" : utils.ensure_b36(playlist_id)},
        ).text)

playlist_delete_video(playlist_id, video_id)

Remove a video from a playlist.

Parameters:

Name	Type	Description	Default
playlist_id	str	The numeric ID of the playlist in base 36.	required
video_id	(int, str)	The numeric ID of the video to remove, in base 10 or 36.	required

Source code in cocorum/servicephp.py

def playlist_delete_video(self, playlist_id: str, video_id: int):
    """Remove a video from a playlist.

Args:
    playlist_id (str): The numeric ID of the playlist in base 36.
    video_id (int, str): The numeric ID of the video to remove, in base 10 or 36.
    """

    print(self.sphp_request(
        "playlist.delete_video",
        data = {
            "playlist_id": str(playlist_id),
            "video_id": utils.ensure_b10(video_id),
            }
        ).text)

playlist_edit(playlist_id, title, description='', visibility='public', channel_id=None)

Edit the details of an existing playlist

Parameters:

Name	Type	Description	Default
playlist_id	str	The numeric ID of the playlist to edit in base 36.	required
title	str	The title of the playlist.	required
description	str	Describe the playlist. Defaults to nothing.	''
visibility	str	Set to public, unlisted, or private via string. Defaults to 'public'.	'public'
channel_id	(int, str)	The ID of the channel to create the playlist under. Defaults to none.	None

Returns:

Name	Type	Description
Playlist	APIPlaylist	The playlist as parsed from the response data.

Source code in cocorum/servicephp.py

def playlist_edit(self, playlist_id: str, title: str, description: str = "", visibility: str = "public", channel_id = None):
    """Edit the details of an existing playlist

Args:
    playlist_id (str): The numeric ID of the playlist to edit in base 36.
    title (str): The title of the playlist.
    description (str): Describe the playlist.
        Defaults to nothing.
    visibility (str): Set to public, unlisted, or private via string.
        Defaults to 'public'.
    channel_id (int, str): The ID of the channel to create the playlist under.
        Defaults to none.

Returns:
    Playlist (APIPlaylist): The playlist as parsed from the response data.
    """

    r = self.sphp_request(
        "playlist.edit",
        data = {
            "title": str(title),
            "description": str(description),
            "visibility": str(visibility),
            "channel_id": str(utils.ensure_b10(channel_id)) if channel_id else None,
            "playlist_id": utils.ensure_b36(playlist_id),
        }
    )
    return APIPlaylist(r.json()["data"])

raid_confirm(stream_id)

Confirm a raid, previously set up by command.

Parameters:

Name	Type	Description	Default
stream_id	(int, str)	The numeric ID of the stream to confirm the raid from, in base 10 or 36.	required

Source code in cocorum/servicephp.py

def raid_confirm(self, stream_id):
    """Confirm a raid, previously set up by command.

Args:
    stream_id (int, str): The numeric ID of the stream to confirm the raid from, in base 10 or 36.
    """

    self.sphp_request(
        "raid.confirm",
        data = {"video_id" : utils.ensure_b10(stream_id)},
        )

rumbles(vote, item_id, item_type)

Post a like or dislike.

Parameters:

Name	Type	Description	Default
vote	int	-1, 0, or 1 (0 means clear vote).	required
item_id	int	The numeric ID of whatever we are liking or disliking.	required
item_type	int	1 for video, 2 for comment.	required

Source code in cocorum/servicephp.py

def rumbles(self, vote: int, item_id, item_type: int):
    """Post a like or dislike.

Args:
    vote (int): -1, 0, or 1 (0 means clear vote).
    item_id (int): The numeric ID of whatever we are liking or disliking.
    item_type (int): 1 for video, 2 for comment.
    """

    r = self.sphp_request(
        "user.rumbles",
        data = {
            "type" : int(item_type),
            "id" : utils.ensure_b10(item_id),
            "vote" : int(vote),
            },
        )
    return APIContentVotes(r.json()["data"])

sphp_request(service_name, data={}, additional_params={}, logged_in=True, method='POST')

Make a request to Service.PHP with common settings service_name: The name parameter of the specific PHP service data: Form data additional_params: Any additional query string parameters logged_in: The request should use the session cookie

Source code in cocorum/servicephp.py

def sphp_request(self, service_name: str, data: dict = {}, additional_params: dict = {}, logged_in = True, method = "POST"):
    """Make a request to Service.PHP with common settings
    service_name: The name parameter of the specific PHP service
    data: Form data
    additional_params: Any additional query string parameters
    logged_in: The request should use the session cookie"""
    params = {"name" : service_name}
    params.update(additional_params)
    r = requests.request(
            method,
            static.URI.servicephp,
            params = params,
            data = data,
            headers = static.RequestHeaders.user_agent,
            cookies = self.session_cookie if logged_in else None,
            timeout = static.Delays.request_timeout,
            )
    assert r.status_code == 200, f"Service.PHP request for {service_name} failed: {r}\n{r.text}"
    #If the request json has a data -> success value, make sure it is True
    d = r.json().get("data")
    if isinstance(d, dict):
        assert d.get("success", True), f"Service.PHP request for {service_name} failed: \n{r.text}"
    #Data was not a dict but was not empty
    elif d:
        print(f"Service.PHP request for {service_name} did not fail but returned unknown data type {type(d)}: {d}")

    return r

unmute_user(record_id)

Unmute a user.

Parameters:

Name	Type	Description	Default
record_id	int	The numeric ID of the mute record to undo.	required

Source code in cocorum/servicephp.py

def unmute_user(self, record_id: int):
    """Unmute a user.

Args:
    record_id: The numeric ID of the mute record to undo.
    """

    self.sphp_request(
        "moderation.unmute",
        data = {
            "record_id" : record_id,
            }
        )

S.D.G.