interpals-api 2.3.0__py3-none-any.whl

interpals_api/errors.py

@@ -0,0 +1,65 @@
+"""
+The project error tree.
+"""
+
+class InterpalsAPIError(Exception):
+    """
+    Base InterpalsAPI error.
+    """
+    pass
+
+
+class SessionError(InterpalsAPIError):
+    """
+    General session error.
+    """
+    pass
+
+
+class APIError(InterpalsAPIError):
+    """
+    General API error.
+    """
+    pass
+
+
+class NoCSRFTokenError(SessionError):
+    """
+    CSRF token not found on session create.
+    """
+    pass
+
+
+class WrongUsernameOrPasswordError(SessionError):
+    """
+    Invalid credentials on session create.
+    """
+    pass
+
+
+class TooManyLoginAttemptsError(SessionError):
+    """
+    Too many attempts on session create.
+    """
+    pass
+
+
+class APITimeoutError(APIError):
+    """
+    Timeout error in API call.
+    """
+    pass
+
+
+class APIAuthError(APIError):
+    """
+    Authorization error in API call.
+    """
+    pass
+
+
+class APIRedirectError(APIError):
+    """
+    Redirect error in API call.
+    """
+    pass

interpals_api/parsers/__init__.py

@@ -0,0 +1,3 @@
+"""
+Different HTML parser of the website.
+"""

interpals_api/parsers/chat_parser.py

@@ -0,0 +1,132 @@
+"""
+Parser for the chat. It supports flexible chats browsing, general information
+and fetching the messages from the history.
+"""
+
+from typing import List, Dict, Any
+
+from bs4 import BeautifulSoup
+
+
+class ChatParser:
+    """
+    Chat parser:
+
+    ```python
+    parser = ChatParser()
+    maxmsgid = parser.parse_maxmsgid(html)
+    unread = parser.parse_unread(html)
+    chats = parser.parse_chat(html)
+    messages = parser.parse_messages(html)
+    ```
+    """
+
+    def parse_maxmsgid(self, content: str) -> int:
+        """
+        Parse maximum id of existing chats from HTML content. It is needed to
+        request chats up to this number (as `max_msg_id` parameter).
+        """
+        soup = BeautifulSoup(content, "lxml")
+        maxmsgid = soup.find('div', id='threads_left')['data-max-msg-id']
+        return int(maxmsgid)
+
+    def parse_unread(self, content: str) -> int:
+        """
+        Parse the count of unread chats from HTML content.
+        """
+        soup = BeautifulSoup(content, "lxml")
+        unread = soup.find('span', id='pmNewCnt').text.strip()
+        return int(unread[2:-1]) if unread else 0
+
+    def parse_chat(self, content: str) -> List[Dict[str, Any]]:
+        """
+        Parse all chats from HTML content. They include thread_id (it's needed 
+        to request chat messages) and other basic fields. The result is a list 
+        of dictionaries.
+        """
+        soup = BeautifulSoup(content, "lxml")
+
+        chats = []
+        elements = soup.find_all('div', class_='pm_thread')
+        for element in elements:
+            chat = {}
+            chat.update(self._parse_thread_info(element))
+            chat.update(self._parse_user_info(element))
+            chat.update(self._parse_message_info(element))
+            chats.append(chat)
+
+        return chats
+
+    def parse_messages(self, content: str) -> List[Dict[str, Any]]:
+        """
+        Parse char messages from HTML content.
+        """
+        soup = BeautifulSoup(content, "lxml")
+
+        messages = []
+
+        elements = soup.find_all('div', class_=['pm_date', 'pm_msg'])
+        user = None
+        date = None
+        for element in elements:
+            if 'pm_date' in element['class']:
+                date = element.text
+
+            else:
+                msg_user_thumb = element.find('div', class_='msg_user_thumb')
+                if msg_user_thumb:
+                    user = msg_user_thumb.a['href']
+
+                message = {}
+                message.update(self._parse_message(element))
+                message['date'] = date
+                message['user'] = user
+                messages.append(message)
+
+        return messages
+
+    def _parse_thread_info(self, element):
+        data = {}
+        data['new'] = 'new' in element['class']
+        data['thread_id'] = element['id'][7:]
+        return data
+
+    def _parse_user_info(self, element):
+        data = {}
+
+        tui_el = element.find_all('div', class_='tui_el')
+        user_age = tui_el[0].text.strip().split(', ')
+        if len(user_age) == 2:
+            data['user'], data['age'] = user_age
+        else:
+            data['user'], data['age'] = user_age[0], None
+        data['city'] = tui_el[1].text if len(tui_el) > 1 else None
+
+        tui_el_0_class = tui_el[0]['class']
+        data['sex'] = tui_el_0_class[1] if len(tui_el_0_class) > 1 else None
+
+        data['avatar'] = 'https:' + element.find(class_='thumb')['src']
+
+        data['flag'] = None
+        flag_img = element.find('div', class_='tui_flag').img
+        if flag_img:
+            data['flag'] = 'https:' + flag_img['src']
+
+        data['online'] = bool(element.find(class_='online-now'))
+
+        return data
+
+    def _parse_message_info(self, element):
+        data = {}
+        data['message'] = element.find(class_='th_snippet').text.strip()
+        data['i_sent'] = bool(element.find(class_='snippet_thumb'))
+        data['unread'] = 'pm_new' in element.find(class_='th_snippet')['class']
+        return data
+
+    def _parse_message(self, element):
+        data = {}
+        data['time'] = element.find('div', class_='pm_time').text
+        data['text'] = element.find('div', class_='msg_body').text.strip()
+        data['msg_id'] = element['id'][4:]
+        data['unread'] = 'pm_unread' in element['class']
+        return data

