itd-sdk 2.5.2__tar.gz → 2.6.0__tar.gz

{itd_sdk-2.5.2 → itd_sdk-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: itd-sdk
-Version: 2.5.2
+Version: 2.6.0
 Summary: ITD client for python
 Keywords: itd,itdsocial
 Author: fi-res

{itd_sdk-2.5.2 → itd_sdk-2.6.0}/itd/__init__.py

@@ -36,7 +36,9 @@ from time import sleep
 
 __version__ = version("itd-sdk")
 
-from itd._default import limiters
+from itd._default import LimiterConfig, limiters
+from itd._default import set_config as set_limiter_config
+from itd._limiter import BurstRateLimiter, HalfRateLimiter, IPRateLimiter, RateLimiter
 from itd.clan import Clan, TopClans
 from itd.client import Client as ITDClient
 from itd.client import Config as ITDConfig
@@ -50,14 +52,12 @@ from itd.user import Me, User, Users, get_follow_status
 from itd.version import Apps, Changelog
 
 
+# call if you set auto_acquire=False in the end of cycle
 def acquire_limiters():
-    try:
-        sleep(max(limiter.get_delay() for limiter in limiters.values() if limiter.is_ran))
-    except ValueError:
-        pass
+    sleep(max((limiter.delay for limiter in limiters.values() if limiter.used), default=0))
 
     for limiter in limiters.values():
-        limiter.is_ran = False
+        limiter.used = False
 
 
 __all__ = [
@@ -83,5 +83,11 @@ __all__ = [
     'Me',
     'Users',
     'get_follow_status',
+    'set_limiter_config',
+    'LimiterConfig',
+    'BurstRateLimiter',
+    'RateLimiter',
+    'HalfRateLimiter',
+    'IPRateLimiter',
     'acquire_limiters'
 ]

{itd_sdk-2.5.2 → itd_sdk-2.6.0}/itd/_default.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 from itd._limiter import IPRateLimiter, RateLimiter
@@ -10,13 +11,32 @@ if TYPE_CHECKING:
 _default_client: Client | None = None
 limiters: dict[int, RateLimiter] = {}
 limits: dict[str, int] = {}
-ip_limiter = IPRateLimiter()
+
+
+@dataclass
+class LimiterConfig:
+    limiter: type[RateLimiter] | None = None
+    ip_limiter: IPRateLimiter | None = None
+    auto_acquire: bool = True
+
+
+_config = LimiterConfig()
+
+
+def set_config(config: LimiterConfig):
+    global _config
+    _config = config
+
+
+def get_config() -> LimiterConfig:
+    global _config
+    return _config
 
 
 def get_default_client() -> Client:
     global _default_client
     if _default_client is None:
-        raise
+        raise RuntimeError('No client inited')
     return _default_client
 
 

itd_sdk-2.6.0/itd/_limiter.py

@@ -0,0 +1,96 @@
+from abc import ABC, abstractmethod
+from time import monotonic, sleep
+
+from itd.logger import get_logger
+
+l = get_logger('limiter')
+
+
+class RateLimiter(ABC):
+    def __init__(self, capacity: int):
+        l.debug(r'\[%s] create rate limiter', capacity)
+        self.capacity = capacity
+        self._delay = 0
+        self.used = False
+
+    @abstractmethod
+    def sync(self, remaining: int): ...  # sync remaining, calls after request
+
+    def acquire(self):  # wait, calls before request
+        sleep(self.delay)
+
+    @abstractmethod
+    def on_limit(self): ...  # calls when RateLimitError raised
+
+    def request(self):  # call before request
+        self.used = True
+
+    @property
+    def delay(self):
+        return self._delay
+
+
+class HalfRateLimiter(RateLimiter):
+    def __init__(self, capacity: int):
+        super().__init__(capacity)
+        self._delay = 60 / capacity
+        self.last_request = 0
+        self.requests = 0
+
+    @property
+    def delay(self):
+        return max(0.1, self._delay - (monotonic() - self.last_request))
+
+    def request(self):
+        super().request()
+        self.last_request = monotonic()
+        self.requests += 1
+
+    def sync(self, remaining: int):
+        # короче тут такая задумка что лимитер оставляет половину ременинга, то есть чем ты дальше от центра тем сильнее тебя пиздит лимитер
+        best = self.capacity / 2
+
+        def diff(a, b):
+            return max(a, b) - min(a, b)
+
+        l.info(r'\[%s] sync limiter total=%s remaining=%s diff=%s', self.capacity, self.requests, remaining, diff(best, remaining))
+        if remaining < best - 3 and self.requests > best:
+            self._delay = min(self._delay * (1 + (diff(best, remaining) / 20)), 30)
+            l.info(r'\[%s] slowdown delay=%.2f', self.capacity, self._delay)
+
+        elif remaining > best + 3 and self.requests > best:
+            self._delay = max(self._delay * (1 - (diff(best, remaining) / 50)), 0.1)
+            l.info(r'\[%s] speedup delay=%.2f', self.capacity, self._delay)
+
+    def on_limit(self):
+        self._delay *= 2
+        self._delay = min(self._delay, 30)
+
+
+class BurstRateLimiter(RateLimiter):
+    def __init__(self, capacity: int):
+        super().__init__(capacity)
+        self.remaining = capacity
+
+    def sync(self, remaining: int):
+        l.debug(r'\[%s] sync limiter remaining=%s', self.capacity, remaining)
+        self.remaining = remaining
+
+    @property
+    def delay(self):
+        if self.remaining < 3:
+            return 60
+        return 0
+
+    def on_limit(self): ...
+
+
+class IPRateLimiter:
+    def __init__(self):
+        self.requests = []
+
+    def acquire(self):
+        self.requests.append(monotonic())
+        self.requests = [request for request in self.requests if request > monotonic() - 60]
+        if len(self.requests) >= 90:
+            sleep(max(self.requests[0] + 60 - monotonic(), 0))

{itd_sdk-2.5.2 → itd_sdk-2.6.0}/itd/api/comments.py

@@ -41,20 +41,25 @@ def get_comments(client: Client, post_id: UUID, cursor: int = 0, limit: int = 20
 
 
 @api_wrapper(NotFoundError('Comment'))
-def like_comment(client: Client, comment_id: UUID):
-    return client.request('post', f'comments/{comment_id}/like')
+def like_comment(client: Client, id: UUID):
+    return client.request('post', f'comments/{id}/like')
 
 
 @api_wrapper(NotFoundError('Comment'))
-def unlike_comment(client: Client, comment_id: UUID):
-    return client.request('delete', f'comments/{comment_id}/like')
+def unlike_comment(client: Client, id: UUID):
+    return client.request('delete', f'comments/{id}/like')
 
 
 @api_wrapper(NotFoundError('Comment'), AlreadyDeletedError('Comment'))
-def delete_comment(client: Client, comment_id: UUID):
-    return client.request('delete', f'comments/{comment_id}')
+def delete_comment(client: Client, id: UUID):
+    return client.request('delete', f'comments/{id}')
 
 
 @api_wrapper(ValidationError(), NotFoundError('Comment'))
-def get_replies(client: Client, comment_id: UUID, page: int = 1, limit: int = 50):
-    return client.request('get', f'comments/{comment_id}/replies', {'page': page, 'limit': limit})
+def get_replies(client: Client, id: UUID, page: int = 1, limit: int = 50):
+    return client.request('get', f'comments/{id}/replies', {'page': page, 'limit': limit})
+
+
+@api_wrapper(ValidationError(), NotFoundError('Comment'), ForbiddenError('edit comment'))
+def edit_comment(client: Client, id: UUID, content: str):
+    return client.request('patch', f'comments/{id}', {'content': content})

itd_sdk-2.6.0/itd/api/notifications.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from uuid import UUID
+
+from itd.base import api_wrapper
+from itd.exceptions import NotFoundError
+
+if TYPE_CHECKING:
+    from itd.client import Client
+    from itd.notification import NotificationsSettings
+
+
+@api_wrapper()
+def get_notifications(client: Client, limit: int = 20, offset: int = 0):
+    return client.request('get', 'notifications', {'limit': limit, 'offset': offset})
+
+
+@api_wrapper(NotFoundError('Notification', json_check=lambda json: json.get('success') is False))
+def mark_as_read(client: Client, id: UUID):
+    return client.request('post', f'notifications/{id}/read')
+
+
+@api_wrapper()
+def mark_all_as_read(client: Client):
+    return client.request('post', 'notifications/read-all')
+
+
+@api_wrapper()
+def get_unread_notifications_count(client: Client):
+    return client.request('get', 'notifications/count')
+
+
+def stream_notifications(client: Client):
+    return client.request_sse('notifications/stream')
+
+
+def get_notifications_settings(client: Client):
+    return client.request('get', 'notifications/settings')
+
+
+def update_notifications_settings(client: Client, settings: NotificationsSettings, *, old: bool = True, new: bool = True):
+    from itd.notification import _NotificationsSettingsNew, _NotificationsSettingsNewPreferences, _NotificationsSettingsOld  # жду фикс circular import день 67
+
+    data = {}
+    if old:
+        print(settings.follows)
+
+        data.update(_NotificationsSettingsOld.model_validate(settings, from_attributes=True).model_dump(mode='json', by_alias=True))
+        print(settings.follows)
+
+    if new:
+        data.update(
+            _NotificationsSettingsNew(
+                web_enabled=settings.web_enabled,
+                sound_enabled=settings.sound,
+                preferences=_NotificationsSettingsNewPreferences.model_validate(settings, from_attributes=True),
+                enabled=settings.enabled
+            ).model_dump(mode='json', by_alias=True)
+        )
+
+    return client.request('put', 'notifications/settings', data)

{itd_sdk-2.5.2 → itd_sdk-2.6.0}/itd/api/posts.py

@@ -97,11 +97,6 @@ def repost(client: Client, id: UUID, content: str | None = None):
     return client.request('post', f'posts/{id}/repost', data)
 
 
-@api_wrapper(NotFoundError('Post'))
-def view_post(client: Client, id: UUID):
-    return client.request('post', f'posts/{id}/view')
-
-
 @api_wrapper(ValidationError(), NotFoundError('User'))
 def get_liked_posts(client: Client, username_or_id: str | UUID, cursor: datetime | None = None, limit: int = 20):
     return client.request('get', f'posts/user/{username_or_id}/liked', {'limit': limit, 'cursor': cursor})

{itd_sdk-2.5.2 → itd_sdk-2.6.0}/itd/base.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import inspect
 from abc import abstractmethod
 from functools import wraps
 from time import sleep
@@ -9,8 +10,7 @@ from pydantic import BaseModel
 from requests import Response
 from requests.exceptions import JSONDecodeError
 
-from itd._default import get_default_client, ip_limiter, limiters, limits
-from itd._limiter import BurstRateLimiter, SafeRateLimiter
+from itd._default import get_config, get_default_client, limiters, limits
 from itd.enums import ALL, BATCH, All, Batch, DebugResponseMode, LoadStatus
 from itd.exceptions import DEFAULT_ERRORS, AccessTokenExpiredError, AccountDeletedError, ITDException, RateLimitError, UnauthorizedError, ValidationError
 from itd.logger import get_logger
@@ -50,6 +50,7 @@ class ITDBaseModel:
 
     def __init__(self, client: Client | None = None) -> None:
         self._client = client or get_default_client()
+
         self._loaded_attrs: set[str] = set()
 
     def __setattr__(self, name: str, value: Any) -> None:
@@ -81,7 +82,7 @@ class ITDBaseModel:
         validated = self._validator().model_validate(data)  # ty: ignore[missing-argument]
         self._loaded_attrs = validated.model_fields_set  # значения автоматом добавляются через setattr # так значит это же тогда надо закоментить? # хз наверн
         for name, value in validated.__dict__.items():
-            setattr(self, name, value)
+            object.__setattr__(self, name, value)
 
         self._post_refresh()
 
@@ -97,7 +98,6 @@ class ITDBaseModel:
     if not TYPE_CHECKING:
 
         def __getattribute__(self, name: str) -> Any:
-
             try:
                 value = object.__getattribute__(self, name)
                 exc = None
@@ -105,6 +105,8 @@ class ITDBaseModel:
                 value = None
                 exc = e
 
+            if name == 'is_following':
+                l.debug(_getattr(self, '_loaded_attrs'))
             if (
                 _getattr(self, '_refreshable')
                 and not name.startswith('_')
@@ -306,7 +308,7 @@ def _filter_bytes(args: tuple):
     return filtered
 
 
-# user calls `Me` -> model calls `get_me` -> `api_wrapper` wrapper: (`get_me` -> `client.request` -> `fetch` -> responses 401 -> `refresh_auth` from `api_wrapper` -> `client.resuest` -> `fetch` -> token refreshed -> `api_wrapper` backs to main query -> `get_me` -> `client.request` -> `fetch` -> user fetched) -> model recieves data -> pydantic fills model # hell what the monster i did
+# user calls `Me` -> model calls `get_me` -> `api_wrapper` wrapper: (`get_me` -> `client.request` -> `fetch` -> responses 401 -> `refresh_auth` from `api_wrapper` -> `client.resuest` -> `fetch` -> token refreshed -> `api_wrapper` backs to main query -> `get_me` -> `client.request` -> `fetch` -> user fetched) -> model recieves data -> pydantic fills model
 def api_wrapper(*exceptions: ITDException):
     """Декоратор для отлавливания ошибок
 
@@ -321,9 +323,19 @@ def api_wrapper(*exceptions: ITDException):
 
             def exec():
                 l.info('exec %s %s %s', func.__name__, _filter_bytes(args), kwargs)
-                if client.config.auto_acquire and name in limits:
-                    limiters[limits[name]].acquire()
-                ip_limiter.acquire()
+
+                config = get_config()
+                is_first = True
+                if name in limits and limits[name] in limiters:
+                    limiter = limiters[limits[name]]
+                    if config.auto_acquire:
+                        limiter.acquire()
+                    is_first = not limiter.used
+                    limiter.request()
+
+                ip_limiter = config.ip_limiter
+                if ip_limiter:
+                    ip_limiter.acquire()
 
                 res: Response = func(client, *args, **kwargs)
 
@@ -337,12 +349,10 @@ def api_wrapper(*exceptions: ITDException):
                 limit = int(res.headers.get('x-ratelimit-limit', 0))
                 limits[name] = limit
 
-                if client.config._anti_rate_limit:
-                    if client.config._burst_requests and limit not in limiters:
-                        limiters[limit] = BurstRateLimiter(limit)
+                if limit not in limiters and config.limiter is not None:
+                    limiters[limit] = config.limiter(limit)
 
-                    elif limit not in limiters:
-                        limiters[limit] = SafeRateLimiter(limit)
+                if limit in limiters and (config.auto_acquire or is_first):
                     limiters[limit].sync(remaining)
 
                 if client.config.debug_response == DebugResponseMode.BEFORE:
@@ -409,7 +419,8 @@ def api_wrapper(*exceptions: ITDException):
                     retry_after = getattr(e, 'retry_after') or client.config.retry_delay
                     l.warning('%s on %s: wait %ss', e.__class__.__name__, func.__name__, retry_after)
                     sleep(retry_after)
-                    limiters[name].on_limit()
+                    if name in limits and limits[name] in limiters:
+                        limiters[limits[name]].on_limit()
 
         return wrapper
 

{itd_sdk-2.5.2 → itd_sdk-2.6.0}/itd/client.py

@@ -12,6 +12,7 @@ from requests import Session
 from requests.adapters import HTTPAdapter
 from requests.utils import default_user_agent
 
+from itd import BurstRateLimiter, HalfRateLimiter, IPRateLimiter, LimiterConfig, set_limiter_config
 from itd._default import _default_client, set_default_client
 from itd.api.auth import change_password, logout, refresh_token
 from itd.api.posts import get_stats
@@ -71,16 +72,17 @@ class Config:
     # для реальных клиентов включен калбэк на ошибки (сами ошибки не выбрасываются) и выключен логгер. Передает ошибки в калбэк, в консоль ничего не пишет, при ошибках сети падает.
     # для ботов включен отлов всех ошибок, а также калбэк при ошибках сети (шоб отправлять в тг например), включен логгер на инфо. Показывает ошибки в консоли, но не завершшает скрипт.
     # для одноразовых скриптов стандартное поведение, отловов ошибок нет, включен логгер на дебаг.
+    # ^ это если что просто мысли, не обращайте внимания
     client_type: Literal['client', 'bot', 'onetime'] = 'onetime'
 
     rate_limit: RateLimitMode | None = None  # deprecated
     rate_limit_default: int | None = None  # deprecated
     rate_limit_actions: dict[str, float | int] | None = None  # deprecated
-    anti_rate_limit: bool | None = None
-    burst_requests: bool | None = None
-    anti_ip_ban: bool = True
-    limit_coefficient: float | None = None
-    auto_acquire: bool = True
+    anti_rate_limit: bool | None = None  # deprecated
+    burst_requests: bool | None = None  # deprecated
+    anti_ip_ban: bool | None = None  # deprecated
+    limit_coefficient: float | None = None  # deprecated
+    auto_acquire: bool | None = None
 
     # enable_logging: bool | None = None
     # logging_level = 'DEBUG'
@@ -163,6 +165,29 @@ class Config:
             l.warning('config.rate_limit_default is deprecated and will be removed in 2.7.0.')
         if self.rate_limit_actions is not None:
             l.warning('config.rate_limit_actions is deprecated and will be removed in 2.7.0.')
+        if self.anti_ip_ban is not None:
+            l.warning(
+                f'config.anti_ip_ban is deprecated and will be removed in 2.7.0. '
+                f'Please use set_limiter_config(LimiterConfig(ip_limiter={"IPRateLimiter" if self.anti_ip_ban else None})).'
+            )
+            set_limiter_config(LimiterConfig(ip_limiter=IPRateLimiter() if self.anti_ip_ban else None))
+        if self.anti_rate_limit is not None:
+            l.warning(
+                f'config.anti_rate_limit is depreacred and will be removed in 2.7.0. '
+                f'Please use set_limiter_config(limiter={"HalfRateLimiter" if self.anti_rate_limit else None}).'
+            )
+            set_limiter_config(LimiterConfig(limiter=HalfRateLimiter if self.anti_rate_limit else None))
+        if self.burst_requests is not None:
+            l.warning(
+                f'config.anti_rate_limit is depreacred and will be removed in 2.7.0. '
+                f'Please use set_limiter_config(limiter={"BurstRateLimiter" if self.burst_requests else None}).'
+            )
+            set_limiter_config(LimiterConfig(limiter=BurstRateLimiter if self.burst_requests else None))
+        if self.limit_coefficient is not None:
+            l.warning(
+                'config.limit_coefficient is deprecated and will be removed in 2.7.0. '
+                'Please define your own rate limiter that will override sync function of RateLimiter class and apply coefficient to remaining.'
+            )
 
         if self.timeout is None:
             match self.client_type:
@@ -185,28 +210,9 @@ class Config:
         else:
             self._post_update_stats = self.post_update_stats
 
-        if self.anti_rate_limit is None:
-            self._anti_rate_limit = self.client_type == 'bot'
-        else:
-            self._anti_rate_limit = self.anti_rate_limit
         if self.load_comments_from_post is not None:
             l.warning('load_comments_from_post is deprecated and will be removed in 2.7.0.')
 
-        if self.burst_requests is None:
-            self._burst_requests = self.client_type != 'bot'
-        else:
-            self._burst_requests = self.burst_requests
-
-        if self.limit_coefficient is None:
-            if self.client_type == 'bot':
-                self._limit_coefficient = 0.75
-            elif self.client_type == 'client':
-                self._limit_coefficient = 0.9
-            else:
-                self._limit_coefficient = 1
-        else:
-            self._limit_coefficient = self.limit_coefficient
-
 
 class AccessToken(BaseModel):
     roles: list[Role] = [Role.USER]

{itd_sdk-2.5.2 → itd_sdk-2.6.0}/itd/comment.py

@@ -6,7 +6,7 @@ from uuid import UUID
 
 from pydantic import BaseModel, Field, field_validator
 
-from itd.api.comments import add_comment, add_reply_comment, delete_comment, get_comments, get_replies, like_comment, unlike_comment
+from itd.api.comments import add_comment, add_reply_comment, delete_comment, edit_comment, get_comments, get_replies, like_comment, unlike_comment
 from itd.base import ITDBaseModel, ITDList
 from itd.enums import CommentSorting, ReportReason, ReportTargetType
 from itd.file import CommentAttach
@@ -115,6 +115,20 @@ class Comment(ITDBaseModel):
         """
         delete_comment(client or self._client, self.id)
 
+    def edit(self, content: str, *, client: Client | None = None) -> datetime:
+        """Изменить комментарий
+
+        Args:
+            content (str): Новое содержимое
+            client (Client | None, optional): Клиент. Defaults to None.
+
+        Returns:
+            datetime: Дата изменения
+        """
+        edited_at = edit_comment(client or self.client, self.id, content).json()['editedAt']
+        self.content = content
+        return parse_datetime(edited_at)
+
     @classmethod
     def new(cls, post: Post, content: str | None = None, attachments: ATTACHMENTS = [], client: Client | None = None):
         instance = cls.__new__(cls)

{itd_sdk-2.5.2 → itd_sdk-2.6.0}/itd/enums.py

@@ -18,6 +18,16 @@ class ViewSource(Enum):
     SEARCH = 8
 
 
+class LastSeenUnit(Enum):
+    JUST_NOW = 'just_now'
+    RECENTLY = 'recently'
+    MINUTES = 'minutes'
+    HOURS = 'hours'
+    THIS_WEEK = 'this_week'
+    THIS_MONTH = 'this_month'
+    LONG_AGO = 'long_ago'
+
+
 class ViewReason(Enum):
     NORMAL = 0  # стандартное
     BLUR = 1  # страница скрыта (listener blur)

{itd_sdk-2.5.2 → itd_sdk-2.6.0}/itd/notification.py

@@ -3,16 +3,24 @@ from __future__ import annotations
 from datetime import datetime
 from json import loads
 from threading import Thread
-from typing import TYPE_CHECKING, Iterator, Literal, cast
+from typing import TYPE_CHECKING, Any, Callable, Iterator, Literal, cast
 from uuid import UUID
 
 from pydantic import BaseModel, Field, field_validator
 from sseclient import SSEClient
 
-from itd.api.notifications import get_notifications, get_unread_notifications_count, mark_all_as_read, mark_as_read, stream_notifications
+from itd.api.notifications import (
+    get_notifications,
+    get_notifications_settings,
+    get_unread_notifications_count,
+    mark_all_as_read,
+    mark_as_read,
+    stream_notifications,
+    update_notifications_settings
+)
 from itd.base import ITDBaseModel, ITDList
 from itd.client import Client
-from itd.enums import NotificationTargetType, NotificationType
+from itd.enums import LoadStatus, NotificationTargetType, NotificationType
 from itd.logger import get_logger
 from itd.user import User
 
@@ -23,9 +31,96 @@ if TYPE_CHECKING:
 l = get_logger('notifications')  # noqa: E741
 
 
+class NotificationsSettings(ITDBaseModel):
+    _validator = lambda _: _NotificationsSettingsValidate
+    enabled: bool
+    web_enabled: bool = Field(True, alias='webEnabled')
+    sound: bool = Field(alias='sound')
+    follows: bool
+    wall_posts: bool = Field(alias='wallPosts')
+    likes: bool
+    comments: bool
+    replies: bool = True
+    mentions: bool
+
+    def _refresh(self, *, client: Client):
+        return get_notifications_settings(client).json()
+
+    def update(
+        self,
+        enabled: bool | None = None,
+        web_enabled: bool | None = None,
+        sound: bool | None = None,
+        follows: bool | None = None,
+        wall_posts: bool | None = None,
+        likes: bool | None = None,
+        comments: bool | None = None,
+        replies: bool | None = None,
+        mentions: bool | None = None,
+        client: Client | None = None,
+        old: bool = True,
+        new: bool = True
+    ):
+        if self.load_status != LoadStatus.FULL:
+            self.refresh()
+        if enabled is not None:
+            self.enabled = enabled
+        if web_enabled is not None:
+            self.web_enabled = web_enabled
+        if sound is not None:
+            self.sound = sound
+        if follows is not None:
+            self.follows = follows
+        if wall_posts is not None:
+            self.wall_posts = wall_posts
+        if likes is not None:
+            self.likes = likes
+        if comments is not None:
+            self.comments = comments
+        if replies is not None:
+            self.replies = replies
+        if mentions is not None:
+            self.mentions = mentions
+        self.update_from_fields(client, old=old, new=new)
+
+    def update_from_fields(self, client: Client | None = None, *, old: bool = True, new: bool = True):
+        update_notifications_settings(client or self.client, self, old=old, new=new)
+
+
+class _NotificationsSettingsValidate(BaseModel, NotificationsSettings):
+    pass
+
+
+class _NotificationsSettingsOld(BaseModel):
+    enabled: bool
+    sound: bool
+    follows: bool
+    wall_posts: bool = Field(serialization_alias='wallPosts')
+    likes: bool
+    comments: bool
+    mentions: bool
+
+
+class _NotificationsSettingsNewPreferences(BaseModel):
+    follows: bool
+    reactions: bool = Field(validation_alias='likes')
+    comments: bool
+    replies: bool
+    mentions: bool
+    wall_posts: bool = Field(serialization_alias='wallPosts')
+
+
+class _NotificationsSettingsNew(BaseModel):
+    web_enabled: bool = Field(serialization_alias='webEnabled')
+    sound_enabled: bool = Field(serialization_alias='soundEnabled')
+    preferences: _NotificationsSettingsNewPreferences
+    enabled: bool
+
+
 class Notification(ITDBaseModel):
     _refreshable = False
-    _notifications: Notifications | None = None
+    _notifications: Notifications
+    _validator = lambda _: _NotificationValidate
 
     id: UUID
     type: NotificationType
@@ -42,30 +137,30 @@ class Notification(ITDBaseModel):
     actor: User
     sound: bool = False  # for notifications from stream
 
-    def __init__(self, notification: dict, notifications: Notifications | None = None, client: Client | None = None) -> None:
-        super().__init__(client)
-        self._notifications = notifications
-
-        for name, value in _NotificationValidate.model_validate(notification).__dict__.items():
-            setattr(self, name, value)
-
     def __hash__(self):
         return int(self.id)
 
+    @classmethod
+    def from_dict(cls, data: dict, notifications: Notifications, *, client: Client | None = None):  # ty: ignore # who asked
+        instance = super().from_dict(data, client=client)
+        instance._notifications = notifications
+        return instance
+
     def read(self, client: Client | None = None) -> None:
         mark_as_read(client or self.client, self.id)
 
-        if not self.is_read and self._notifications and self._notifications._unread:  # check if already read and has notifications and unread loaded
+        if not self.is_read and self._notifications._unread:  # check if already read and has notifications and unread loaded
             self._notifications._unread -= 1
 
         self.is_read = True
         self.read_at = datetime.now()
 
-    def get_text(self, avatar: bool = False) -> str:
+    def get_text(self, actor: bool = True, avatar: bool = False) -> str:
         text = ''
         if avatar:
             text += self.actor.avatar + ' '
-        text += self.actor.display_name + ' '
+        if actor:
+            text += self.actor.display_name + ' '
 
         match self.type:
             case NotificationType.FOLLOW:
@@ -107,6 +202,9 @@ class Notification(ITDBaseModel):
             case NotificationType.MENTION | NotificationType.COMMENT_MENTION:
                 return 'purple'
 
+    def __str__(self):
+        return self.get_text()
+
 
 class _NotificationValidate(BaseModel, Notification):
     @field_validator('actor', mode='plain')
@@ -116,9 +214,14 @@ class _NotificationValidate(BaseModel, Notification):
 
 
 class Notifications(ITDList[Notification]):
-    _unread: int | None = None
     cursor: int = 0
 
+    def __init__(self, client: Client | None = None):
+        super().__init__(client=client)
+        self._unread: int | None = None
+        self._callbacks: dict[str | None, Callable[[Notification], Any]] = {}
+        self.settings = NotificationsSettings(client=client)
+
     def _fetch(self, client: Client, limit: int) -> dict:
         return get_notifications(client, limit, len(self)).json()
 
@@ -134,7 +237,7 @@ class Notifications(ITDList[Notification]):
         return data['hasMore']
 
     def _to_models(self, objects: list, client: Client):
-        return [Notification(notification, self, client) for notification in objects]
+        return [Notification.from_dict(notification, self, client=client) for notification in objects]
 
     def read_all(self):
         mark_all_as_read(self.client)
@@ -154,15 +257,21 @@ class Notifications(ITDList[Notification]):
             data = loads(event.data)
 
             if 'userId' in data and 'timestamp' in data and 'type' not in data:
-                l.debug('got init message')
+                l.debug('got init message %s', data)
                 continue  # initial message
 
-            notification = Notification(data, self, self.client)
+            notification: Notification = Notification.from_dict(data, self, client=self.client)
             self.insert(0, notification)
+            if self._unread is not None:
+                self._unread += 1
 
             l.info('new notification type=%s', notification.type.value)
             exec(f'self.on_{notification.type.value}(notification)')
             self.on_notification(notification)
+            if None in self._callbacks:
+                self._callbacks[None](notification)
+            if notification.type.value in self._callbacks:
+                self._callbacks[notification.type.value](notification)
 
             yield notification
 
@@ -207,3 +316,20 @@ class Notifications(ITDList[Notification]):
     def on_wall_post(self, notification: Notification, /) -> None: ...
 
     def on_notification(self, notification: Notification, /) -> None: ...
+
+    def on(
+        self,
+        type: Literal[
+            'like', 'comment', 'reply', 'repost', 'mention', 'follow', 'follow_request', 'follow_accepted', 'comment_like', 'comment_mention', 'wall_post'
+        ]
+        | None = None
+    ):
+        def decorator(func: Callable[[Notification], Any]):
+            self._callbacks[type] = func
+
+            def wrapper(*args, **kwargs):
+                return func(*args, **kwargs)
+
+            return wrapper
+
+        return decorator

{itd_sdk-2.5.2 → itd_sdk-2.6.0}/itd/post.py

@@ -25,8 +25,7 @@ from itd.api.posts import (
     repost,
     restore_post,
     unlike_post,
-    unpin_post,
-    view_post
+    unpin_post
 )
 from itd.base import ITDBaseModel, ITDList
 from itd.comment import Comment, Comments
@@ -459,7 +458,7 @@ class Post(ITDBaseModel):
 
             c.dwell_tracker.record_view(self.id, self.vs, duration, entered_at, exited_at, self.source, self.source_context, reason)
         else:
-            view_post(c, self.id)
+            l.error('old post viewing is no more supported. Please enable dwell_tracker in config.')
 
         if c == self.client:
             self.is_viewed = True

{itd_sdk-2.5.2 → itd_sdk-2.6.0}/itd/user.py

@@ -29,7 +29,7 @@ from itd.api.users import (
 )
 from itd.api.users import get_follow_status as _get_follow_status
 from itd.base import ITDBaseModel, ITDList
-from itd.enums import AccessType, LoadStatus, ReportReason, ReportTargetType, Role, Unset
+from itd.enums import AccessType, LastSeenUnit, LoadStatus, ReportReason, ReportTargetType, Role, Unset
 from itd.exceptions import AccountDeletedError, NotFoundError, PinNotOwnedError
 from itd.pin import Pin
 from itd.poll import NewPoll
@@ -173,6 +173,28 @@ class _SubscriptionValidate(BaseModel, Subscription):
     pass
 
 
+class LastSeen(BaseModel):
+    unit: LastSeenUnit
+    value: int | None = None
+
+    def __str__(self):
+        match self.unit:
+            case LastSeenUnit.JUST_NOW:
+                return 'только что'
+            case LastSeenUnit.RECENTLY:
+                return 'недавно'
+            case LastSeenUnit.MINUTES:
+                return f'{self.value} минут назад'
+            case LastSeenUnit.HOURS:
+                return f'{self.value} часов назад'
+            case LastSeenUnit.THIS_WEEK:
+                return 'на этой неделе'
+            case LastSeenUnit.THIS_MONTH:
+                return 'в этом месяце'
+            case LastSeenUnit.LONG_AGO:
+                return 'давно'  # гавно
+
+
 class _UserBase(ITDBaseModel):
     _identifier: str | UUID
 
@@ -253,7 +275,7 @@ class User(_UserBase):
     is_private: bool | None = Field(None, alias='isPrivate')  # none if following or blocked
 
     is_subscribed: bool = Field(False, alias='hasNuksta')
-    last_seen: datetime | dict | None = Field(None, alias='lastSeen')  # none if hidden or blocked
+    last_seen: datetime | LastSeen | None = Field(None, alias='lastSeen')  # none if hidden or blocked
     online: bool = False
 
     pinned_post_id: UUID | None = Field(None, alias='pinnedPostId')  # none if no or blocked

{itd_sdk-2.5.2 → itd_sdk-2.6.0}/pyproject.toml

@@ -14,7 +14,7 @@ version_provider = "uv"
 
 [project]
 name = "itd-sdk"
-version = "2.5.2"
+version = "2.6.0"
 description = "ITD client for python"
 readme = "README.md"
 authors = [

itd_sdk-2.5.2/itd/_limiter.py

@@ -1,97 +0,0 @@
-from time import monotonic, sleep
-
-from itd.logger import get_logger
-
-l = get_logger('limiter')
-
-
-class RateLimiter:
-    window: int = 65
-
-    def __init__(self, capacity: int):
-        l.debug(r'\[%s] create rate limiter', capacity)
-        self.capacity = capacity
-        self.is_ran = True
-
-    def sync(self, remaining: int): ...
-    def acquire(self): ...
-    def on_limit(self): ...
-    def get_delay(self): ...
-
-
-class SafeRateLimiter(RateLimiter):
-    def __init__(self, capacity: int):
-        super().__init__(capacity)
-        self.delay = 60 / capacity
-        self.last_request = monotonic()
-        self.requests = 0
-        self.is_ran = False
-
-    def get_delay(self):
-        self.requests += 1
-        self.last_request = monotonic()
-        return max(0.1, self.delay - (monotonic() - self.last_request))
-
-    def acquire(self):
-        l.debug(r'\[%s] acquire limiter delay=%s', self.capacity, round(self.delay, 2))
-        sleep(self.get_delay())
-
-    def sync(self, remaining: int):
-        l.info(r'\[%s] sync limiter remaining=%s', self.capacity, remaining)
-        if remaining < self.capacity * 0.2:
-            self.delay *= 1 + 1 / (remaining or 0.5)
-            l.info(r'\[%s] increase delay=%s', self.capacity, round(self.delay, 2))
-        if remaining > self.capacity * 0.9:
-            self.delay *= 0.7
-            l.info(r'\[%s] decrease delay=%s', self.capacity, round(self.delay, 2))
-        elif 10 < self.requests < 500 and remaining > self.capacity * 0.5:
-            self.delay -= 1 / self.requests
-        self.delay = max(0.1, min(self.delay, 30))
-        self.is_ran = True
-
-    def on_limit(self):
-        self.delay *= 2
-        self.delay = min(self.delay, 30)
-
-
-class BurstRateLimiter(RateLimiter):
-    def __init__(self, capacity: int):
-        super().__init__(capacity)
-        self.requests = []
-
-    def sync(self, remaining: int):
-        l.debug(r'\[%s] sync limiter remaining=%s', self.capacity, remaining)
-
-        used = self.capacity - remaining
-        if used > 0:
-            self.requests = self.requests[-used:]  # ai
-        while len(self.requests) < used:
-            self.requests.append(monotonic())
-
-    def acquire(self):
-        l.debug(r'\[%s] acquire limiter', self.capacity)
-
-        self.requests = [request for request in self.requests if request > monotonic() - self.window]
-        while len(self.requests) >= self.capacity:
-            self.requests = [request for request in self.requests if request > monotonic() - self.window]
-            if self.requests:
-                sleep(max(self.requests[0] + self.window - monotonic(), 0.1))
-
-
-class IPRateLimiter:
-    window: int = 60
-    max_requests: int = 90
-
-    def __init__(self):
-        self.requests = []
-
-    def acquire(self):
-        self.requests.append(monotonic())
-        self.requests = [request for request in self.requests if request > monotonic() - self.window]
-        while len(self.requests) >= self.max_requests:
-            self.requests = [request for request in self.requests if request > monotonic() - self.window]
-            if self.requests:
-                sleep(self.get_delay())
-
-    def get_delay(self):
-        return max(self.requests[0] + self.window - monotonic(), 0.1)

itd_sdk-2.5.2/itd/api/notifications.py

@@ -1,39 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-from uuid import UUID
-
-from itd.base import api_wrapper
-from itd.exceptions import NotFoundError
-
-if TYPE_CHECKING:
-    from itd.client import Client
-
-
-@api_wrapper()
-def get_notifications(client: Client, limit: int = 20, offset: int = 0):
-    return client.request('get', 'notifications', {'limit': limit, 'offset': offset})
-
-
-@api_wrapper(NotFoundError('Notification', json_check=lambda json: json.get('success') is False))
-def mark_as_read(client: Client, id: UUID):
-    return client.request('post', f'notifications/{id}/read')
-
-
-@api_wrapper()
-def mark_all_as_read(client: Client):
-    return client.request('post', 'notifications/read-all')
-
-
-@api_wrapper()
-def get_unread_notifications_count(client: Client):
-    return client.request('get', 'notifications/count')
-
-
-def stream_notifications(client: Client):
-    """Получить SSE поток уведомлений
-
-    Returns:
-        Response: Streaming response для SSE
-    """
-    return client.request_sse('notifications/stream')