Hiven Types

---

List of represented Types

List of Type	Description
Attachment	Represents a Hiven message attachment containing a file
Context	Represents a Command Context for a triggered command that was registered prior
Embed	Represents an embed message object either customised or from a website
Entity	Represents a Hiven Entity inside a House which can contain Rooms
Feed	Represents the feed that is displayed on Hiven specifically for the user
House	Represents a Hiven House which can contain rooms and entities
Invite	Represents an Invite to a Hiven House
Member	Represents a House Member on Hiven which contains the Hiven User, role-data and member-data
Mention	Represents an mention for a user in Hiven
DeletedMessage	Represents a Deleted Message in a Room
Message	Represents a standard Hiven message sent by a user
PrivateRoom	Represents a private chat room with only one user
PrivateGroupRoom	Represents a private group chat room with multiple users
Relationship	Represents a user-relationship with another user or bot
TextRoom	Represents a Hiven Room inside a House
User	Represents the standard Hiven User
UserTyping	Represents a Hiven User typing in a room

openhivenpy.types.attachment.Attachment

Represents a Hiven Message Attachment containing a file

filename: str property readonly

json_schema

media_url: str property readonly

raw: dict property readonly

Methods

__init__(self, data, client) special

Represents a Hiven Message Attachment containing a file

:param data: Data that should be used to create the object :param client: The HivenClient

Source code in openhivenpy\types\attachment.py

def __init__(self, data: dict, client: HivenClient):
    """
    Represents a Hiven Message Attachment containing a file

    :param data: Data that should be used to create the object
    :param client: The HivenClient
    """
    try:
        self._filename = data.get('filename')
        self._media_url = data.get('media_url')
        self._raw = data.get('raw')

    except Exception as e:
        raise InitializationError(f"Failed to initialise {self.__class__.__name__}") from e
    else:
        self._client = client

format_obj_data(data) classmethod

Validates the data and appends data if it iis missing that would be required for the creation of an instance.

:param data: Data that should be validated and used to form the object :return: The modified dictionary, which can then be used to create a new class instance

Source code in openhivenpy\types\attachment.py

@classmethod
def format_obj_data(cls, data: dict) -> dict:
    """
    Validates the data and appends data if it iis missing that would be
    required for the creation of an instance.

    :param data: Data that should be validated and used to form the object
    :return: The modified dictionary, which can then be used to create a 
     new class instance
    """
    data['raw'] = {**data.pop('raw', {}), **data}
    return cls.validate(data)

json_validator(data)

openhivenpy.types.context.Context

Represents a Command Context for a triggered command that was registered prior

author: Optional[User] property readonly

house: Optional[House] property readonly

json_schema

room: Optional[TextRoom] property readonly

timestamp: Optional[datetime.datetime] property readonly

Methods

__init__(self, data, client) special

Represents a Command Context for a triggered command that was registered prior

:param data: Data that should be used to create the object :param client: The HivenClient

Source code in openhivenpy\types\context.py

def __init__(self, data: dict, client: HivenClient):
    """
    Represents a Command Context for a triggered command that was
    registered prior

    :param data: Data that should be used to create the object
    :param client: The HivenClient
    """
    try:
        self._room = data.get('room')
        self._author = data.get('author')
        self._house = data.get('house')
        self._timestamp = data.get('timestamp')

    except Exception as e:
        raise InitializationError(f"Failed to initialise {self.__class__.__name__}") from e
    else:
        self._client = client

format_obj_data(data) classmethod

Validates the data and appends data if it is missing that would be required for the creation of an instance.

---

Does NOT contain other objects and only their ids!

:param data: Data that should be validated and used to form the object :return: The modified dictionary, which can then be used to create a new class instance

Source code in openhivenpy\types\context.py

@classmethod
def format_obj_data(cls, data: dict) -> dict:
    """
    Validates the data and appends data if it is missing that would be 
    required for the creation of an instance.

    ---

    Does NOT contain other objects and only their ids!

    :param data: Data that should be validated and used to form the object
    :return: The modified dictionary, which can then be used to create a 
     new class instance
    """
    data = cls.validate(data)
    data['timestamp'] = utils.safe_convert(int, data.get('timestamp'))

    if not data.get('room_id') and data.get('room'):
        room = data.pop('room')
        if type(room) is dict:
            room = room.get('id', None)
        elif isinstance(room, DataClassObject):
            room = getattr(room, 'id', None)
        else:
            room = None

        if room is None:
            raise InvalidPassedDataError("The passed room is not in the correct format!", data=data)
        else:
            data['room_id'] = room

    if not data.get('house_id') and data.get('house'):
        house = data.pop('house')
        if type(house) is dict:
            house = house.get('id', None)
        elif isinstance(house, DataClassObject):
            house = getattr(house, 'id', None)
        else:
            house = None

        if house is None:
            raise InvalidPassedDataError("The passed house is not in the correct format!", data=data)
        else:
            data['house_id'] = house

    if not data.get('author_id') and data.get('author'):
        author = data.pop('author')
        if type(author) is dict:
            author = author.get('id', None)
        elif isinstance(author, DataClassObject):
            author = getattr(author, 'id', None)
        else:
            author = None

        if author is None:
            raise InvalidPassedDataError("The passed author is not in the correct format!", data=data)
        else:
            data['author_id'] = author

    data['room'] = data['room_id']
    data['author'] = data['author_id']
    data['house'] = data['house_id']
    return data

json_validator(data)

openhivenpy.types.embed.Embed

Represents an embed message object either customised or from a website

description: Optional[str] property readonly

image: Optional[str] property readonly

json_schema

title: Optional[str] property readonly

type: Optional[int] property readonly

url: Optional[str] property readonly

Methods

__init__(self, data, client) special

Represents an embed message object either customised or from a website

:param data: Data that should be used to create the object :param client: The HivenClient

Source code in openhivenpy\types\embed.py

def __init__(self, data: dict, client: HivenClient):
    """
    Represents an embed message object either customised or from a website

    :param data: Data that should be used to create the object
    :param client: The HivenClient
    """
    try:
        self._url = data.get('url')
        self._type = data.get('type')
        self._title = data.get('title')
        self._image = data.get('image')
        self._description = data.get('description')

    except Exception as e:
        raise InitializationError(f"Failed to initialise {self.__class__.__name__}") from e
    else:
        self._client = client

format_obj_data(data) classmethod

Validates the data and appends data if it is missing that would be required for the creation of an instance.

:param data: Data that should be validated and used to form the object :return: The modified dictionary, which can then be used to create a new class instance

Source code in openhivenpy\types\embed.py

@classmethod
def format_obj_data(cls, data: dict) -> dict:
    """
    Validates the data and appends data if it is missing that would be
    required for the creation of an instance.

    :param data: Data that should be validated and used to form the object
    :return: The modified dictionary, which can then be used to create a 
    new class instance
    """
    return cls.validate(data)

json_validator(data)

openhivenpy.types.entity.Entity

Represents a Hiven Entity inside a House which can contain Rooms

Attributes

house: Optional[House] property readonly

house_id: str property readonly

id: str property readonly

json_schema

name: str property readonly

position: int property readonly

resource_pointers: Optional[List[TextRoom, dict]] property readonly

Objects contained inside the entity. If dict is returned it's a type that is not yet included in the lib

type: Optional[int] property readonly

Methods

__init__(self, data, client) special

Represents a Hiven Entity inside a House which can contain Rooms

:param data: Data that should be used to create the object :param client: The HivenClient

