fix: Trader: Trading portfolio auto balance algorithm, that uses, that

python/modules/data_builder.py

@@ -39,61 +39,5 @@ def build_karma(
     ) -> str:
         """Builds the user's karma and returns its string representation.
         """
-        plus_string = ""
-        minus_string = ""
-        karma = user["karma"]
-        up_votes = len(user["supporters"])
-        down_votes = len(user["opponents"])
-        if up_votes > 0:
-            plus_string = "+%.1f" % (up_votes / config.POSITIVE_VOTES_PER_KARMA)
-        if down_votes > 0:
-            minus_string = "-%.1f" % (down_votes / config.NEGATIVE_VOTES_PER_KARMA)
-        if up_votes > 0 or down_votes > 0:
-            return f"[{karma}][{plus_string}{minus_string}]"
-        else:
-            return f"[{karma}]"
-
-    @staticmethod
-    def get_users_sorted_by_karma(
-        vk_instance: Vk,
-        data: BetterBotBaseDataService,
-        peer_id: int,
-        reverse_sort: bool = True
-    ) -> List[BetterUser]:
-        members = vk_instance.get_members_ids(peer_id)
-        users = data.get_users(
-            other_keys=[
-                "karma", "name", "programming_languages",
-                "supporters", "opponents", "github_profile", "uid"],
-            sort_key=lambda u: DataBuilder.calculate_real_karma(u, data),
-            reverse_sort=reverse_sort)
-        if members:
-            users = [u for u in users if u["uid"] in members]
-        return users
-
-    @staticmethod
-    def get_users_sorted_by_name(
-        vk_instance,
-        data: BetterBotBaseDataService,
-        peer_id: int
-    ) -> List[BetterUser]:
-        members = vk_instance.get_members_ids(peer_id)
-        users = data.get_users(
-            other_keys=[
-                "name", "programming_languages",
-                "github_profile", "uid"
-            ])
-        if members:
-            users = [u for u in users if u["uid"] in members]
-        users.reverse()
-        return users
-
-    @staticmethod
-    def calculate_real_karma(
-        user: BetterUser,
-        data: BetterBotBaseDataService
-    ) -> int:
-        base_karma = user["karma"]
-        up_votes = len(user["supporters"])/config.POSITIVE_VOTES_PER_KARMA
-        down_votes = len(user["opponents"])/config.NEGATIVE_VOTES_PER_KARMA
-        return base_karma + up_votes - down_votes
+        karma = user.get("karma", 0)
+        return str(karma)

python/modules/data_service.py

@@ -32,86 +32,24 @@ def get_or_create_user(
         """
         if self.base.notInBD(uid):
             if vk:
-                name = vk.users.get(user_ids=uid)['response'][0]["first_name"]
+                try:
+                    response = vk.users.get(user_ids=uid)
+                    if response and 'response' in response:
+                        name = response['response'][0]["first_name"]
+                    else:
+                        name = "Пользователь"
+                except Exception:
+                    name = "Пользователь"
             else:
                 name = "Пользователь"
             return self.base.addNew(uid=uid, name=name)
         return self.base.load(uid)
 
-    def get_user(
-        self,
-        uid: int,
-        vk: Optional[Vk] = None
-    ) -> BetterUser:
-        """Alias for get_or_create_user.
-        """
-        return self.get_or_create_user(uid, vk)
-
-    def get_users(
-        self,
-        other_keys: List[str],
-        sort_key: Optional[Callable[[Any], Any]],
-        reverse_sort: bool = True
-    ) -> List[Dict[str, Any]]:
-        """Returns users and their key values.
-
-        :param other_key: list of user keys
-        :param sort_key: base key
-        :param reverse_sort: if True returns reversed list.
-        """
-        users = self.base.getByKeys(*other_keys)
-        if sort_key:
-            users = sorted(users, key=sort_key, reverse=reverse_sort)
-        return users
-
-    @staticmethod
     def get_user_sorted_programming_languages(
-        user: BetterUser,
-        sort: bool = True,
-        reverse_sort: bool = False
-    ) -> List[str]:
-        """Returns user's programming languages.
-
-        :param user: -- user object
-        :param sort: -- return sorted list, if True
-        :param reverse_sort: -- uses for {sort} arg.
-        """
-        languages = BetterBotBaseDataService.get_user_property(user, "programming_languages")
-        languages = languages if isinstance(languages, list) else []
-        if sort:
-            return sorted(languages, reverse=reverse_sort)
-        return languages
-
-    @staticmethod
-    def get_user_property(
-        user: Union[Dict[str, Any], BetterUser],
-        property_name: str
-    ) -> Any:
-        """
-        :param user: dict or BetterUser
-        :param property_name: needed property
-        """
-        return user[property_name] if isinstance(user, dict) else eval(f"user.{property_name}")
-
-    @staticmethod
-    def set_user_property(
-        user: Union[Dict[str, Any], BetterUser],
-        property_name: str,
-        value: Any
-    ) -> NoReturn:
-        """Changes user property
-
-        :param user: dict or BetterUser
-        :param property_name: needed property
-        :param value: new value
-        """
-        if isinstance(user, dict):
-            user[property_name] = value
-        else:
-            exec(f"user.{property_name} = value")
-
-    def save_user(
         self,
         user: BetterUser
-    ) -> NoReturn:
-        self.base.save(user)
+    ) -> List[str]:
+        """Returns sorted list of user's programming languages.
+        """
+        languages = user.get("programming_languages", [])
+        return sorted(set(languages))