interpals_api/parsers/friends_parser.py

@@ -0,0 +1,53 @@
+"""
+Parser for user friends.
+"""
+
+from typing import List, Dict, Any
+
+from bs4 import BeautifulSoup
+
+
+class FriendsParser:
+    """
+    Friends parser:
+
+    ```python
+    parser = FriendsParser()
+    data = parser.parse(html)
+    ```
+    """
+
+    def parse(self, content: str) -> List[Dict[str, Any]]:
+        """
+        Parse HTML content and return list of friends as dictionaries having
+        username, age, city, online status and avatar URL.
+        """
+        soup = BeautifulSoup(content, "lxml")
+
+        boxes = soup.find_all('div', class_='friendBox')
+        friends = []
+        for box in boxes:
+            friend = {}
+            friend.update(self._parse_user_info(box))
+            friend.update(self._parse_avatar(box))
+            friend.update(self._parse_online(box))
+            friends.append(friend)
+
+        return friends
+
+    def _parse_avatar(self, box):
+        avatar = 'https:' + box.img['src']
+        return {'avatar': avatar}
+
+    def _parse_user_info(self, box):
+        src = box.find('img', class_='status')['src']
+        online = 'online' in src
+        return {'online': online}
+
+    def _parse_online(self, box):
+        username, age, city, *extra = box.text.strip().split()
+        return {
+            'user': username,
+            'age': age,
+            'city': city
+        }

interpals_api/parsers/pictures_parser.py

@@ -0,0 +1,91 @@
+"""
+Parser for user pictures. It supports the album structure.
+"""
+
+from typing import List, Dict, Any
+
+from bs4 import BeautifulSoup
+
+
+class PicturesParser:
+    """
+    Pictures parser:
+
+    ```python
+    parser = PicturesParser()
+    albums_data = parser.parse_albums(albums_html)
+    ```
+
+    ```python
+    parser = PicturesParser()
+    pictures_data = parser.parse_pictures(pictures_html)
+    ```
+    """
+
+    def parse_albums(self, content: str) -> List[Dict[str, Any]]:
+        """
+        Parse HTML content and return album information incliding its `aid`,
+        description and pictures' URLs.
+        """
+        soup = BeautifulSoup(content, "lxml")
+
+        elements = soup.find_all('div', class_='editAlbumBox')
+        albums = []
+        for element in elements:
+            album = {}
+            album.update(self._parse_aid(element))
+            album.update(self._parse_info(element))
+            album.update(self._parse_album_pictures(element))
+            albums.append(album)
+
+        return albums
+
+    def parse_pictures(self, content: str) -> List[Dict[str, Any]]:
+        """
+        Parse HTML content and return a list of pictures as URLs of small and
+        big ones.
+        """
+        soup = BeautifulSoup(content, "lxml")
+
+        elements = soup.find_all('div', class_='albThumb')
+        pictures = []
+        for element in elements:
+            picture = {}
+            picture['src180x180'] = element.find('img')['src']
+            picture['src'] = ("https://ipstatic.net/photos/" 
+                              + picture['src180x180'].split('/180x180/')[1])
+            # picture['src'] = self._patch_src(picture['src'])
+            pictures.append(picture)
+
+        return pictures
+
+    def _parse_aid(self, element):
+        href = element.find('a', class_='albEditThumb')['href']
+        aid = href.split('&')[0].split('=')[-1]
+        return {'aid': aid}
+
+    def _parse_info(self, element):
+        name = element.find('h3').text
+        stat = element.find('div', class_='albumStats').text.split('|')
+        pics_number = int(stat[0].strip().split()[0])
+        created = stat[1].strip().split(None, 1)[1]
+        updated = stat[2].strip().split(None, 1)[1]
+        return {
+            'name': name,
+            'pics_number': pics_number,
+            'created': created,
+            'updated': updated
+        }
+
+    def _parse_album_pictures(self, element):
+        links = element.find_all('a', class_='thumb')
+        pics = [
+            link.find('img')['src']
+            for link in links
+        ]
+        return {'pictures': pics}
+
+    # def _patch_src(self, src):
+    #     if src[-6] == '_':
+    #         src = src[:-6] + src[-4:]
+    #     return src