Source code in openhivenpy\types\entity.py

def __init__(self, data: dict, client: HivenClient):
    """
    Represents a Hiven Entity inside a House which can contain Rooms

    :param data: Data that should be used to create the object
    :param client: The HivenClient
    """
    try:
        super().__init__()
        self._type = data.get('type')
        self._position = data.get('position')
        self._resource_pointers = data.get('resource_pointers')
        self._name = data.get('name')
        self._id = data.get('id')
        self._house_id = data.get('house_id')
        self._house = data.get('house')

    except Exception as e:
        raise InitializationError(f"Failed to initialise {self.__class__.__name__}") from e
    else:
        self._client = client

__repr__(self) special

Source code in openhivenpy\types\entity.py

def __repr__(self) -> str:
    info = [
        ('name', self.name),
        ('id', self.id),
        ('position', self.position),
        ('type', self.type)
    ]
    return '<Entity {}>'.format(' '.join('%s=%s' % t for t in info))

format_obj_data(data) classmethod

Validates the data and appends data if it is missing that would be required for the creation of an instance.

---

Does NOT contain other objects and only their ids!

:param data: Data that should be validated and used to form the object :return: The modified dictionary, which can then be used to create a new class instance

Source code in openhivenpy\types\entity.py

@classmethod
def format_obj_data(cls, data: dict) -> dict:
    """
    Validates the data and appends data if it is missing that would be 
    required for the creation of an instance.

    ---

    Does NOT contain other objects and only their ids!

    :param data: Data that should be validated and used to form the object
    :return: The modified dictionary, which can then be used to create a 
     new class instance
    """
    if not data.get('house_id') and data.get('house'):
        house = data.pop('house')
        if type(house) is dict:
            house_id = house.get('id')
        elif isinstance(house, DataClassObject):
            house_id = getattr(house, 'id', None)
        else:
            house_id = None

        if house_id is None:
            raise InvalidPassedDataError("The passed house is not in the correct format!", data=data)
        else:
            data['house_id'] = house_id

    data['house'] = data.get('house_id')
    data = cls.validate(data)
    return data

get_cached_data(self)

Fetches the most recent data from the cache based on the instance id

Source code in openhivenpy\types\entity.py

def get_cached_data(self) -> Optional[dict]:
    """ Fetches the most recent data from the cache based on the instance id """
    return self._client.storage['entities'].get(self.id)

json_validator(data)

openhivenpy.types.feed.Feed

Represents the feed that is displayed on Hiven specifically for the user

__init__(self, data, client) special

Source code in openhivenpy\types\feed.py

def __init__(self, data: dict, client: HivenClient):
    ...

__repr__(self) special

Source code in openhivenpy\types\feed.py

def __repr__(self) -> str:
    info = [
        ('unknown', "")
    ]
    return '<Feed {}>'.format(' '.join('%s=%s' % t for t in info))

__str__(self) special

Source code in openhivenpy\types\feed.py

def __str__(self) -> str:
    return repr(self)

openhivenpy.types.house.House

Represents a Hiven House which can contain rooms and entities

banner: Optional[str] property readonly

client_member: Optional[Member] property readonly

default_permissions: Optional[int] property readonly

entities: Optional[List[Entity]] property readonly

json_schema

members: Optional[List[Member]] property readonly

owner: Optional[Member] property readonly

roles: Optional[list] property readonly

users: Optional[List[Member]] property readonly

Methods

__init__(self, data, client) special

Source code in openhivenpy\types\house.py

def __init__(self, data: dict, client: HivenClient):
    try:
        self._roles = data.get('roles')
        self._roles_data = self._roles
        self._entities: list = data.get('entities')
        self._default_permissions = data.get('default_permissions')
        self._members: dict = data.get('members')
        self._member_data = self._members
        self._client_member = data.get('client_member')
        self._banner = data.get('banner')
        self._owner = data.get('owner')
        self._client = client

    except Exception as e:
        raise InitializationError(f"Failed to initialise {self.__class__.__name__}") from e
    super().__init__(data, client)

create_entity(self, name) async

Creates a entity in the house with the specified name.

:param name: The name of the new entity :return: The newly created Entity Instance

Source code in openhivenpy\types\house.py

async def create_entity(self, name: str) -> Optional[Entity]:
    """
    Creates a entity in the house with the specified name.

    :param name: The name of the new entity
    :return: The newly created Entity Instance
    """
    try:
        resp = await self._client.http.post(
            endpoint=f"/houses/{self.id}/entities",
            json={'name': name, 'type': 1}
        )
        raw_data = await resp.json()

        data = raw_data.get('data')

        # Fetching all existing ids
        existing_entity_ids = [e['id'] for e in self.entities]
        for d in data:
            id_ = d.get('id')
            if id_ not in existing_entity_ids:
                d = Entity.format_obj_data(d)
                _entity = Entity(d, self._client)
                self._entities.append(_entity)
                return _entity

    except Exception as e:
        utils.log_traceback(
            brief=f"Failed to create category '{name}' in house {repr(self)}:",
            exc_info=sys.exc_info()
        )
        # TODO! Raise exception
        return None

create_invite(self, max_uses) async

Creates an invite for the current house.

:param max_uses: Maximal uses for the invite code :return: The invite url if successful.

Source code in openhivenpy\types\house.py

async def create_invite(self, max_uses: int) -> Optional[Invite]:
    """
    Creates an invite for the current house. 

    :param max_uses: Maximal uses for the invite code
    :return: The invite url if successful.
    """
    try:
        from . import Invite
        resp = await self._client.http.post(
            endpoint=f"/houses/{self.id}/invites",
            json={"max_uses": max_uses}
        )
        raw_data = await resp.json()

        data = raw_data.get('data')
        data = Invite.format_obj_data(data)
        return Invite(data, self._client)

    except Exception as e:
        utils.log_traceback(
            brief=f"Failed to create invite for house {repr(self)}",
            exc_info=sys.exc_info()
        )
        # TODO! Raise exception
        return None

create_room(self, name, parent_entity_id=None) async

Creates a Room in the house with the specified name.

:return: A Room Instance for the Hiven Room that was created if successful else None

Source code in openhivenpy\types\house.py

async def create_room(self, name: str, parent_entity_id: Optional[int] = None) -> Optional[TextRoom]:
    """
    Creates a Room in the house with the specified name. 

    :return: A Room Instance for the Hiven Room that was created if successful else None
    """
    try:
        from . import TextRoom
        default_entity = utils.get(self.entities, name="Rooms")
        json = {
            'name': name,
            'parent_entity_id': parent_entity_id if parent_entity_id else default_entity.id
        }

        # Creating the room using the api
        resp = await self._client.http.post(f"/houses/{self._id}/rooms", json=json)
        raw_data = await resp.json()

        data = TextRoom.format_obj_data(raw_data.get('data'))
        return TextRoom(data, self._client)

    except Exception as e:
        utils.log_traceback(
            brief=f"Failed to create room '{name}' in house {repr(self)}:",
            exc_info=sys.exc_info()
        )
        # TODO! Raise exception
        return None

delete(self) async

Deletes the house if permissions are sufficient!

:return: The house ID if successful else None

Source code in openhivenpy\types\house.py

async def delete(self) -> Optional[str]:
    """
    Deletes the house if permissions are sufficient!

    :return: The house ID if successful else None
    """
    try:
        await self._client.http.delete(f"/houses/{self.id}")
        return self.id

    except Exception as e:
        utils.log_traceback(
            brief=f"Failed to delete House {repr(self)}",
            exc_info=sys.exc_info()
        )
        # TODO! Raise exception
        return None

edit(self, **kwargs) async

Changes the houses data on Hiven.

Available options: name, icon(base64)

:return: True if the request was successful else False

Source code in openhivenpy\types\house.py

async def edit(self, **kwargs) -> bool:
    """
    Changes the houses data on Hiven.

    Available options: name, icon(base64)

    :return: True if the request was successful else False
    """
    try:
        for key, data in kwargs.items():
            if key in ['name']:
                await self._client.http.patch(
                    endpoint=f"/houses/{self.id}", json={key: data}
                )
                return True
            else:
                raise NameError("The passed value does not exist in the House!")

    except Exception as e:
        keys = "".join(key + " " for key in kwargs.keys()) if kwargs != {} else ''
        utils.log_traceback(
            brief=f"Failed edit request of values '{keys}' in house {repr(self)}:",
            exc_info=sys.exc_info()
        )
        # TODO! Raise exception
        return False

find_entity(self, entity_id)

Fetches the raw data of a entity

:param entity_id: The id of the entity which should be fetched :return: The data in the cache if it was found

Source code in openhivenpy\types\house.py

def find_entity(self, entity_id: str) -> Optional[dict]:
    """
    Fetches the raw data of a entity

    :param entity_id: The id of the entity which should be fetched
    :return: The data in the cache if it was found
    """
    return self._client.storage['entities'].get(entity_id)

find_member(self, member_id)

Fetches the raw data of a member

:param member_id: The id of the member which should be fetched :return: The data in the cache if it was found

Source code in openhivenpy\types\house.py

def find_member(self, member_id: str) -> Optional[dict]:
    """
    Fetches the raw data of a member

    :param member_id: The id of the member which should be fetched
    :return: The data in the cache if it was found
    """
    return self._member_data.get(member_id)

find_room(self, room_id)

Fetches the raw data of a room

:param room_id: The id of the room which should be fetched :return: The data in the cache if it was found

Source code in openhivenpy\types\house.py

def find_room(self, room_id: str) -> Optional[dict]:
    """
    Fetches the raw data of a room

    :param room_id: The id of the room which should be fetched
    :return: The data in the cache if it was found
    """
    return self._client.storage['rooms']['house'].get(room_id)

format_obj_data(data) classmethod

Validates the data and appends data if it is missing that would be required for the creation of an instance.

---

Does NOT contain other objects and only their ids!

:param data: Data that should be validated and used to form the object :return: The modified dictionary, which can then be used to create a new class instance

Source code in openhivenpy\types\house.py

@classmethod
def format_obj_data(cls, data: dict) -> dict:
    """
    Validates the data and appends data if it is missing that would be 
    required for the creation of an instance.

    ---

    Does NOT contain other objects and only their ids!

    :param data: Data that should be validated and used to form the object
    :return: The modified dictionary, which can then be used to create a 
     new class instance
    """
    data = LazyHouse.format_obj_data(data)
    data = cls.validate(data)
    return data

get_entity(self, entity_id)

Fetches a entity from the cache based on the id

:return: The Entity Instance if it exists else returns None

Source code in openhivenpy\types\house.py

def get_entity(self, entity_id: str) -> Optional[Entity]:
    """
    Fetches a entity from the cache based on the id

    :return: The Entity Instance if it exists else returns None
    """
    try:
        from . import Entity
        cached_entity = self.find_entity(entity_id)
        if cached_entity:
            return Entity(cached_entity, self._client)

        return None

    except Exception as e:
        utils.log_traceback(
            brief=f"Failed to get the member with id {entity_id}:",
            exc_info=sys.exc_info()
        )
        # TODO! Raise exception
        return None

get_member(self, member_id)

Fetches a member from the cache based on the id

:return: The Member Instance if it exists else returns None

Source code in openhivenpy\types\house.py

def get_member(self, member_id: str) -> Optional[Member]:
    """
    Fetches a member from the cache based on the id

    :return: The Member Instance if it exists else returns None
    """
    try:
        from . import Member

        cached_member = self.find_member(member_id)
        if cached_member:
            return Member(cached_member, self._client)

        return None

    except Exception as e:
        utils.log_traceback(
            brief=f"Failed to get the member with id {member_id}:",
            exc_info=sys.exc_info()
        )
        # TODO! Raise exception
        raise

get_room(self, room_id)

Fetches a room from the cache based on the id

:return: The Room Instance if it exists else returns None

Source code in openhivenpy\types\house.py

def get_room(self, room_id: str) -> Optional[TextRoom]:
    """
    Fetches a room from the cache based on the id

    :return: The Room Instance if it exists else returns None
    """
    try:
        from . import TextRoom
        cached_room = self.find_room(room_id)
        if cached_room:
            return TextRoom(cached_room, self._client)

        return None

    except Exception as e:
        utils.log_traceback(
            brief=f"Failed to get the room with id {room_id} in house {repr(self)}:",
            exc_info=sys.exc_info()
        )
        # TODO! Raise exception
        return None

json_validator(data)

leave(self) async

Leaves the house

:return: True if it was successful else False

Source code in openhivenpy\types\house.py

async def leave(self) -> bool:
    """
    Leaves the house

    :return: True if it was successful else False
    """
    try:
        await self._client.http.delete(endpoint=f"/users/@me/houses/{self.id}")
        return True

    except Exception as e:
        utils.log_traceback(
            brief=f"Failed to leave {repr(self)}:",
            exc_info=sys.exc_info()
        )
        # TODO! Raise exception
        return False

openhivenpy.types.invite.Invite

Represents an Invite to a Hiven House

code: Optional[int] property readonly

created_at: Optional[str] property readonly

house: Optional[House] property readonly

house_id: Optional[str] property readonly

house_members: Optional[int] property readonly

json_schema

max_age: Optional[int] property readonly

max_uses: Optional[int] property readonly

type: Optional[int] property readonly

url: Optional[str] property readonly

Methods

__init__(self, data, client) special

Source code in openhivenpy\types\invite.py

def __init__(self, data: dict, client: HivenClient):
    try:
        self._code = data.get('code')
        self._url = data.get('url')
        self._created_at = data.get('created_at')
        self._house_id = data.get('house_id')
        self._max_age = data.get('max_age')
        self._max_uses = data.get('max_uses')
        self._type = data.get('type')
        self._house = data.get('house')
        self._house_members = data.get('house_members')

    except Exception as e:
        raise InitializationError(f"Failed to initialise {self.__class__.__name__}") from e
    else:
        self._client = client

__repr__(self) special

Source code in openhivenpy\types\invite.py

def __repr__(self) -> str:
    info = [
        ('code', self.code),
        ('url', self.url),
        ('created_at', self.created_at),
        ('house_id', self.house_id),
        ('type', self.type),
        ('max_age', self.max_age),
        ('max_uses', self.max_uses),
    ]
    return '<Invite {}>'.format(' '.join('%s=%s' % t for t in info))

format_obj_data(data) classmethod

Validates the data and appends data if it is missing that would be required for the creation of an instance.

---

Does NOT contain other objects and only their ids!

:param data: Data that should be validated and used to form the object :return: The modified dictionary, which can then be used to create a new class instance

Source code in openhivenpy\types\invite.py

