pyvko 0.0.1__py3-none-any.whl

pyvko/api_based.py

@@ -0,0 +1,57 @@
+from abc import abstractmethod, ABC
+from typing import Any, Dict
+
+from vk_api import VkApi
+
+
+class RequestRoot:
+    def get_request(self, parameters: Dict | None = None):
+        return parameters or {}
+
+
+class ApiMixin(RequestRoot, ABC):
+    @property
+    @abstractmethod
+    def new_api(self) -> VkApi:
+        pass
+
+    @property
+    def api(self) -> Any:
+        assert False, f"{type(self).__name__} still uses unmigrated api — switch to new_api"
+
+    @abstractmethod
+    def get_request(self, parameters: Dict | None = None) -> Dict:
+        return super().get_request(parameters)
+
+
+class ApiBased(RequestRoot):
+    __VERSION = 5.199
+
+    def __init__(self, api: Any) -> None:
+        super().__init__()
+
+        self.__api = api
+
+    @property
+    def new_api(self) -> Any:
+        return self.__api
+
+    @property
+    def api(self) -> Any:
+        assert False, f"{type(self).__name__} still uses unmigrated api — switch to new_api"
+
+    @staticmethod
+    def __get_default_object():
+        return {
+            # "v": ApiBased.__VERSION,
+        }
+
+    def get_request(self, parameters: Dict | None = None) -> Dict:
+        if parameters is None:
+            parameters = {}
+
+        assert "v" not in parameters
+
+        request = ApiBased.__get_default_object() | parameters | super().get_request()
+
+        return request

pyvko/aspects/albums.py

@@ -0,0 +1,139 @@
+from abc import abstractmethod, ABC
+from pathlib import Path
+from typing import Any, Dict, List
+
+
+from pyvko.api_based import ApiMixin, ApiBased
+from pyvko.attachment.attachment import Attachment
+from pyvko.attachment.photo import Photo
+from pyvko.shared.photos_uploader import AlbumPhotoUploader
+from pyvko.shared.utils import get_all
+
+
+class Album(ApiBased, Attachment):
+    def __init__(self, api: Any, api_object: dict) -> None:
+        super().__init__(api)
+
+        self.__name = api_object["title"]
+        self.__id = api_object["id"]
+        self.__owner_id = api_object["owner_id"]
+
+    @property
+    def name(self) -> str:
+        return self.__name
+
+    @property
+    def id(self) -> int:
+        return self.__id
+
+    @property
+    def url(self) -> str:
+        return f"https://vk.com/album{self.owner_id}_{self.id}"
+
+    def get_photos(self) -> List[Photo]:
+        parameters = self.get_request()
+
+        photos_descriptions = get_all(parameters, self.api.photos.get)
+
+        photos = [Photo.from_photo_object(self.api, photo_object) for photo_object in photos_descriptions]
+
+        return photos
+
+    def get_request(self, parameters: Dict | None = None) -> dict:
+        if parameters is None:
+            parameters = {}
+
+        parameters |= {
+            "owner_id": self.__owner_id,
+            "album_id": self.__id
+        }
+
+        return super().get_request(parameters)
+
+    def set_cover(self, cover: Photo):
+        request = self.get_request({
+            "photo_id": cover.id
+        })
+
+        self.api.photos.makeCover(**request)
+
+    def add_photo(self, path: Path) -> Photo:
+        uploader = AlbumPhotoUploader(self.api, self.id, -self.__owner_id)
+
+        return uploader.upload(path)
+
+    # region Attachment
+
+    @property
+    def type(self) -> str:
+        return "album"
+
+    @property
+    def owner_id(self) -> int:
+        return self.__owner_id
+
+    @property
+    def media_id(self) -> int:
+        return self.id
+
+    # endregion Attachment
+
+
+class Albums(ApiMixin, ABC):
+    @property
+    @abstractmethod
+    def id(self) -> int:
+        pass
+
+    def __get_albums(self, parameters: Dict | None = None) -> List[Album]:
+        request = self.__get_owned_request(parameters)
+
+        result = self.api.photos.getAlbums(**request)
+
+        albums = [Album(self.api, album_object) for album_object in result["items"]]
+
+        return albums
+
+    def get_all_albums(self) -> List[Album]:
+        return self.__get_albums()
+
+    def get_album_by_id(self, album_id: int) -> Album | None:
+        albums_list = self.__get_albums({
+            "album_ids": [album_id]
+        })
+
+        if len(albums_list) == 1:
+            return albums_list[0]
+        elif len(albums_list) == 0:
+            return None
+        else:
+            assert False
+
+    def create_album(self, name: str) -> Album:
+        parameters = {
+            "title": name,
+            "group_id": abs(self.id),
+            "upload_by_admins_only": 1
+        }
+
+        parameters = self.get_request(parameters)
+
+        response = self.api.photos.createAlbum(**parameters)
+
+        created_album = Album(self.api, response)
+
+        return created_album
+
+    def __get_owned_request(self, parameters: Dict | None = None) -> dict:
+        if parameters is None:
+            parameters = {}
+        else:
+            parameters = parameters.copy()
+
+        assert "owner_id" not in parameters
+
+        parameters.update({
+            "owner_id": self.id
+        })
+
+        return self.get_request(parameters)

