def from_dict(cls, event_dict): event_id = sanitize_id(event_dict["event_id"]) sender = sanitize_id(event_dict["sender"]) leaving_user = sanitize_id(event_dict["state_key"]) timestamp = sanitize_ts(event_dict["origin_server_ts"]) return cls(event_id, sender, leaving_user, timestamp)
def from_dict(cls, event_dict): event_id = sanitize_id(event_dict["event_id"]) sender = sanitize_id(event_dict["sender"]) timestamp = sanitize_ts(event_dict["origin_server_ts"]) name = sanitize_string(event_dict['content']['name']) return cls(event_id, sender, timestamp, name)
def from_dict(cls, event_dict): event_id = sanitize_id(event_dict["event_id"]) sender = sanitize_id(event_dict["sender"]) timestamp = sanitize_ts(event_dict["origin_server_ts"]) canonical_alias = sanitize_id(event_dict["content"]["alias"]) return cls(event_id, sender, timestamp, canonical_alias)
def from_dict(cls, event_dict): event_id = sanitize_id(event_dict["event_id"]) sender = sanitize_id(event_dict["sender"]) timestamp = sanitize_ts(event_dict["origin_server_ts"]) topic = sanitize_text(event_dict["content"]["topic"]) return cls(event_id, sender, timestamp, topic)
def from_dict(cls, server, parsed_dict): try: return cls(server, sanitize_id(parsed_dict["user_id"]), sanitize_id(parsed_dict["device_id"]), sanitize_token(parsed_dict["access_token"])) except (KeyError, TypeError, ValueError): return MatrixErrorEvent.from_dict(server, "Error logging in", True, parsed_dict)
def from_dict(cls, event): event_id = sanitize_id(event["event_id"]) sender = sanitize_id(event["sender"]) timestamp = sanitize_ts(event["origin_server_ts"]) mxc_url = sanitize_text(event['content']['url']) description = sanitize_text(event["content"]["body"]) return cls(event_id, sender, timestamp, mxc_url, description)
def from_dict(cls, event): event_id = sanitize_id(event["event_id"]) sender = sanitize_id(event["sender"]) timestamp = sanitize_ts(event["origin_server_ts"]) message = sanitize_text(event["content"]["body"]) message_type = sanitize_text(event["content"]["msgtype"]) return cls(event_id, sender, timestamp, message, message_type)
def from_dict(cls, event_dict): event_id = sanitize_id(event_dict["event_id"]) sender = sanitize_id(event_dict["sender"]) timestamp = sanitize_ts(event_dict["origin_server_ts"]) power_levels = [] for user, level in event_dict["content"]["users"].items(): power_levels.append( PowerLevel(sanitize_id(user), sanitize_power_level(level))) return cls(event_id, sender, timestamp, power_levels)
def from_dict(cls, event_dict): event_id = sanitize_id(event_dict["event_id"]) sender = sanitize_id(event_dict["sender"]) timestamp = sanitize_ts(event_dict["origin_server_ts"]) redaction_id = sanitize_id(event_dict["redacts"]) reason = (sanitize_text(event_dict["content"]["reason"]) if "reason" in event_dict["content"] else None) return cls(event_id, sender, timestamp, redaction_id, reason)
def from_dict(cls, event_dict): event_id = sanitize_id(event_dict["event_id"]) sender = sanitize_id(event_dict["sender"]) timestamp = sanitize_ts(event_dict["origin_server_ts"]) display_name = None if event_dict["content"]: if "display_name" in event_dict["content"]: display_name = sanitize_text( event_dict["content"]["displayname"]) return cls(event_id, sender, timestamp, display_name)
def from_dict(cls, event): event_id = sanitize_id(event["event_id"]) sender = sanitize_id(event["sender"]) timestamp = sanitize_ts(event["origin_server_ts"]) censor = sanitize_id(event['unsigned']['redacted_because']['sender']) reason = None if 'reason' in event['unsigned']['redacted_because']['content']: reason = sanitize_text( event['unsigned']['redacted_because']['content']['reason']) return cls(event_id, sender, timestamp, censor, reason)
def from_dict(cls, server, room_id, reason, parsed_dict): try: return cls(server, room_id, sanitize_id(parsed_dict["event_id"]), reason) except (KeyError, TypeError, ValueError): return MatrixErrorEvent.from_dict(server, "Error redacting message", False, parsed_dict)
def from_dict(cls, server, room_id, topic, parsed_dict): try: return cls(server, room_id, sanitize_id(parsed_dict["event_id"]), topic) except (KeyError, TypeError, ValueError): return MatrixErrorEvent.from_dict(server, "Error setting topic", False, parsed_dict)
def from_dict(cls, event): event_id = sanitize_id(event["event_id"]) sender = sanitize_id(event["sender"]) timestamp = sanitize_ts(event["origin_server_ts"]) msg = "" formatted_msg = None msg = sanitize_text(event['content']['body']) if ('format' in event['content'] and 'formatted_body' in event['content']): if event['content']['format'] == "org.matrix.custom.html": formatted_msg = Formatted.from_html( sanitize_text(event['content']['formatted_body'])) return cls(event_id, sender, timestamp, msg, formatted_msg)
def from_dict(cls, server, room_id, parsed_dict): try: return cls( server, room_id, sanitize_id(parsed_dict["room_id"]), ) except (KeyError, TypeError, ValueError): return MatrixErrorEvent.from_dict(server, "Error joining room", False, parsed_dict)
def from_dict(cls, room_id, parsed_dict): prev_batch = sanitize_id(parsed_dict['timeline']['prev_batch']) state_dict = parsed_dict['state']['events'] timeline_dict = parsed_dict['timeline']['events'] state_events = RoomInfo._parse_events(state_dict, messages=False) timeline_events = RoomInfo._parse_events(timeline_dict) events = state_events + timeline_events return cls(room_id, prev_batch, list(filter(None, events)))
def from_dict(cls, server, parsed_dict): try: next_batch = sanitize_id(parsed_dict["next_batch"]) room_info_dict = parsed_dict["rooms"] join_infos, invite_infos = MatrixSyncEvent._infos_from_dict( room_info_dict) return cls(server, next_batch, join_infos, invite_infos) except (KeyError, ValueError, TypeError): return MatrixErrorEvent.from_dict(server, "Error syncing", False, parsed_dict)
def from_dict(cls, server, room_id, message, parsed_dict): try: event_id = sanitize_id(parsed_dict["event_id"]) sender = server.user_id age = 0 plain_message = message.to_plain() formatted_message = message message = RoomMessageEmote(event_id, sender, age, plain_message, formatted_message) return cls(server, room_id, message) except (KeyError, TypeError, ValueError): return MatrixErrorEvent.from_dict(server, "Error sending message", False, parsed_dict)
def from_dict(cls, server, room_id, parsed_dict): try: end_token = sanitize_id(parsed_dict["end"]) if not parsed_dict["chunk"]: return cls(server, room_id, end_token, []) event_func = partial(MatrixBacklogEvent._room_event_from_dict, room_id) message_events = list( filter(lambda event: event["type"] == "m.room.message", parsed_dict["chunk"])) events = [event_func(m) for m in message_events] return cls(server, room_id, end_token, events) except (KeyError, ValueError, TypeError): return MatrixErrorEvent.from_dict(server, "Error fetching backlog", False, parsed_dict)