@classmethod
def format_obj_data(cls, data: dict) -> dict:
    """
    Validates the data and appends data if it is missing that would be
    required for the creation of an instance.

    ---

    Does NOT contain other objects and only their ids!

    :param data: Data that should be validated and used to form the object
    :return: The modified dictionary, which can then be used to create a 
     new class instance
    """
    if data.get('invite') is not None:
        invite = data.get('invite')
    else:
        invite = data
    data['code'] = invite.get('code')
    data['url'] = "https://hiven.house/{}".format(data['code'])
    data['created_at'] = invite.get('created_at')
    data['max_age'] = invite.get('max_age')
    data['max_uses'] = invite.get('max_uses')
    data['type'] = invite.get('type')
    data['house_members'] = data.get('counts', {}).get('house_members')

    if not invite.get('house_id') and invite.get('house'):
        house = invite.pop('house')
        if type(house) is dict:
            house_id = house.get('id')
        elif isinstance(house, DataClassObject):
            house_id = getattr(house, 'id', None)
        else:
            house_id = None

        if house_id is None:
            raise InvalidPassedDataError("The passed house is not in the correct format!", data=data)
        else:
            data['house_id'] = house_id

    data['type'] = int(data['type'])
    data['house'] = data.get('house_id')
    data = cls.validate(data)
    return data

json_validator(data)

openhivenpy.types.member.Member

Represents a House Member on Hiven which contains the Hiven User, role-data and member-data

Attributes

house: Optional[House] property readonly

house_id: Optional[str] property readonly

id: Optional[str] property readonly

Unique string id of the user

joined_at: Optional[str] property readonly

joined_house_at: Optional[str] property readonly

json_schema

roles: Optional[List[dict]] property readonly

user_id: Optional[str] property readonly

Methods

__init__(self, data, client) special

Source code in openhivenpy\types\member.py

def __init__(self, data: dict, client: HivenClient):
    super().__init__(data.get('user'), client)
    try:
        data = {**data.get('user'), **data}
        self._user_id = data.get('user_id')
        self._house_id = data.get('house_id')
        self._joined_at = data.get('joined_at')
        self._roles = data.get('roles')
        self._house = data.get('house')

    except Exception as e:
        raise InitializationError(
            f"Failed to initialise {self.__class__.__name__}"
        ) from e

__repr__(self) special

Source code in openhivenpy\types\member.py

def __repr__(self) -> str:
    info = [
        ('username', self.username),
        ('name', self.name),
        ('id', self.id),
        ('icon', self.icon),
        ('header', self.header),
        ('bot', self.bot),
        ('house_id', self.house_id),
        ('joined_house_at', self.joined_house_at)
    ]
    return '<Member {}>'.format(' '.join('%s=%s' % t for t in info))

format_obj_data(data) classmethod

Validates the data and appends data if it is missing that would be required for the creation of an instance.

---

Does NOT contain other objects and only their ids!

:param data: Data that should be validated and used to form the object :return: The modified dictionary, which can then be used to create a new class instance

Source code in openhivenpy\types\member.py

@classmethod
def format_obj_data(cls, data: dict) -> dict:
    """
    Validates the data and appends data if it is missing that would be 
    required for the creation of an instance.

    ---

    Does NOT contain other objects and only their ids!

    :param data: Data that should be validated and used to form the object
    :return: The modified dictionary, which can then be used to create a 
     new class instance
    """
    if not data.get('house_id') and data.get('house'):
        house = data.pop('house')
        if type(house) is dict:
            house_id = house.get('id')
        elif isinstance(house, DataClassObject):
            house_id = getattr(house, 'id', None)
        else:
            house_id = None

        if house_id is None:
            raise InvalidPassedDataError(
                "The passed house is not in the correct format!", data=data
            )
        else:
            data['house_id'] = house_id

    elif not data.get('house_id') and not data.get('house'):
        raise InvalidPassedDataError(
            "house_id and house missing from required data", data=data
        )

    data['house'] = data.get('house_id')
    data = cls.validate(data)
    return data

json_validator(data)

kick(self) async

Kicks a user from the house.

The client needs permissions to kick, or else this will raise HivenException.Forbidden

:return: True if the request was successful :raises Forbidden: If the request failed to execute

Source code in openhivenpy\types\member.py

async def kick(self) -> bool:
    """
    Kicks a user from the house.

    The client needs permissions to kick, or else this will raise
    `HivenException.Forbidden`

    :return: True if the request was successful
    :raises Forbidden: If the request failed to execute
    """
    try:
        resp = await self._client.http.delete(
            f"/{self._house_id}/members/{self._user_id}"
        )
        if not resp.status < 300:
            raise HTTPForbiddenError()
        else:
            return True
    except HTTPForbiddenError:
        raise

    except Exception as e:
        utils.log_traceback(
            brief=f"Failed to kick the member due to an exception "
                  "occurring:",
            exc_info=sys.exc_info()
        )
        # TODO! Raise exception
        return False

openhivenpy.types.mention.Mention

Represents an mention for a user in Hiven

author: Optional[User] property readonly

author_id: Optional[str] property readonly

json_schema

timestamp: Optional[datetime.datetime] property readonly

user: Optional[User] property readonly

user_id: Optional[str] property readonly

Methods

__init__(self, data, client) special

Source code in openhivenpy\types\mention.py

def __init__(self, data: dict, client: HivenClient):
    try:
        self._timestamp = data.get('timestamp')
        self._user = data.get('user')
        self._user_id = data.get('user_id')
        self._author = data.get('author')
        self._author_id = data.get('author_id')

    except Exception as e:
        raise InitializationError(f"Failed to initialise {self.__class__.__name__}") from e
    else:
        self._client = client

format_obj_data(data) classmethod

Validates the data and appends data if it is missing that would be required for the creation of an instance.

---

Does NOT contain other objects and only their ids!

:param data: Data that should be validated and used to form the object :return: The modified dictionary, which can then be used to create a new class instance

Source code in openhivenpy\types\mention.py

@classmethod
def format_obj_data(cls, data: dict) -> dict:
    """
    Validates the data and appends data if it is missing that would be 
    required for the creation of an instance.

    ---

    Does NOT contain other objects and only their ids!

    :param data: Data that should be validated and used to form the object
    :return: The modified dictionary, which can then be used to create a 
     new class instance
    """
    if not data.get('user_id') and data.get('user'):
        user = data.pop('user')
        if type(user) is dict:
            user = user.get('id', None)
        elif isinstance(user, DataClassObject):
            user = getattr(user, 'id', None)
        else:
            user = None

        if user is None:
            raise InvalidPassedDataError("The passed user is not in the correct format!", data=data)
        else:
            data['user'] = user

    if not data.get('author_id') and data.get('author'):
        author = data.pop('author')
        if type(author) is dict:
            author = author.get('id', None)
        elif isinstance(author, DataClassObject):
            author = getattr(author, 'id', None)
        else:
            author = None

        if author is None:
            raise InvalidPassedDataError("The passed author is not in the correct format!", data=data)
        else:
            data['author'] = author

    data['author'] = data.get('author_id')
    data['user'] = data.get('user_id')
    data = cls.validate(data)
    return data

json_validator(data)

openhivenpy.types.message.DeletedMessage

Represents a Deleted Message in a Room

house_id: Optional[str] property readonly

json_schema

message_id: Optional[str] property readonly

room_id: Optional[str] property readonly

Methods

__init__(self, data, client) special

Source code in openhivenpy\types\message.py

def __init__(self, data: dict, client: HivenClient):
    try:
        self._message_id = data.get('message_id')
        self._house_id = data.get('house_id')
        self._room_id = data.get('room_id')

    except Exception as e:
        raise InitializationError(f"Failed to initialise {self.__class__.__name__}") from e
    else:
        self._client = client