pyvko/aspects/comments.py

@@ -0,0 +1,143 @@
+from abc import abstractmethod, ABC
+from dataclasses import dataclass
+from datetime import datetime
+from typing import List, Dict, Any
+
+from pyvko.api_based import ApiMixin, ApiBased
+from pyvko.attachment.attachment import Attachment
+from pyvko.attachment.attachment_parser import AttachmentParser
+from pyvko.aspects.likes import Likes
+from pyvko.shared.utils import get_all
+
+
+@dataclass
+class CommentModel:
+    text: str
+    from_group: int = 0
+
+    attachments: List[Attachment] | None = None
+
+    def to_request(self):
+        request = {}
+
+        if self.text:
+            request["message"] = self.text
+
+        if self.from_group != 0:
+            request["from_group"] = self.from_group
+
+        if self.attachments:
+            request["attachments"] = ",".join([a.to_attach() for a in self.attachments])
+
+        return request
+
+
+class Comment(ApiBased, Likes):
+    @property
+    def item_id(self) -> int:
+        return self.id
+
+    @property
+    def like_object_type(self) -> str:
+        return "comment"
+
+    @property
+    def owner_id(self) -> int:
+        return self.__owner_id
+
+    @property
+    def id(self):
+        return self.__id
+
+    @property
+    def text(self) -> str:
+        return self.__text
+
+    @property
+    def date(self) -> datetime:
+        return self.__date
+
+    def __init__(
+            self,
+            api: Any,
+            comment_id: int,
+            owner_id: int,
+            date: datetime,
+            text: str,
+            attachments: List[Attachment] | None
+    ) -> None:
+        super().__init__(api)
+
+        self.__id = comment_id
+        self.__owner_id = owner_id
+        self.__date = date
+        self.__text = text
+        self.__attachments = attachments
+
+    @classmethod
+    def from_api_object(cls, api_object: Dict, api: Any) -> 'Comment':
+        if "attachments" in api_object:
+            parser = AttachmentParser.shared()
+
+            attachments = [parser.parse_object(o, api) for o in api_object["attachments"]]
+        else:
+            attachments = None
+
+        return Comment(
+            api=api,
+            comment_id=api_object["id"],
+            owner_id=api_object["owner_id"],
+            date=datetime.fromtimestamp(api_object["date"]),
+            text=api_object["text"],
+            attachments=attachments
+        )
+
+
+class Comments(ApiMixin, ABC):
+    @property
+    @abstractmethod
+    def post_id(self) -> int:
+        pass
+
+    @property
+    @abstractmethod
+    def owner_id(self) -> int:
+        pass
+
+    def add_comment(self, comment: CommentModel) -> Comment:
+        add_comment_request = self.get_request(comment.to_request() | {
+            "post_id": self.post_id,
+            "owner_id": self.owner_id,
+        })
+
+        add_comment_response = self.api.wall.createComment(**add_comment_request)
+
+        comment_id = add_comment_response["comment_id"]
+
+        return self.get_comment(comment_id)
+
+    def get_comments(self) -> List[Comment]:
+        request = self.get_request({
+            "post_id": self.post_id,
+            "owner_id": self.owner_id,
+            # "count": 10,
+        })
+
+        comments_objects = list(get_all(request, self.api.wall.getComments, count_key="current_level_count"))
+
+        comments = [Comment.from_api_object(comments_object, self.api) for comments_object in comments_objects]
+
+        return comments
+
+    def get_comment(self, comment_id: int) -> Comment:
+        request = self.get_request({
+            "comment_id": comment_id,
+            "owner_id": self.owner_id,
+            # "count": 10,
+        })
+
+        comment_object = self.api.wall.getComment(**request)
+
+        comment = Comment.from_api_object(comment_object["items"][0], self.api)
+
+        return comment

