def __init__(self, controller: Any) -> None:
self.controller = controller
self.client = controller.client
self.msg_view = None # type: Any
self.msg_list = None # type: Any
self.narrow = [] # type: List[Any]
self._have_last_message = {} # type: Dict[str, bool]
self.stream_id = -1
self.recipients = frozenset() # type: FrozenSet[Any]
self.index = initial_index
self.user_id = -1
self.user_email = ""
self.user_full_name = ""
self.server_url = '{uri.scheme}://{uri.netloc}/'.format(
uri=urlparse(self.client.base_url))
self.server_name = ""
self._notified_user_of_notification_failure = False
self.event_actions = OrderedDict([
('message', self._handle_message_event),
('update_message', self._handle_update_message_event),
('reaction', self._handle_reaction_event),
('subscription', self._handle_subscription_event),
('typing', self._handle_typing_event),
('update_message_flags', self._handle_update_message_flags_event),
]) # type: OrderedDict[str, Callable[[Event], None]]
self.initial_data = {} # type: Dict[str, Any]
# Register to the queue before initializing further so that we don't
# lose any updates while messages are being fetched.
self._update_initial_data()
self.server_version = self.initial_data['zulip_version']
self.server_feature_level = (
self.initial_data.get('zulip_feature_level'))
self.users = self.get_all_users()
subscriptions = self.initial_data['subscriptions']
stream_data = Model._stream_info_from_subscriptions(subscriptions)
(self.stream_dict, self.muted_streams, self.pinned_streams,
self.unpinned_streams) = stream_data
self.muted_topics = (self.initial_data['muted_topics']
) # type: List[List[str]]
groups = self.initial_data['realm_user_groups']
self.user_group_by_id = {} # type: Dict[int, Dict[str, Any]]
self.user_group_names = self._group_info_from_realm_user_groups(groups)
self.unread_counts = classify_unread_counts(self)
self.fetch_all_topics(workers=5)
self.new_user_input = True
self._start_presence_updates()
def __init__(self, controller: Any) -> None:
self.controller = controller
self.client = controller.client
# Get message after registering to the queue.
self.msg_view = None # type: Any
self.anchor = 0
self.num_before = 30
self.num_after = 10
self.msg_list = None # type: Any
self.narrow = [] # type: List[Any]
self.update = False
self.stream_id = -1
self.stream_dict = {} # type: Dict[int, Any]
self.recipients = frozenset() # type: FrozenSet[Any]
self.index = None # type: Any
self.user_id = -1 # type: int
self.initial_data = {} # type: Dict[str, Any]
self._update_user_id()
self._update_initial_data()
self.users = self.get_all_users()
self.muted_streams = list() # type: List[int]
self.streams = self.get_subscribed_streams()
self.muted_topics = self.initial_data['muted_topics']
self.unread_counts = classify_unread_counts(self)
self.new_user_input = True
self.update_presence()
def test_classify_unread_counts(mocker, initial_data, stream_dict,
classified_unread_counts, muted_topics,
muted_streams, vary_in_unreads):
model = mocker.Mock()
model.stream_dict = stream_dict
model.initial_data = initial_data
model.muted_topics = muted_topics
model.muted_streams = muted_streams
assert classify_unread_counts(model) == dict(classified_unread_counts,
**vary_in_unreads)
def test_classify_unread_counts(mocker, initial_data, stream_dict,
classified_unread_counts, muted_topics,
muted_streams, vary_in_unreads):
model = mocker.Mock()
model.stream_dict = stream_dict
model.initial_data = initial_data
model.is_muted_topic = mocker.Mock(side_effect=(
lambda stream_id, topic: [model.stream_dict[stream_id]['name'], topic
] in muted_topics))
model.muted_streams = muted_streams
assert classify_unread_counts(model) == dict(classified_unread_counts,
**vary_in_unreads)
def __init__(self, controller: Any) -> None:
self.controller = controller
self.client = controller.client
self.msg_view = None # type: Any
self.msg_list = None # type: Any
self.narrow = [] # type: List[Any]
self.found_newest = False
self.stream_id = -1
self.recipients = frozenset() # type: FrozenSet[Any]
self.index = initial_index
self.user_id = -1 # type: int
self.user_email = ""
self.user_full_name = ""
self.server_url = '{uri.scheme}://{uri.netloc}/'.format(
uri=urlparse(self.client.base_url))
self.event_actions = OrderedDict([
('message', self.append_message),
('update_message', self.update_message),
('reaction', self.update_reaction),
('subscription', self.update_subscription),
('typing', self.handle_typing_event),
('update_message_flags', self.update_message_flag_status),
]) # type: OrderedDict[str, Callable[[Event], None]]
self.initial_data = {} # type: Dict[str, Any]
# Register to the queue before initializing further so that we don't
# lose any updates while messages are being fetched.
self._update_initial_data()
self.users = self.get_all_users()
subscriptions = self.initial_data['subscriptions']
stream_data = Model._stream_info_from_subscriptions(subscriptions)
(self.stream_dict, self.muted_streams, self.pinned_streams,
self.unpinned_streams) = stream_data
self.muted_topics = self.initial_data['muted_topics']
self.unread_counts = classify_unread_counts(self)
self.fetch_all_topics(workers=5)
self.new_user_input = True
self._start_presence_updates()
def test_classify_unread_counts(
mocker: MockerFixture,
initial_data: Dict[str, Any],
stream_dict: Dict[int, Dict[str, Any]],
classified_unread_counts: Dict[str, Any],
muted_topics: List[List[str]],
muted_streams: Set[int],
vary_in_unreads: Dict[str, Any],
) -> None:
model = mocker.Mock()
model.stream_dict = stream_dict
model.initial_data = initial_data
model.is_muted_topic = mocker.Mock(side_effect=(
lambda stream_id, topic: [model.stream_dict[stream_id]["name"], topic
] in muted_topics))
model.muted_streams = muted_streams
assert classify_unread_counts(model) == dict(classified_unread_counts,
**vary_in_unreads)
def __init__(self, controller: Any) -> None:
self.controller = controller
self.client = controller.client
self.msg_view = None # type: Any
self.msg_list = None # type: Any
self.narrow = [] # type: List[Any]
self.update = False
self.stream_id = -1
self.recipients = frozenset() # type: FrozenSet[Any]
self.index = initial_index
self.user_id = -1 # type: int
self.initial_data = {} # type: Dict[str, Any]
# Register to the queue before initializing further so that we don't
# lose any updates while messages are being fetched.
self._update_initial_data()
self.users = self.get_all_users()
subscriptions = self.initial_data['subscriptions']
stream_data = Model._stream_info_from_subscriptions(subscriptions)
(self.stream_dict, self.muted_streams,
self.pinned_streams, self.unpinned_streams) = stream_data
self.muted_topics = self.initial_data['muted_topics']
self.unread_counts = classify_unread_counts(self)
self.new_user_input = True
self.update_presence()
self.event_actions = {
'message': self.append_message,
'update_message': self.update_message,
'reaction': self.update_reaction,
'typing': self.handle_typing_event,
'update_message_flags': self.update_star_status,
} # type: Dict[str, Callable[[Event], None]]
def __init__(self, controller: Any) -> None:
self.controller = controller
self.client = controller.client
self.narrow = [] # type: List[Any]
self._have_last_message = {} # type: Dict[str, bool]
self.stream_id = -1
self.recipients = frozenset() # type: FrozenSet[Any]
self.index = initial_index
self.user_id = -1
self.user_email = ""
self.user_full_name = ""
self.server_url = '{uri.scheme}://{uri.netloc}/'.format(
uri=urlparse(self.client.base_url))
self.server_name = ""
self._notified_user_of_notification_failure = False
self.event_actions = OrderedDict([
('message', self._handle_message_event),
('update_message', self._handle_update_message_event),
('reaction', self._handle_reaction_event),
('subscription', self._handle_subscription_event),
('typing', self._handle_typing_event),
('update_message_flags', self._handle_update_message_flags_event),
]) # type: OrderedDict[str, Callable[[Event], None]]
self.initial_data = {} # type: Dict[str, Any]
# Register to the queue before initializing further so that we don't
# lose any updates while messages are being fetched.
self._update_initial_data()
self.server_version = self.initial_data['zulip_version']
self.server_feature_level = (
self.initial_data.get('zulip_feature_level')
)
self.users = self.get_all_users()
subscriptions = self.initial_data['subscriptions']
stream_data = Model._stream_info_from_subscriptions(subscriptions)
(self.stream_dict, self.muted_streams,
self.pinned_streams, self.unpinned_streams) = stream_data
# NOTE: The expected response has been upgraded from
# [stream_name, topic] to [stream_name, topic, date_muted] in
# feature level 1, server version 3.0.
muted_topics = self.initial_data['muted_topics']
assert set(map(len, muted_topics)) in (set(), {2}, {3})
self._muted_topics = {
(stream_name, topic): (None if self.server_feature_level is None
else date_muted[0])
for stream_name, topic, *date_muted in muted_topics
} # type: Dict[Tuple[str, str], Optional[int]]
groups = self.initial_data['realm_user_groups']
self.user_group_by_id = {} # type: Dict[int, Dict[str, Any]]
self.user_group_names = self._group_info_from_realm_user_groups(groups)
self.unread_counts = classify_unread_counts(self)
self._draft = None # type: Optional[Message]
unicode_emoji_data = unicode_emojis.EMOJI_DATA
for name, data in unicode_emoji_data.items():
data['type'] = 'unicode_emoji'
typed_unicode_emoji_data = cast(NamedEmojiData, unicode_emoji_data)
custom_emoji_data = self.fetch_custom_emojis()
zulip_extra_emoji = {
'zulip': {'code': 'zulip', 'type': 'zulip_extra_emoji'}
} # type: NamedEmojiData
all_emoji_data = {**typed_unicode_emoji_data,
**custom_emoji_data,
**zulip_extra_emoji}.items()
self.active_emoji_data = OrderedDict(sorted(all_emoji_data,
key=lambda e: e[0]))
self.new_user_input = True
self._start_presence_updates()