interpals_api/parsers/profile_parser.py

@@ -0,0 +1,124 @@
+"""
+Parser for general profile data of a user. It includes gender, location,
+online, join date, status message, avatar URL, uid number and the description.
+"""
+
+from typing import Dict, Any
+
+from bs4 import BeautifulSoup
+
+
+class ProfileParser:
+    """
+    Parser class.
+
+    ```python
+    parser = ProfileParser()
+    data = parser.parse(html)
+    ```
+    """
+
+    def parse(self, content: str) -> Dict[str, Any]:
+        """
+        Parse HTML content and return the data as a dictionary.
+        """
+        soup = BeautifulSoup(content, "lxml")
+
+        data = {}
+
+        data.update(self._extract_name_age_sex(soup))
+        data.update(self._extract_location(soup))
+        data.update(self._extract_online(soup))
+        data.update(self._extract_joined_updated(soup))
+        data.update(self._extract_status(soup))
+        data.update(self._extract_avatar(soup))
+        data.update(self._extract_uid(soup))
+        data.update(self._extract_info(soup))
+
+        return data
+
+    def _extract_name_age_sex(self, soup):
+        profile_box = soup.find(class_='profileBox')
+
+        sex = profile_box.find('img')['src'].split('/')[-1][:-7]
+
+        pieces = profile_box.text.split('\n')
+        pieces = list(map(str.strip, pieces))
+        pieces = list(filter(lambda s: s, pieces))
+        piece = pieces[1]
+        piece = piece.replace('y.o.', '')
+        na = piece.split(', ')
+        if len(na) == 2:
+            name, age = na
+        else:
+            if na.isdigit():
+                name, age = None, na
+            else:
+                name, age = na, None
+        age = int(age)
+
+        return {'name': name, 'age': age, 'sex': sex}
+
+    def _extract_location(self, soup):
+        links = soup.find(class_='profLocation').find_all('a')
+        city = links[1].text
+        city_code = links[1]['href'].split('=')[-1]
+        country = links[2].text
+        country_code = links[2]['href'][-2:]
+        return {
+            'city': city,
+            'city_code': city_code,
+            'country': country,
+            'country_code': country_code
+        }
+
+    def _extract_online(self, soup):
+        text = soup.find(class_='profOnlineStatus').text.strip()
+        if text.lower() == "online now":
+            online = True
+            last = None
+        else:
+            online = False
+            last = ' '.join(text.split()[1:])
+        return {'online': online, 'last': last}
+
+    def _extract_joined_updated(self, soup):
+        text = soup.find(class_='profileBox').find_all('p')[0].text.strip()
+        joined, updated = text.split('\n')[1::2]
+        joined = joined[:-1]
+        updated = updated[:-1]
+        return {'joined': joined, 'updated': updated}
+
+    def _extract_status(self, soup):
+        element = soup.find('span', id='prStatMsgTxt')
+        status = element.text if element else ''
+        return {'status': status}
+
+    def _extract_avatar(self, soup):
+        avatar_link = soup.find('a', class_='mainPhoto')
+        if not avatar_link:
+            avatar_link = soup.find('a', class_='mpImgLink')
+        avatar = 'https:' + avatar_link.find('img')['src']
+        return {'avatar': avatar}
+
+    def _extract_uid(self, soup):
+        report_link = soup.find('a', class_='profReportLink')
+        if report_link:
+            uid = report_link['user-id']
+        else:
+            uid = soup.find('div', class_='hidden-uid').text
+        return {'uid': uid}
+
+    def _extract_info(self, soup):
+        box = soup.find(class_='profDataBox')
+        titles = box.find_all('h2')
+        texts = box.find_all('div', class_='profDataBoxText')
+        info = []
+        for title, text in zip(titles, texts):
+            title = title.text.strip()
+            text = text.text.strip()
+            info.append({
+                'title': title,
+                'text': text
+            })
+        return {'info': info}