pyvko 0.0.1__tar.gz

pyvko-0.0.1/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: pyvko
+Version: 0.0.1
+Summary: VK API typed wrapper library
+Home-page: 
+Author: Igor Djachenko
+Author-email: i.s.djachenko@gmail.com
+License: MIT
+Project-URL: Homepage, https://github.com/djachenko/pyvko
+Project-URL: Repository, https://github.com/djachenko/pyvko
+Project-URL: Issues, https://github.com/djachenko/pyvko/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: ruff; extra == "test"
+Requires-Dist: mypy; extra == "test"
+Provides-Extra: release
+Requires-Dist: build; extra == "release"
+Requires-Dist: python-semantic-release; extra == "release"
+Dynamic: author-email

pyvko-0.0.1/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyvko"
+version = "0.0.1"
+description = "VK API typed wrapper library"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Igor Djachenko" }]
+requires-python = ">=3.10"
+
+[project.optional-dependencies]
+test = [
+    "pytest",
+    "ruff",
+    "mypy",
+]
+release = [
+    "build",
+    "python-semantic-release",
+]
+
+[project.urls]
+Homepage = "https://github.com/djachenko/pyvko"
+Repository = "https://github.com/djachenko/pyvko"
+Issues = "https://github.com/djachenko/pyvko/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[[tool.mypy.overrides]]
+module = "vk_api.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "pyvko.pyvko_runner"
+ignore_errors = true
+
+[tool.semantic_release]
+version_toml = ["pyproject.toml:project.version"]
+branch = "master"
+build_command = "pip install build && python -m build"
+changelog_file = "CHANGELOG.md"
+commit_message = "chore(release): v{version} [no ci]"
+major_on_zero = false
+allow_zero_version = true

pyvko-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyvko-0.0.1/setup.py

@@ -0,0 +1,16 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='pyvko',
+    version='0.1.11',
+    packages=find_packages(),
+    install_requires=[
+        'vk_api',
+        'requests',
+    ],
+    url='',
+    license='MIT',
+    author='Harry Djachenko',
+    author_email='i.s.djachenko@gmail.com',
+    description=''
+)

pyvko-0.0.1/src/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-0.0.1/src/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-0.0.1/src/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-0.0.1/src/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