__str__(self) special

Source code in openhivenpy\types\message.py

def __str__(self):
    return f"Deleted message in room {self.room_id}"

format_obj_data(data) classmethod

Validates the data and appends data if it is missing that would be required for the creation of an instance.

:param data: Data that should be validated and used to form the object :return: The modified dictionary, which can then be used to create a new class instance

Source code in openhivenpy\types\message.py

@classmethod
def format_obj_data(cls, data: dict) -> dict:
    """
    Validates the data and appends data if it is missing that would be
    required for the creation of an
    instance.

    :param data: Data that should be validated and used to form the object
    :return: The modified dictionary, which can then be used to create a 
     new class instance
    """
    data = cls.validate(data)
    data['message_id'] = data['id']
    return data

json_validator(data)

openhivenpy.types.message.Message

Represents a standard Hiven message sent by a user

attachment: Optional[Attachment] property readonly

author: Optional[User] property readonly

author_id: Optional[str] property readonly

bucket: Optional[int] property readonly

content: Optional[str] property readonly

created_at: Optional[str] property readonly

device_id: Optional[str] property readonly

edited_at: Optional[str] property readonly

embed: Embed property readonly

exploding: Optional[bool] property readonly

exploding_age: Optional[int] property readonly

house: Optional[House] property readonly

house_id: Optional[str] property readonly

id: Optional[str] property readonly

json_schema

mentions: Optional[List[Mention]] property readonly

room: Optional[TextRoom] property readonly

room_id: Optional[str] property readonly

timestamp: Optional[datetime.datetime] property readonly

type: Optional[int] property readonly

Methods

__init__(self, data, client) special

Source code in openhivenpy\types\message.py

def __init__(self, data: dict, client: HivenClient):
    try:
        self._id = data.get('id')
        self._author = data.get('author')
        self._author_id = data.get('author_id')
        self._attachment: Union[dict, Attachment] = data.get('attachment')
        self._content = data.get('content')
        self._timestamp = data.get('timestamp')
        self._edited_at = data.get('edited_at')
        self._mentions = data.get('mentions')
        self._type = data.get('type')  # I believe, 0 = normal message, 1 = system.
        self._exploding = data.get('exploding')
        self._house_id = data.get('house_id')
        self._house = data.get('house')
        self._room_id = data.get('room_id')
        self._room = data.get('room')
        self._embed = data.get('embed')
        self._bucket = data.get('bucket')
        self._device_id = data.get('device_id')
        self._exploding_age = data.get('exploding_age')

    except Exception as e:
        raise InitializationError(f"Failed to initialise {self.__class__.__name__}") from e
    else:
        self._client = client

__repr__(self) special

Source code in openhivenpy\types\message.py

def __repr__(self) -> str:
    info = [
        ('id', self.id),
        ('content', self.content),
        ('author', repr(self.author)),
        ('room', repr(self.room)),
        ('type', self.type),
        ('exploding', self.exploding),
        ('edited_at', self.edited_at)
    ]
    return '<Message {}>'.format(' '.join('%s=%s' % t for t in info))

__str__(self) special

Source code in openhivenpy\types\message.py

def __str__(self) -> str:
    return f"<Message id='{self.id}' from '{self.author.name}'>"

delete(self, delay=None) async

Deletes the message. Raises Forbidden if not allowed.

:param delay: Delay until deleting the message as read (in seconds) :return: A DeletedMessage object if successful

Source code in openhivenpy\types\message.py

async def delete(self, delay: float = None) -> bool:
    """
    Deletes the message. Raises Forbidden if not allowed.

    :param delay: Delay until deleting the message as read (in seconds)
    :return: A DeletedMessage object if successful
    """
    try:
        if delay is not None:
            await asyncio.sleep(delay=delay)

        resp = await self._client.http.delete(
            endpoint=f"/rooms/{self.room_id}/messages/{self.id}"
        )

        if not resp.status < 300:
            raise HTTPForbiddenError()
        else:
            return True

    except Exception as e:
        utils.log_traceback(
            brief=f"Failed to delete the message {repr(self)}:",
            exc_info=sys.exc_info()
        )
        # TODO! Raise exception

edit(self, content) async

Edits a message on Hiven

:return: True if the request was successful else False

Source code in openhivenpy\types\message.py

async def edit(self, content: str) -> bool:
    """
    Edits a message on Hiven

    :return: True if the request was successful else False
    """
    try:
        await self._client.http.patch(
            endpoint=f"/rooms/{self.room_id}/messages/{self.id}", json={'content': content}
        )
        return True

    except Exception as e:
        utils.log_traceback(
            brief=f"Failed to edit message {repr(self)}",
            exc_info=sys.exc_info()
        )
        return False

format_obj_data(data) classmethod

Validates the data and appends data if it is missing that would be required for the creation of an instance.

---

Does NOT contain other objects and only their ids!

:param data: Data that should be validated and used to form the object :return: The modified dictionary, which can then be used to create a new class instance

Source code in openhivenpy\types\message.py

@classmethod
def format_obj_data(cls, data: dict) -> dict:
    """
    Validates the data and appends data if it is missing that would be
    required for the creation of an
    instance.

    ---

    Does NOT contain other objects and only their ids!

    :param data: Data that should be validated and used to form the object
    :return: The modified dictionary, which can then be used to create a 
     new class instance
    """
    # I believe, 0 = normal message, 1 = system.
    data['type'] = utils.safe_convert(int, data.get('type'), None)
    data['bucket'] = utils.safe_convert(int, data.get('bucket'), None)
    data['exploding_age'] = utils.safe_convert(int,
                                               data.get('exploding_age'),
                                               None)
    data['timestamp'] = utils.safe_convert(int, data.get('timestamp'))

    data = cls.validate(data)

    if not data.get('room_id') and data.get('room'):
        room_ = data.pop('room')
        if type(room_) is dict:
            room_ = room_.get('id', None)
        elif isinstance(room_, DataClassObject):
            room_ = getattr(room_, 'id', None)
        elif type(data.get('room_id')) is str:
            room_ = data['room_id']
        else:
            room_ = None

        if room_ is None:
            raise InvalidPassedDataError("The passed room is not in the correct format!", data=data)
        else:
            data['room_id'] = room_

    if not data.get('house_id') and data.get('house'):
        house_ = data.pop('house')
        if type(house_) is dict:
            house_ = house_.get('id', None)
        elif isinstance(house_, DataClassObject):
            house_ = getattr(house_, 'id', None)
        elif type(data.get('house_id')) is str:
            house_ = data['house_id']
        else:
            house_ = None

        data['house_id'] = house_

    if not data.get('author_id') and data.get('author'):
        author = data.pop('author')
        if type(author) is dict:
            author = author.get('id', None)
        elif isinstance(author, DataClassObject):
            author = getattr(author, 'id', None)
        elif type(data.get('author_id')) is str:
            author = data['author_id']
        else:
            author = None

        if author is None:
            raise InvalidPassedDataError("The passed author is not in the correct format!", data=data)
        else:
            data['author'] = author

    data['author'] = data['author_id']
    data['house'] = data['house_id']
    data['room'] = data['room_id']
    data['device_id'] = utils.safe_convert(str, data.get('device_id'), None)
    return data

json_validator(data)

mark_as_read(self, delay=None) async

Marks the message as read. This doesn't need to be done for bot clients.

:param delay: Delay until marking the message as read (in seconds) :return: True if the request was successful else False

