:orphan:

:py:mod:`slidge.group.participant`
==================================

.. py:module:: slidge.group.participant


Module Contents
---------------

Classes
~~~~~~~

.. autoapisummary::

   slidge.group.participant.LegacyParticipant




.. py:class:: LegacyParticipant(muc, nickname = None, is_user=False, is_system=False)




   A legacy participant of a legacy group chat.

   .. py:method:: send_initial_presence(full_jid, nick_change=False, presence_id = None)

      Called when the user joins a MUC, as a mechanism
      to indicate to the joining XMPP client the list of "participants".

      Can be called this to trigger a "participant has joined the group" event.

      :param full_jid: Set this to only send to a specific user XMPP resource.
      :param nick_change: Used when the user joins and the MUC renames them (code 210)
      :param presence_id: set the presence ID. used internally by slidge


   .. py:method:: leave()

      Call this when the participant leaves the room


   .. py:method:: kick()

      Call this when the participant is kicked from the room


   .. py:method:: ban()

      Call this when the participant is banned from the room


   .. py:method:: online(status = None, last_seen = None)

      Send an "online" presence from this contact to the user.

      :param status: Arbitrary text, details of the status, eg: "Listening to Britney Spears"
      :param last_seen: For :xep:`0319`


   .. py:method:: away(status = None, last_seen = None)

      Send an "away" presence from this contact to the user.

      This is a global status, as opposed to :meth:`.LegacyContact.inactive`
      which concerns a specific conversation, ie a specific "chat window"

      :param status: Arbitrary text, details of the status, eg: "Gone to fight capitalism"
      :param last_seen: For :xep:`0319`


   .. py:method:: extended_away(status = None, last_seen = None)

      Send an "extended away" presence from this contact to the user.

      This is a global status, as opposed to :meth:`.LegacyContact.inactive`
      which concerns a specific conversation, ie a specific "chat window"

      :param status: Arbitrary text, details of the status, eg: "Gone to fight capitalism"
      :param last_seen: For :xep:`0319`


   .. py:method:: busy(status = None, last_seen = None)

      Send a "busy" (ie, "dnd") presence from this contact to the user,

      :param status: eg: "Trying to make sense of XEP-0100"
      :param last_seen: For :xep:`0319`


   .. py:method:: offline(status = None, last_seen = None)

      Send an "offline" presence from this contact to the user.

      :param status: eg: "Trying to make sense of XEP-0100"
      :param last_seen: For :xep:`0319`


   .. py:method:: invite_to(muc, reason = None, password = None, **send_kwargs)

      Send an invitation to join a group (:xep:`0249`) from this :term:`XMPP Entity`.

      :param muc: the muc the user is invited to
      :param reason: a text explaining why the user should join this muc
      :param password: maybe this will make sense later? not sure
      :param send_kwargs: additional kwargs to be passed to _send()
          (internal use by slidge)


   .. py:method:: active(**kwargs)

      Send an "active" chat state (:xep:`0085`) from this
      :term:`XMPP Entity`.


   .. py:method:: composing(**kwargs)

      Send a "composing" (ie "typing notification") chat state (:xep:`0085`)
      from this :term:`XMPP Entity`.


   .. py:method:: paused(**kwargs)

      Send a "paused" (ie "typing paused notification") chat state
      (:xep:`0085`) from this :term:`XMPP Entity`.


   .. py:method:: inactive(**kwargs)

      Send an "inactive" (ie "contact has not interacted with the chat session
      interface for an intermediate period of time") chat state (:xep:`0085`)
      from this :term:`XMPP Entity`.


   .. py:method:: gone(**kwargs)

      Send a "gone" (ie "contact has not interacted with the chat session interface,
      system, or device for a relatively long period of time") chat state
      (:xep:`0085`) from this :term:`XMPP Entity`.


   .. py:method:: ack(legacy_msg_id, **kwargs)

      Send an "acknowledged" message marker (:xep:`0333`) from this :term:`XMPP Entity`.

      :param legacy_msg_id: The message this marker refers to


   .. py:method:: received(legacy_msg_id, **kwargs)

      Send a "received" message marker (:xep:`0333`) from this :term:`XMPP Entity`.
      If called on a :class:`LegacyContact`, also send a delivery receipt
      marker (:xep:`0184`).

      :param legacy_msg_id: The message this marker refers to


   .. py:method:: displayed(legacy_msg_id, **kwargs)

      Send a "displayed" message marker (:xep:`0333`) from this :term:`XMPP Entity`.

      :param legacy_msg_id: The message this marker refers to


   .. py:method:: send_text(body, legacy_msg_id = None, *, when = None, reply_to = None, thread = None, hints = None, carbon=False, archive_only=False, correction=False, correction_event_id = None, link_previews = None, **send_kwargs)

      Send a text message from this :term:`XMPP Entity`.

      :param body: Content of the message
      :param legacy_msg_id: If you want to be able to transport read markers from the gateway
          user to the legacy network, specify this
      :param when: when the message was sent, for a "delay" tag (:xep:`0203`)
      :param reply_to: Quote another message (:xep:`0461`)
      :param hints:
      :param thread:
      :param carbon: (only used if called on a :class:`LegacyContact`)
          Set this to ``True`` if this is actually a message sent **to** the
          :class:`LegacyContact` by the :term:`User`.
          Use this to synchronize outgoing history for legacy official apps.
      :param correction: whether this message is a correction or not
      :param correction_event_id: in the case where an ID is associated with the legacy
          'correction event', specify it here to use it on the XMPP side. If not specified,
          a random ID will be used.
      :param link_previews: A little of sender (or server, or gateway)-generated
          previews of URLs linked in the body.
      :param archive_only: (only in groups) Do not send this message to user,
          but store it in the archive. Meant to be used during ``MUC.backfill()``


   .. py:method:: correct(legacy_msg_id, new_text, *, when = None, reply_to = None, thread = None, hints = None, carbon=False, archive_only=False, correction_event_id = None, link_previews = None, **send_kwargs)

      Modify a message that was previously sent by this :term:`XMPP Entity`.

      Uses last message correction (:xep:`0308`)

      :param new_text: New content of the message
      :param legacy_msg_id: The legacy message ID of the message to correct
      :param when: when the message was sent, for a "delay" tag (:xep:`0203`)
      :param reply_to: Quote another message (:xep:`0461`)
      :param hints:
      :param thread:
      :param carbon: (only in 1:1) Reflect a message sent to this ``Contact`` by the user.
          Use this to synchronize outgoing history for legacy official apps.
      :param archive_only: (only in groups) Do not send this message to user,
          but store it in the archive. Meant to be used during ``MUC.backfill()``
      :param correction_event_id: in the case where an ID is associated with the legacy
          'correction event', specify it here to use it on the XMPP side. If not specified,
          a random ID will be used.
      :param link_previews: A little of sender (or server, or gateway)-generated
          previews of URLs linked in the body.


   .. py:method:: react(legacy_msg_id, emojis = (), thread = None, **kwargs)

      Send a reaction (:xep:`0444`) from this :term:`XMPP Entity`.

      :param legacy_msg_id: The message which the reaction refers to.
      :param emojis: An iterable of emojis used as reactions
      :param thread:


   .. py:method:: retract(legacy_msg_id, thread = None, **kwargs)

      Send a message retraction (:XEP:`0424`) from this :term:`XMPP Entity`.

      :param legacy_msg_id: Legacy ID of the message to delete
      :param thread:


   .. py:method:: send_file(file_path = None, legacy_msg_id = None, *, data_stream = None, data = None, file_url = None, file_name = None, content_type = None, reply_to = None, when = None, caption = None, legacy_file_id = None, thread = None, **kwargs)
      :async:

      Send a single file from this :term:`XMPP Entity`.

      :param file_path: Path to the attachment
      :param data_stream: Alternatively, a stream of bytes (such as a File object)
      :param data: Alternatively, a bytes object
      :param file_url: Alternatively, a URL
      :param file_name: How the file should be named.
      :param content_type: MIME type, inferred from filename if not given
      :param legacy_msg_id: If you want to be able to transport read markers from the gateway
          user to the legacy network, specify this
      :param reply_to: Quote another message (:xep:`0461`)
      :param when: when the file was sent, for a "delay" tag (:xep:`0203`)
      :param caption: an optional text that is linked to the file
      :param legacy_file_id: A unique identifier for the file on the legacy network.
           Plugins should try their best to provide it, to avoid duplicates.
      :param thread:



