use properties instead of stupid get/set methods

9 files changed, 55 insertions, 104 deletions

diff --git a/vk/api.py b/vk/api.py
index 041f0bd..84efd91 100644
--- a/vk/api.py
+++ b/vk/api.py
@@ -138,7 +138,7 @@ class API:
         user_list = map(User.from_api_response, user_list)
         if deactivated_users:
             return user_list
-        return [user for user in user_list if not user.is_deactivated()]
+        return [user for user in user_list if not user.is_deactivated]
 
     def users_get(self, user_ids, fields=(), deactivated_users=True):
         return self._filter_response_with_users(
diff --git a/vk/last_seen.py b/vk/last_seen.py
index 6c373d3..e5584eb 100644
--- a/vk/last_seen.py
+++ b/vk/last_seen.py
@@ -80,20 +80,14 @@ class LastSeen(MutableMapping):
 
     _DEFAULT_FIELD_PARSER = str
 
-    def has_time(self):
-        return LastSeenField.TIME in self
-
-    def get_time(self):
+    @property
+    def time(self):
         return self[LastSeenField.TIME]
 
-    def set_time(self, time):
-        self[LastSeenField.TIME] = time
-
-    def has_platform(self):
-        return LastSeenField.PLATFORM in self
+    @property
+    def time_local(self):
+        return self.time.astimezone()
 
-    def get_platform(self):
+    @property
+    def platform(self):
         return self[LastSeenField.PLATFORM]
-
-    def set_platform(self, platform):
-        self[LastSeenField.PLATFORM] = platform
diff --git a/vk/mutuals.py b/vk/mutuals.py
index 062d07c..1332162 100644
--- a/vk/mutuals.py
+++ b/vk/mutuals.py
@@ -18,7 +18,7 @@ _OUTPUT_USER_FIELDS = UserField.UID, UserField.FIRST_NAME, UserField.LAST_NAME
 
 
 def _query_friend_list(api, user):
-    return api.friends_get(user.get_uid(), fields=_OUTPUT_USER_FIELDS)
+    return api.friends_get(user.uid, fields=_OUTPUT_USER_FIELDS)
 
 
 def _filter_user_fields(user):
diff --git a/vk/platform.py b/vk/platform.py
index e7ca38a..2664c39 100644
--- a/vk/platform.py
+++ b/vk/platform.py
@@ -24,22 +24,10 @@ class Platform(Enum):
     def __str__(self):
         return str(self.value)
 
-    @staticmethod
-    def _capitalize_first_letter(s):
-        m = re.search(r'\w', s)
-        if m is None:
-            return s
-        return s[: m.start()] + m.group().upper() + s[m.end() :]
-
-    def get_descr_header(self):
-        return self._capitalize_first_letter(_PLATFORM_DESCRIPTIONS[self])
-
-    def get_descr_text(self):
+    @property
+    def descr(self):
         return f'the {_PLATFORM_DESCRIPTIONS[self]}'
 
-    def get_descr_text_capitalized(self):
-        return self._capitalize_first_letter(self.get_descr_text())
-
 
 _PLATFORM_DESCRIPTIONS = {
     Platform.MOBILE: '"mobile" web version (or an unrecognized mobile app)',
diff --git a/vk/tracking/db/backend/log.py b/vk/tracking/db/backend/log.py
index 0cc8a63..0ffee5c 100644
--- a/vk/tracking/db/backend/log.py
+++ b/vk/tracking/db/backend/log.py
@@ -47,7 +47,7 @@ class Writer(meta.Writer):
 
     def on_initial_status(self, user):
         self._reset_last_notification()
-        if user.is_online():
+        if user.is_online:
             self.info(self._format_user_is_online(user))
         else:
             self.info(self._format_user_is_offline(user))
@@ -55,7 +55,7 @@ class Writer(meta.Writer):
 
     def on_status_update(self, user):
         self._reset_last_notification()
-        if user.is_online():
+        if user.is_online:
             self.info(self._format_user_went_online(user))
         else:
             self.info(self._format_user_went_offline(user))
@@ -70,37 +70,24 @@ class Writer(meta.Writer):
         self.exception(e)
 
     @staticmethod
-    def _format_user(user):
-        if user.has_last_name():
-            return f'{user.get_first_name()} {user.get_last_name()}'
-        return f'{user.get_first_name()}'
-
-    @staticmethod
     def _format_user_is_online(user):
-        user = Writer._format_user(user)
-        return f'{user} is ONLINE.'
+        return f'{user.full_name} is ONLINE.'
 
     @staticmethod
     def _format_user_is_offline(user):
-        user = Writer._format_user(user)
-        return f'{user} is OFFLINE.'
+        return f'{user.full_name} is OFFLINE.'
 
     @staticmethod
     def _format_user_last_seen(user):
-        last_seen = user.get_last_seen_time_local()
-        platform = user.get_last_seen_platform().get_descr_text()
-        user = Writer._format_user(user)
-        return f'{user} was last seen at {last_seen} using {platform}.'
+        return f'{user.full_name} was last seen at {user.last_seen.time_local} using {user.last_seen.platform.descr}.'
 
     @staticmethod
     def _format_user_went_online(user):
-        user = Writer._format_user(user)
-        return f'{user} went ONLINE.'
+        return f'{user.full_name} went ONLINE.'
 
     @staticmethod
     def _format_user_went_offline(user):
-        user = Writer._format_user(user)
-        return f'{user} went OFFLINE.'
+        return f'{user.full_name} went OFFLINE.'
 
     @staticmethod
     def _format_another_connection_error(e):
diff --git a/vk/tracking/db/record.py b/vk/tracking/db/record.py
index b641a67..86a417f 100644
--- a/vk/tracking/db/record.py
+++ b/vk/tracking/db/record.py
@@ -73,7 +73,7 @@ class Record(MutableMapping):
             if isinstance(field, UserField):
                 record[field] = user[field]
             elif isinstance(field, LastSeenField):
-                record[field] = user.get_last_seen()[field]
+                record[field] = user.last_seen[field]
             else:
                 assert False
         return record
@@ -98,5 +98,5 @@ class Record(MutableMapping):
             else:
                 assert False
         if last_seen:
-            user.set_last_seen(last_seen)
+            user.last_seen = last_seen
         return user
diff --git a/vk/tracking/sessions.py b/vk/tracking/sessions.py
index 3386c7f..6c4e787 100644
--- a/vk/tracking/sessions.py
+++ b/vk/tracking/sessions.py
@@ -129,18 +129,18 @@ class OnlineSessionEnumerator(MutableMapping):
         return self._close_user_session(record.to_user())
 
     def _known_user(self, user):
-        return user.get_uid() in self._records
+        return user.uid in self._records
 
     def _unknown_user(self, user):
         return not self._known_user(user)
 
     def _close_user_session(self, user):
-        if user not in self or self[user].is_offline():
+        if user not in self or self[user].is_offline:
             self[user] = user
             return None
-        if user.is_online():
+        if user.is_online:
             return None
-        session = user, self[user].get_last_seen_time(), user.get_last_seen_time()
+        session = user, self[user].last_seen.time, user.last_seen.time
         self[user] = user
         return session
 
@@ -291,7 +291,7 @@ class OutputSinkJSON(OutputSinkOnlineSessions):
 class OutputConverterPlot:
     @staticmethod
     def convert_user(user):
-        return f'{user.get_first_name()}\n{user.get_last_name()}'
+        return f'{user.first_name}\n{user.last_name}'
 
     @staticmethod
     def convert_date(date):
diff --git a/vk/tracking/status.py b/vk/tracking/status.py
index 7ef8e7c..7ef0b3c 100644
--- a/vk/tracking/status.py
+++ b/vk/tracking/status.py
@@ -62,7 +62,7 @@ class StatusTracker:
         user_list = self._api.users_get(
             uids, self._USER_FIELDS, deactivated_users=False
         )
-        return {user.get_uid(): user for user in user_list}
+        return {user.uid: user for user in user_list}
 
     def _notify_status(self, user):
         for fn in self._on_initial_status:
@@ -95,7 +95,7 @@ class StatusTracker:
     @staticmethod
     def _filter_status_updates(old_users, new_users):
         for uid, user in new_users.items():
-            if old_users[uid].is_online() != user.is_online():
+            if old_users[uid].is_online != user.is_online:
                 old_users[uid] = user
                 yield user
 
diff --git a/vk/user.py b/vk/user.py
index 69e8147..60bde9f 100644
--- a/vk/user.py
+++ b/vk/user.py
@@ -78,11 +78,11 @@ class User(Hashable, MutableMapping):
         self._fields = fields
 
     def __eq__(self, other):
-        return self.get_uid() == other.get_uid()
+        return self.uid == other.uid
         # return self._fields == other._fields
 
     def __hash__(self):
-        return hash(self.get_uid())
+        return hash(self.uid)
 
     def __getitem__(self, field):
         return self._fields[field]
@@ -115,74 +115,56 @@ class User(Hashable, MutableMapping):
 
     _DEFAULT_FIELD_PARSER = str
 
-    def get_uid(self):
+    @property
+    def uid(self):
         return self[UserField.UID]
 
-    def get_first_name(self):
+    @property
+    def first_name(self):
         return self[UserField.FIRST_NAME]
 
-    def set_first_name(self, name):
-        self[UserField.FIRST_NAME] = name
-
+    @property
     def has_last_name(self):
-        return UserField.LAST_NAME in self and self.get_last_name()
+        return UserField.LAST_NAME in self and self.last_name
 
-    def get_last_name(self):
+    @property
+    def last_name(self):
         return self[UserField.LAST_NAME]
 
-    def set_last_name(self, name):
-        self[UserField.LAST_NAME] = name
+    @property
+    def full_name(self):
+        if not self.has_last_name:
+            return self.first_name
+        return f'{self.first_name} {self.last_name}'
 
+    @property
     def is_deactivated(self):
         return UserField.DEACTIVATED in self
 
-    def get_deactivation_reason(self):
+    @property
+    def deactivation_reason(self):
         return self[UserField.DEACTIVATED]
 
-    def set_deactivated(self, reason):
-        self[UserField.DEACTIVATED] = reason
-
+    @property
     def is_hidden(self):
         return UserField.HIDDEN in self and self[UserField.HIDDEN]
 
-    def set_hidden(self, value=True):
-        self[UserField.HIDDEN] = value
-
-    def has_domain(self):
-        return UserField.DOMAIN in self
-
-    def get_domain(self):
+    @property
+    def domain(self):
         return self[UserField.DOMAIN]
 
-    def set_domain(self, domain):
-        self[UserField.DOMAIN] = domain
-
-    def has_online_flag(self):
-        return UserField.ONLINE in self
-
+    @property
     def is_online(self):
         return self[UserField.ONLINE]
 
+    @property
     def is_offline(self):
-        return not self.is_online()
+        return not self.is_online
 
-    def set_online_flag(self, value=True):
-        self[UserField.ONLINE] = value
-
-    def has_last_seen(self):
-        return UserField.LAST_SEEN in self
-
-    def get_last_seen(self):
+    @property
+    def last_seen(self):
         return self[UserField.LAST_SEEN]
 
-    def set_last_seen(self, last_seen):
+    @last_seen.setter
+    def last_seen(self, last_seen):
         self[UserField.LAST_SEEN] = last_seen
-
-    def get_last_seen_time(self):
-        return self[UserField.LAST_SEEN].get_time()
-
-    def get_last_seen_time_local(self):
-        return self[UserField.LAST_SEEN].get_time().astimezone()
-
-    def get_last_seen_platform(self):
-        return self[UserField.LAST_SEEN].get_platform()