Source code in openhivenpy\types\message.py

async def mark_as_read(self, delay: float = None) -> bool:
    """
    Marks the message as read. This doesn't need to be done for bot clients.

    :param delay: Delay until marking the message as read (in seconds)
    :return: True if the request was successful else False
    """
    try:
        if delay is not None:
            await asyncio.sleep(delay=delay)
        await self._client.http.post(
            endpoint=f"/rooms/{self.room_id}/messages/{self.id}/ack"
        )
        return True

    except Exception as e:
        utils.log_traceback(
            brief=f"Failed to mark message as read {repr(self)}:",
            exc_info=sys.exc_info()
        )
        # TODO! Raise exception

openhivenpy.types.private_room.PrivateRoom

Represents a private chat room with only one user

client_user: Optional[User] property readonly

description: Optional[str] property readonly

emoji: Optional[str] property readonly

id: Optional[str] property readonly

json_schema

last_message_id: Optional[str] property readonly

name: Optional[str] property readonly

recipient: Optional[User] property readonly

recipient_id: Optional[str] property readonly

type: Optional[int] property readonly

Methods

__init__(self, data, client) special

Source code in openhivenpy\types\private_room.py

def __init__(self, data: dict, client: HivenClient):
    try:
        self._id = data.get('id')
        self._last_message_id = data.get('last_message_id')
        self._recipient = data.get('recipient')
        self._recipient_id = data.get('recipient_id')
        self._name = data.get('name')
        self._description = data.get('description')
        self._emoji = data.get('emoji')
        self._type = data.get('type')
        self._client_user = client.client_user

    except Exception as e:
        raise InitializationError(f"Failed to initialise {self.__class__.__name__}") from e
    else:
        self._client = client

__repr__(self) special

Source code in openhivenpy\types\private_room.py

def __repr__(self) -> str:
    info = [
        ('id', self.id),
        ('last_message_id', self.last_message_id),
        ('recipients', self.recipient),
        ('type', self.type)
    ]
    return '<PrivateRoom {}>'.format(' '.join('%s=%s' % t for t in info))

format_obj_data(data) classmethod

Validates the data and appends data if it is missing that would be required for the creation of an instance.

---

Does NOT contain other objects and only their ids!

:param data: Data that should be validated and used to form the object :return: The modified dictionary, which can then be used to create a new class instance

Source code in openhivenpy\types\private_room.py

@classmethod
def format_obj_data(cls, data: dict) -> dict:
    """
    Validates the data and appends data if it is missing that would be 
    required for the creation of an instance.

    ---

    Does NOT contain other objects and only their ids!

    :param data: Data that should be validated and used to form the object
    :return: The modified dictionary, which can then be used to create a
     new class instance
    """
    data = cls.validate(data)

    name = ""
    if not data.get('recipient_id') and data.get('recipients'):
        recipient = data.pop('recipients')[0]
        if type(recipient) is dict:
            name = recipient.get('name', None)
            recipient = recipient.get('id', None)
        elif isinstance(recipient, DataClassObject):
            name = getattr(recipient, 'name', None)
            recipient = getattr(recipient, 'id', None)
        else:
            recipient = None
            name = None

        if recipient is None:
            raise InvalidPassedDataError("The passed recipient/s is/are not in the correct format!", data=data)
        else:
            data['recipient_id'] = recipient

    data['recipient'] = data['recipient_id']

    # If the passed recipient object does not contain the name parameter it will be fetched later from the client
    # based on the id
    if name:
        data['name'] = f"Private chat with {name}"
    else:
        data['name'] = None
    return data

get_cached_data(self)

Fetches the most recent data from the cache based on the instance id

Source code in openhivenpy\types\private_room.py

def get_cached_data(self) -> Optional[dict]:
    """ Fetches the most recent data from the cache based on the instance id """
    return self._client.storage['rooms']['private']['single'][self.id]

json_validator(data)

send(self, content, delay=None) async

Sends a message in the private room.

:param content: Content of the message :param delay: Delay until sending the message (in seconds) :return: Returns a Message Instance if successful.

Source code in openhivenpy\types\private_room.py

async def send(
        self, content: str, delay: float = None
) -> Optional[Message]:
    """
    Sends a message in the private room. 

    :param content: Content of the message
    :param delay: Delay until sending the message (in seconds)
    :return: Returns a Message Instance if successful.
    """
    # TODO! Requires functionality check!
    try:
        if delay is not None:
            await asyncio.sleep(delay=delay)
        resp = await self._client.http.post(
            endpoint=f"/rooms/{self.id}/messages", json={"content": content}
        )

        raw_data = await resp.json()

        # Raw_data not in correct format => needs to access data field
        data = raw_data.get('data')

        data = message.Message.format_obj_data(data)
        msg = message.Message(data, self._client)
        return msg

    except Exception as e:
        utils.log_traceback(
            brief=f"Failed to send message in room {repr(self)}:",
            exc_info=sys.exc_info()
        )
        # TODO! Raise exception
        return None

start_call(self, delay=None) async

openhivenpy.types.PrivateRoom.start_call()

Starts a call with the user in the private room

:param delay: Delay until calling (in seconds) :return: True if successful

Source code in openhivenpy\types\private_room.py

async def start_call(self, delay: float = None) -> bool:
    """openhivenpy.types.PrivateRoom.start_call()

    Starts a call with the user in the private room

    :param delay: Delay until calling (in seconds)
    :return: True if successful
    """
    try:
        if delay is not None:
            await asyncio.sleep(delay=delay)

        resp = await self._client.http.post(f"/rooms/{self.id}/call")

        data = await resp.json()
        if data.get('data'):
            return True
        else:
            return False

    except Exception as e:
        utils.log_traceback(
            brief=f"Failed to start call in room {repr(self)}:",
            exc_info=sys.exc_info()
        )
        # TODO! Raise exception
        return False

openhivenpy.types.private_room.PrivateGroupRoom

Represents a private group chat room with multiple users

client_user: Optional[User] property readonly

description: Optional[int] property readonly

emoji: Optional[str] property readonly

id: Optional[str] property readonly

json_schema

last_message_id: Optional[str] property readonly

name: Optional[str] property readonly

recipients: Optional[List[User]] property readonly

type: Optional[int] property readonly

Methods

__init__(self, data, client) special

Source code in openhivenpy\types\private_room.py

def __init__(self, data: dict, client: HivenClient):
    try:
        self._id = data.get('id')
        self._last_message_id = data.get('last_message_id')
        self._recipients = data.get('recipients')
        self._name = data.get('name')
        self._description = data.get('description')
        self._emoji = data.get('emoji')
        self._type = data.get('type')
        self._client_user = client.client_user

    except Exception as e:
        utils.log_traceback(
            brief=f"Failed to initialise {self.__class__.__name__}:",
            exc_info=sys.exc_info()
        )
        raise InitializationError(f"Failed to initialise {self.__class__.__name__}") from e
    else:
        self._client = client

__repr__(self) special

Source code in openhivenpy\types\private_room.py

def __repr__(self) -> str:
    info = [
        ('id', self.id),
        ('last_message_id', self.last_message_id),
        ('recipients', self.recipients),
        ('type', self.type)
    ]
    return '<PrivateGroupRoom {}>'.format(' '.join('%s=%s' % t for t in info))

format_obj_data(data) classmethod

Validates the data and appends data if it is missing that would be required for the creation of an instance.

---

Does NOT contain other objects and only their ids!

:param data: Data that should be validated and used to form the object :return: The modified dictionary, which can then be used to create a new class instance

