Beispiel #1
0
    async def get_chats(
        self,
        links: Optional[list[str]] = None,
        limit: int = 100,
        offset: int = 0,
        refresh: bool = True,
        inside_loop: bool = False,
    ) -> list[dict[str, Any]]:
        result, status = await api_helper.default_data(self, refresh)
        if status:
            return result
        if links is None:
            links = []
        api_count = self.chatMessagesCount
        if api_count and not links:
            link = endpoint_links(
                identifier=self.id, global_limit=limit, global_offset=offset
            ).list_chats
            ceil = math.ceil(api_count / limit)
            numbers = list(range(ceil))
            for num in numbers:
                num = num * limit
                link = link.replace(f"limit={limit}", f"limit={limit}")
                new_link = link.replace("offset=0", f"offset={num}")
                links.append(new_link)
        multiplier = self.session_manager.max_threads
        if links:
            link = links[-1]
        else:
            link = endpoint_links(
                identifier=self.id, global_limit=limit, global_offset=offset
            ).list_chats
        links_2 = api_helper.calculate_the_unpredictable(link, limit, multiplier)
        final_links = links
        if not inside_loop:
            final_links += links_2
        else:
            final_links = links_2
        results = await self.session_manager.async_requests(final_links)
        has_more = results[-1]["hasMore"]
        final_results = [x["list"] for x in results]
        final_results = list(chain.from_iterable(final_results))
        for result in final_results:
            result["withUser"] = create_user(result["withUser"], self)
            result["lastMessage"] = create_message(
                result["lastMessage"], result["withUser"]
            )

        if has_more:
            results2 = await self.get_chats(
                links=[final_links[-1]],
                limit=limit,
                offset=limit + offset,
                inside_loop=True,
            )
            final_results.extend(results2)

        final_results.sort(key=lambda x: x["withUser"].id, reverse=True)
        self.chats = final_results
        return final_results
Beispiel #2
0
    async def get_chats(
        self,
        links: Optional[list] = None,
        limit=100,
        offset=0,
        refresh=True,
        inside_loop=False,
    ) -> list:
        api_type = "chats"
        if not self.active:
            return []
        if not refresh:
            result = handle_refresh(self, api_type)
            if result:
                return result
        if links is None:
            links = []
        api_count = self.chatMessagesCount
        if api_count and not links:
            link = endpoint_links(identifier=self.id,
                                  global_limit=limit,
                                  global_offset=offset).list_chats
            ceil = math.ceil(api_count / limit)
            numbers = list(range(ceil))
            for num in numbers:
                num = num * limit
                link = link.replace(f"limit={limit}", f"limit={limit}")
                new_link = link.replace("offset=0", f"offset={num}")
                links.append(new_link)
        multiplier = getattr(self.session_manager.pool, "_processes")
        if links:
            link = links[-1]
        else:
            link = endpoint_links(identifier=self.id,
                                  global_limit=limit,
                                  global_offset=offset).list_chats
        links2 = api_helper.calculate_the_unpredictable(
            link, limit, multiplier)
        if not inside_loop:
            links += links2
        else:
            links = links2
        results = await self.session_manager.async_requests(links)
        has_more = results[-1]["hasMore"]
        final_results = [x["list"] for x in results]
        final_results = list(chain.from_iterable(final_results))

        if has_more:
            results2 = await self.get_chats(links=[links[-1]],
                                            limit=limit,
                                            offset=limit + offset,
                                            inside_loop=True)
            final_results.extend(results2)

        final_results.sort(key=lambda x: x["withUser"]["id"], reverse=True)
        self.chats = final_results
        return final_results