pyvko/aspects/events.py

@@ -0,0 +1,216 @@
+from abc import ABC
+from datetime import datetime
+from enum import Enum
+from functools import cache
+from typing import Optional, List, Dict, Tuple, Any
+from urllib.parse import urlparse
+
+from vk_api.exceptions import ApiError
+
+from pyvko.api_based import ApiMixin, ApiBased
+from pyvko.aspects.albums import Albums
+from pyvko.aspects.posts import Posts
+
+
+class Event(ApiBased, Posts, Albums):
+    class Category(Enum):
+        CIRCUS = 1120
+        CONCERT = 1107
+        PARTY = 1103
+        EXHIBITION = 1104
+
+    class Section(Enum):
+        WALL = "wall"
+        DISCUSSION = "topics"
+        PHOTOS = "photos"
+        VIDEOS = "video"
+        MUSIC = "audio"
+        FILES = "docs"
+        WIKI = "wiki"
+        ARTICLES = "articles"
+        NARRATIVES = "narratives"
+        MESSAGES = "messages"
+
+        @staticmethod
+        @cache
+        def __section_index_mapping() -> List[Tuple['Event.Section', int]]:
+            return [
+                (Event.Section.PHOTOS, 1),
+                (Event.Section.VIDEOS, 4),
+            ]
+
+        @classmethod
+        def from_index(cls, index: int) -> Optional['Event.Section']:
+
+            for section, section_index in Event.Section.__section_index_mapping():
+                if index == section_index:
+                    return section
+
+            return None
+
+        def to_index(self) -> Optional[int]:
+            for section, section_index in Event.Section.__section_index_mapping():
+                if section == self:
+                    return section_index
+
+            return None
+
+    class SectionState(Enum):
+        NOT_AVAILABLE = -1
+        DISABLED = 0
+        OPEN = 1
+        ENABLED = 1
+        LIMITED = 2
+        RESTRICTED = 3
+
+    def __init__(self, api: Any, event_object: Dict, settings_object: Dict | None) -> None:
+        super().__init__(api)
+
+        self.__id: int = -event_object["id"]
+        self.name = event_object["name"]
+        self.start_date: datetime = datetime.fromtimestamp(event_object["start_date"])
+        self.end_date: datetime | None
+
+        if "finish_date" in event_object:
+            self.end_date = datetime.fromtimestamp(event_object["finish_date"])
+        else:
+            self.end_date = None
+
+        self.is_closed = bool(event_object["is_closed"])
+        self.url = event_object["screen_name"]
+
+        self.event_category: Event.Category | None = None
+        self.__sections: Dict[Event.Section, Event.SectionState] = {}
+        self.main_section: Event.Section | None = None
+        self.secondary_section: Event.Section | None = None
+        self.organiser: int | None = None
+
+        if settings_object is not None:
+            category_value = settings_object["public_category"]
+
+            if category_value != 0:
+                self.event_category = Event.Category(category_value)
+
+            self.__sections = {
+                s: Event.SectionState(settings_object[s.value]) for s in Event.Section
+            }
+
+            self.main_section = Event.Section.from_index(settings_object["main_section"])
+            self.secondary_section = Event.Section.from_index(settings_object["secondary_section"])
+            self.organiser = settings_object.get("event_object_id")
+
+    @property
+    def id(self) -> int:
+        return self.__id
+
+    @property
+    def browser_url(self):
+        return f"http://vk.com/event{abs(self.id)}"
+
+    def section_state(self, section: Section) -> Optional[SectionState]:
+        return self.__sections.get(section)
+
+    def set_section_state(self, section: Section, new_state: SectionState):
+        assert new_state != Event.SectionState.NOT_AVAILABLE
+        assert self.__sections[section] != Event.SectionState.NOT_AVAILABLE
+
+        self.__sections[section] = new_state
+
+    def save(self):
+        params = {
+            "group_id": abs(self.__id),
+            "access": int(self.is_closed),
+            "event_start_date": int(self.start_date.timestamp()),
+            "title": self.name,
+        }
+
+        for section, state in self.__sections.items():
+            if state == Event.SectionState.NOT_AVAILABLE:
+                continue
+
+            params[section.value] = state.value
+
+        if self.end_date is not None:
+            params["event_finish_date"] = int(self.end_date.timestamp())
+
+        if self.event_category is not None:
+            params["public_category"] = self.event_category.value
+
+        if self.main_section is not None:
+            params["main_section"] = self.main_section.to_index()
+
+        if self.secondary_section is not None:
+            params["secondary_section"] = self.secondary_section.to_index()
+
+        if self.organiser is not None:
+            params["event_group_id"] = abs(self.organiser)
+
+        request = self.get_request(params)
+
+        self.new_api.groups.edit(**request)
+
+
+class Events(ApiMixin, ABC):
+    def create_event(self, title: str) -> Event:
+        request = self.get_request({
+            "title": title,
+            "type": "event",
+        })
+
+        response = self.new_api.groups.create(**request)
+
+        event = self.get_event(response["id"])
+
+        assert event is not None
+
+        return event
+
+    def get_event(self, url: str | int) -> Event | None:
+        url = str(url)
+
+        parse_result = urlparse(url)
+
+        qualifier = parse_result.path \
+            .split("/")[-1] \
+            .removeprefix("event") \
+            .removeprefix("-")
+
+        group_request = self.get_request({
+            "group_id": qualifier,
+            "fields": [
+                "start_date",
+                "finish_date",
+            ]
+        })
+
+        event_request = {
+            "fields": [
+                "start_date",
+                "finish_date",
+                "main_section",
+            ]
+        }
+
+        event_request.update(group_request)
+
+        event_response = self.new_api.groups.getById(**event_request)
+
+        event_object = event_response["groups"][0]
+
+        if event_object["type"] not in ["event", ]:
+            return None
+
+        group_request["group_id"] = event_object["id"]
+
+        try:
+            settings_response = self.new_api.groups.getSettings(**group_request)
+        except ApiError as err:
+            # 15 — ACCESS_DENIED in VK API
+            if err.code not in [3, 15]:
+                raise
+
+            settings_response = None
+
+        event = Event(self.new_api, event_object=event_object, settings_object=settings_response)
+
+        return event