Source code in openhivenpy\types\private_room.py

@classmethod
def format_obj_data(cls, data: dict) -> dict:
    """
    Validates the data and appends data if it is missing that would be 
    required for the creation of an instance.

    ---

    Does NOT contain other objects and only their ids!

    :param data: Data that should be validated and used to form the object
    :return: The modified dictionary, which can then be used to create a
     new class instance
    """
    data = cls.validate(data)
    data['name'] = f"Private chat with {data['recipients'][0]['name']}"

    if type(data.get('recipients')) is list:
        data['recipients'] = [i['id'] for i in data['recipients']]

    return data

get_cached_data(self)

Fetches the most recent data from the cache based on the instance id

Source code in openhivenpy\types\private_room.py

def get_cached_data(self) -> Optional[dict]:
    """
    Fetches the most recent data from the cache based on the instance id
    """
    return self._client.storage['rooms']['private']['group'][self.id]

json_validator(data)

send(self, content, delay=None) async

Sends a message in the private room.

:param content: Content of the message :param delay: Seconds to wait until sending the message (in seconds) :return: A Message instance if successful else None

Source code in openhivenpy\types\private_room.py

async def send(self, content: str, delay: float = None) -> Optional[Message]:
    """
    Sends a message in the private room.

    :param content: Content of the message
    :param delay: Seconds to wait until sending the message (in seconds)
    :return: A Message instance if successful else None
    """
    try:
        if delay is not None:
            await asyncio.sleep(delay=delay)
        resp = await self._client.http.post(
            endpoint=f"/rooms/{self.id}/messages",
            json={"content": content}
        )

        raw_data = await resp.json()

        # Raw_data not in correct format => needs to access data field
        data = raw_data.get('data')

        data = message.Message.format_obj_data(data)
        msg = message.Message(data, self._client)
        return msg

    except Exception as e:
        utils.log_traceback(
            brief=f"Failed to send message in room {repr(self)}:",
            exc_info=sys.exc_info()
        )
        # TODO! Raise exception
        return None

start_call(self, delay=None) async

openhivenpy.types.PrivateGroupRoom.start_call()

Starts a call with the user in the private room

:param delay: Delay until calling (in seconds) :return: True if successful

Source code in openhivenpy\types\private_room.py

async def start_call(self, delay: float = None) -> bool:
    """openhivenpy.types.PrivateGroupRoom.start_call()

    Starts a call with the user in the private room

    :param delay: Delay until calling (in seconds)
    :return: True if successful
    """
    try:
        if delay is not None:
            await asyncio.sleep(delay=delay)
        await self._client.http.post(f"/rooms/{self.id}/call")
        return True

    except Exception as e:
        utils.log_traceback(
            brief=f"Failed to start call in {repr(self)}:",
            exc_info=sys.exc_info()
        )
        # TODO! Raise exception
        return False

openhivenpy.types.relationship.Relationship

Represents a user-relationship with another user or bot

---

Possible Types:

0 - No Relationship

1 - Outgoing Friend Request

2 - Incoming Friend Request

3 - Friend

4 - Restricted User

5 - Blocked User

id: Optional[str] property readonly

json_schema

type: Optional[int] property readonly

user: Optional[User] property readonly

user_id: Optional[str] property readonly

Methods

__init__(self, data, client) special

Source code in openhivenpy\types\relationship.py

def __init__(self, data: dict, client: HivenClient):
    try:
        self._user_id = data.get('user_id')
        self._user = data.get('user')
        self._type = data.get('type')
        self._last_updated_at = data.get('last_updated_at')

    except Exception as e:
        raise InitializationError(f"Failed to initialise {self.__class__.__name__}") from e
    else:
        self._client = client

__repr__(self) special

Source code in openhivenpy\types\relationship.py

def __repr__(self) -> str:
    info = [
        ('id', self.id),
        ('user_id', self.user_id),
        ('user', repr(self.user)),
        ('type', self.type)
    ]
    return '<Relationship {}>'.format(' '.join('%s=%s' % t for t in info))

format_obj_data(data) classmethod

Validates the data and appends data if it is missing that would be required for the creation of an instance.

---

Does NOT contain other objects and only their ids!

:param data: Data that should be validated and used to form the object :return: The modified dictionary, which can then be used to create a new class instance

Source code in openhivenpy\types\relationship.py

@classmethod
def format_obj_data(cls, data: dict) -> dict:
    """
    Validates the data and appends data if it is missing that would be 
    required for the creation of an instance.

    ---

    Does NOT contain other objects and only their ids!

    :param data: Data that should be validated and used to form the object
    :return: The modified dictionary, which can then be used to create a
     new class instance
    """
    data = cls.validate(data)
    data['type'] = utils.safe_convert(int, data.get('type'))

    if not data.get('user_id') and data.get('user'):
        user = data.pop('user')
        if type(user) is dict:
            user_id = user.get('id')
        elif isinstance(user, DataClassObject):
            user_id = getattr(user, 'id', None)
        else:
            user_id = None

        if user_id is None:
            raise InvalidPassedDataError("The passed user is not in the correct format!", data=data)
        else:
            data['user_id'] = user_id
    elif not data.get('user_id') and not data.get('user'):
        raise InvalidPassedDataError("user_id and user missing from required data", data=data)

    data['user'] = data['user_id']
    return data

get_cached_data(self)

Fetches the most recent data from the cache based on the instance id

Source code in openhivenpy\types\relationship.py

def get_cached_data(self) -> Optional[dict]:
    """ Fetches the most recent data from the cache based on the instance id """
    return self._client.storage['relationships'][self.user_id]

json_validator(data)

openhivenpy.types.textroom.TextRoom

Represents a Hiven Room inside a House

---

Possible Types:

0 - Text

1 - Portal

description: Optional[str] property readonly

emoji: Optional[str] property readonly

house: Optional[House] property readonly

house_id: Optional[str] property readonly

id: Optional[str] property readonly

json_schema

name: Optional[str] property readonly

position: Optional[int] property readonly

type: Optional[int] property readonly

Methods

__init__(self, data, client) special

Source code in openhivenpy\types\textroom.py

def __init__(self, data: dict, client: HivenClient):
    try:
        self._id = data.get('id')
        self._name = data.get('name')
        self._house_id = data.get('house_id')
        self._position = data.get('position')
        self._type = data.get('type')
        self._emoji = data.get('emoji')
        self._description = data.get('description')
        self._last_message_id = data.get('last_message_id')
        self._house = data.get('house')

    except Exception as e:
        raise InitializationError(f"Failed to initialise {self.__class__.__name__}") from e
    else:
        self._client = client

__repr__(self) special

Source code in openhivenpy\types\textroom.py

def __repr__(self) -> str:
    info = [
        ('name', self.name),
        ('id', self.id),
        ('house_id', self.house_id),
        ('position', self.position),
        ('type', self.type),
        ('emoji', self.emoji),
        ('description', self.description)
    ]
    return str('<Room {}>'.format(' '.join('%s=%s' % t for t in info)))

edit(self, **kwargs) async

Changes the rooms data on Hiven

Available options: emoji, name, description

:return: True if the request was successful else False

Source code in openhivenpy\types\textroom.py