Beispiel #3
0
    async def get_messages(
        self,
        links: Optional[list] = None,
        limit=10,
        offset=0,
        refresh=True,
        inside_loop=False,
    ) -> list:
        api_type = "messages"
        if not self.subscriber or self.is_me():
            return []
        if not refresh:
            result = handle_refresh(self, api_type)
            if result:
                return result
        if links is None:
            links = []
        multiplier = getattr(self.session_manager.pool, "_processes")
        if links:
            link = links[-1]
        else:
            link = endpoint_links(identifier=self.id,
                                  global_limit=limit,
                                  global_offset=offset).message_api
            links.append(link)
        links2 = api_helper.calculate_the_unpredictable(
            link, limit, multiplier)
        if not inside_loop:
            links += links2
        else:
            links = links2
        results = await self.session_manager.async_requests(links)
        results = await remove_errors(results)
        results = [x for x in results if x]
        has_more = results[-1]["hasMore"] if results else False
        final_results = [x["list"] for x in results if "list" in x]
        final_results = list(chain.from_iterable(final_results))

        if has_more:
            results2 = await self.get_messages(links=[links[-1]],
                                               limit=limit,
                                               offset=limit + offset,
                                               inside_loop=True)
            final_results.extend(results2)
        print
        if not inside_loop:
            final_results = [
                create_message.create_message(x, self) for x in final_results
                if x
            ]
        else:
            final_results.sort(key=lambda x: x["fromUser"]["id"], reverse=True)
        self.temp_scraped.Messages = final_results
        return final_results
Beispiel #4
0
    async def get_messages(
        self,
        links: Optional[list[str]] = None,
        limit: int = 10,
        offset: int = 0,
        refresh: bool = True,
        inside_loop: bool = False,
    ):
        result, status = await api_helper.default_data(self, refresh)
        if status:
            return result
        if links is None:
            links = []
        multiplier = self.get_session_manager().max_threads
        if links:
            link = links[-1]
        else:
            link = endpoint_links(identifier=self.id,
                                  global_limit=limit,
                                  global_offset=offset).message_api
            links.append(link)
        links2 = api_helper.calculate_the_unpredictable(
            link, limit, multiplier)
        if not inside_loop:
            links += links2
        else:
            links = links2
        results = await self.get_session_manager().async_requests(links)
        results = await api_helper.remove_errors(results)
        final_results = []
        if isinstance(results, list):
            has_more = results[-1]["list"] if results else False
            final_results = [x["list"] for x in results if "list" in x]
            final_results = list(chain.from_iterable(final_results))

            if has_more:
                results2 = await self.get_messages(
                    links=[links[-1]],
                    limit=limit,
                    offset=limit + offset,
                    inside_loop=True,
                )
                final_results.extend(results2)
            print
            if not inside_loop:
                final_results = [
                    message_model.create_message(x, self)
                    for x in final_results if x
                ]
            else:
                final_results.sort(key=lambda x: x["fromUser"]["id"],
                                   reverse=True)
            self.temp_scraped.Messages = final_results
        return final_results
Beispiel #5
0
    async def get_messages(
        self,
        links: Optional[list[str]] = None,
        limit: int = 10,
        offset: int = 0,
        refresh: bool = True,
        inside_loop: bool = False,
    ) -> list[Any]:
        result, status = await api_helper.default_data(self, refresh)
        if status:
            return result
        groups = await self.get_groups()
        if isinstance(groups, ErrorDetails):
            return []
        found_id: Optional[int] = None
        for group in groups["groups"]:
            for user in group["users"]:
                if self.id == user["userId"]:
                    found_id = user["groupId"]
                    break
                print
            print
        final_results: list[message_model.create_message] = []
        if found_id:
            if links is None:
                links = []
            multiplier = self.get_session_manager().max_threads
            if links:
                link = links[-1]
            else:
                link = endpoint_links(
                    identifier=found_id, global_limit=limit, global_offset=offset
                ).message_api
                links.append(link)
            links2 = api_helper.calculate_the_unpredictable(link, limit, multiplier)
            if not inside_loop:
                links += links2
            else:
                links = links2
            results = await self.get_session_manager().async_requests(links)
            results = await api_helper.remove_errors(results)
            results = api_helper.merge_dictionaries(results)
            if not results:
                return []
            extras = results["response"]
            final_results = extras["messages"]

            if final_results:
                results2 = await self.get_messages(
                    links=[links[-1]],
                    limit=limit,
                    offset=limit + offset,
                    inside_loop=True,
                )
                final_results.extend(results2)
            print
            if not inside_loop:
                final_results = [
                    message_model.create_message(x, self, extras)
                    for x in final_results
                    if x
                ]
            self.temp_scraped.Messages = final_results
        return final_results