pyvko/aspects/groups.py

@@ -0,0 +1,95 @@
+from abc import ABC
+from typing import Any, Dict, List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pyvko.entities.user import User
+
+from pyvko.api_based import ApiMixin, ApiBased
+from pyvko.aspects.albums import Albums
+from pyvko.aspects.events import Events, Event
+from pyvko.aspects.posts import Posts
+from pyvko.entities.user import User
+from pyvko.shared.utils import get_all
+
+
+class Group(ApiBased, Posts, Albums, Events):
+    # from pyvko.entities.user import User
+
+    def __init__(self, api: Any, group_object: Dict) -> None:
+        super().__init__(api)
+
+        self.__group_object = group_object
+
+        self.__id = -group_object["id"]
+        self.__name = group_object["name"]
+        self.__url = group_object["screen_name"]
+
+    def __str__(self) -> str:
+        return f"Group: {self.__name}({self.id})"
+
+    @property
+    def name(self) -> str:
+        return self.__name
+
+    # region Wall
+
+    @property
+    def id(self) -> int:
+        return self.__id
+
+    # endregion Wall
+
+    @property
+    def url(self) -> str:
+        return self.__url
+
+    def get_members(self) -> List['User']:
+        parameters = {
+            "group_id": self.id,
+            "sort": "time_desc",
+            "fields": [
+                "online",
+            ]
+        }
+
+        parameters = self.get_request(parameters)
+
+        users_descriptions = get_all(parameters, self.new_api.groups.getMembers)
+
+        users = [User(api=self.new_api, user_object=description) for description in users_descriptions]
+
+        return users
+
+    # region Events
+
+    def create_event(self, title: str) -> Event:
+        event = super().create_event(title)
+
+        event.organiser = self.id
+
+        event.save()
+
+        return event
+
+    # endregion Events
+
+
+class Groups(ApiMixin, ABC):
+    def get_group(self, url: str | int) -> Group | None:
+        if isinstance(url, int):
+            url = abs(url)
+
+        group_request = self.get_request({
+            "group_id": url
+        })
+
+        group_response = self.new_api.groups.getById(**group_request)
+
+        group_object = group_response["groups"][0]
+
+        if group_object["type"] not in ["page", "group"]:
+            return None
+
+        group = Group(api=self.new_api, group_object=group_object)
+
+        return group