async def edit(self, **kwargs) -> bool:
    """
    Changes the rooms data on Hiven

    Available options: emoji, name, description

    :return: True if the request was successful else False
    """
    try:
        for key in kwargs.keys():
            if key in ['emoji', 'name', 'description']:
                await self._client.http.patch(f"/rooms/{self.id}", json={key: kwargs.get(key)})

                return True
            else:
                raise NameError("The passed value does not exist in the Room!")

    except Exception as e:
        keys = "".join(key + " " for key in kwargs.keys()) if kwargs != {} else ''
        utils.log_traceback(
            brief=f"Failed to change the values {keys} in room {repr(self)}: ",
            exc_info=sys.exc_info()
        )
        # TODO! Raise exception
        return False

format_obj_data(data) classmethod

Validates the data and appends data if it is missing that would be required for the creation of an instance.

:param data: Data that should be validated and used to form the object :return: The modified dictionary, which can then be used to create a new class instance

Source code in openhivenpy\types\textroom.py

@classmethod
def format_obj_data(cls, data: dict) -> dict:
    """
    Validates the data and appends data if it is missing that would be
    required for the creation of an instance.

    :param data: Data that should be validated and used to form the object
    :return: The modified dictionary, which can then be used to create a 
     new class instance
    """
    if not data.get('house_id') and data.get('house'):
        house = data.pop('house')
        if type(house) is dict:
            house_id = house.get('id')
        elif isinstance(house, DataClassObject):
            house_id = getattr(house, 'id', None)
        else:
            house_id = None

        if house_id is None:
            raise InvalidPassedDataError("The passed house is not in the correct format!", data=data)
        else:
            data['house_id'] = house_id

    data['house'] = data['house_id']
    data = cls.validate(data)
    return data

get_cached_data(self)

Fetches the most recent data from the cache based on the instance id

Source code in openhivenpy\types\textroom.py

def get_cached_data(self) -> Optional[dict]:
    """ Fetches the most recent data from the cache based on the instance id """
    return self._client.storage['rooms']['house'][self.id]

get_recent_messages(self) async

Gets the recent messages from the current room

:return: A list of all messages in form of Message instances if successful.

Source code in openhivenpy\types\textroom.py

async def get_recent_messages(self) -> Optional[List[Message]]:
    """
    Gets the recent messages from the current room

    :return: A list of all messages in form of Message instances if successful.
    """
    try:
        raw_data = await self._client.http.get(f"/rooms/{self.id}/messages")
        raw_data = await raw_data.json()

        data = raw_data.get('data')

        messages_ = []
        for _ in data:
            msg = Message(_, self._client)
            messages_.append(msg)

        return messages_

    except Exception as e:
        utils.log_traceback(
            brief=f"Failed to create invite for house {repr(self)}:",
            exc_info=sys.exc_info()
        )
        # TODO! Raise exception
        return None

json_validator(data)

send(self, content, delay=None) async

Sends a message in the current room.

:param content: Content of the message :param delay: Seconds to wait until sending the message (in seconds) :return: A new message object if the request was successful

Source code in openhivenpy\types\textroom.py

async def send(self, content: str, delay: float = None) -> Optional[Message]:
    """
    Sends a message in the current room.

    :param content: Content of the message
    :param delay: Seconds to wait until sending the message (in seconds)
    :return: A new message object if the request was successful
    """
    try:
        if delay is not None:
            await asyncio.sleep(delay=delay)
        resp = await self._client.http.post(
            f"/rooms/{self.id}/messages",
            json={"content": content}
        )
        raw_data = await resp.json()

        # Raw_data not in correct format => needs to access data field
        data = raw_data.get('data')
        data = Message.format_obj_data(data)
        return Message(data, self._client)

    except Exception as e:
        utils.log_traceback(
            brief=f"Failed to send message in room {repr(self)}",
            exc_info=sys.exc_info()
        )
        # TODO! Raise exception
        return None

start_typing(self) async

Adds the client to the list of users typing

:return: True if the request was successful else False

Source code in openhivenpy\types\textroom.py

async def start_typing(self) -> bool:
    """
    Adds the client to the list of users typing

    :return: True if the request was successful else False
    """
    try:
        await self._client.http.post(f"/rooms/{self.id}/typing")

        return True

    except Exception as e:
        utils.log_traceback(
            brief=f"Failed to create invite for house {repr(self)}:",
            exc_info=sys.exc_info()
        )
        # TODO! Raise exception
        return False

openhivenpy.types.user.User

Represents the regular extended Hiven User

blocked: Optional[bool] property readonly

email: Optional[str] property readonly

json_schema

location: Optional[str] property readonly

mfa_enabled: Optional[bool] property readonly

presence: Optional[str] property readonly

website: Optional[str] property readonly

Methods

__init__(self, data, client) special

Source code in openhivenpy\types\user.py

def __init__(self, data: dict, client: HivenClient):
    try:
        super().__init__(data, client)
        self._location = data.get('location')
        self._website = data.get('website')
        self._blocked = data.get('blocked')
        self._presence = data.get('presence')
        self._email = data.get('email')
        self._mfa_enabled = data.get('mfa_enabled')

    except Exception as e:
        raise InitializationError(
            f"Failed to initialise {self.__class__.__name__}"
        ) from e

__repr__(self) special

Source code in openhivenpy\types\user.py

def __repr__(self) -> str:
    info = [
        ('username', self.username),
        ('name', self.name),
        ('id', self.id),
        ('icon', self.icon),
        ('header', self.header),
        ('bot', self.bot)
    ]
    return '<User {}>'.format(' '.join('%s=%s' % t for t in info))

format_obj_data(data) classmethod

Validates the data and appends data if it is missing that would be required for the creation of an instance.

:param data: Data that should be validated and used to form the object :return: The modified dictionary, which can then be used to create a new class instance

Source code in openhivenpy\types\user.py

@classmethod
def format_obj_data(cls, data: dict) -> dict:
    """
    Validates the data and appends data if it is missing that would be 
    required for the creation of an instance.

    :param data: Data that should be validated and used to form the object
    :return: The modified dictionary, which can then be used to create a 
     new class instance
    """
    data = LazyUser.format_obj_data(data)
    data = cls.validate(data)
    return data

get_cached_data(self)

Fetches the most recent data from the cache based on the instance id

Source code in openhivenpy\types\user.py

def get_cached_data(self) -> Optional[dict]:
    """ Fetches the most recent data from the cache based on the instance id """
    return self._client.storage['users'][self.id]

json_validator(data)

openhivenpy.types.usertyping.UserTyping

Represents a Hiven User typing in a room

author: Optional[User] property readonly

author_id: Optional[str] property readonly

house: Optional[House] property readonly

house_id: Optional[str] property readonly

room: Optional[TextRoom] property readonly

room_id: Optional[str] property readonly

timestamp: Optional[datetime.datetime] property readonly

__init__(self, data, client) special

Source code in openhivenpy\types\usertyping.py

def __init__(self, data: dict, client: HivenClient):
    try:
        self._author = data.get('author')
        self._room = data.get('room')
        self._house = data.get('house')
        self._author_id = data.get('author_id')
        self._house_id = data.get('house_id')
        self._room_id = data.get('room_id')
        self._timestamp = data.get('timestamp')

    except Exception as e:
        raise InitializationError(
            f"Failed to initialise {self.__class__.__name__}"
        ) from e
    else:
        self._client = client

__repr__(self) special

Source code in openhivenpy\types\usertyping.py

def __repr__(self) -> str:
    info = [
        ('house_id', self.house_id),
        ('author_id', self.author_id),
        ('room_id', self.room_id),
        ('author', repr(self.author))
    ]
    return '<Typing {}>'.format(' '.join('%s=%s' % t for t in info))

---

Last update: 2021-08-21