itd-sdk 2.3.0__tar.gz → 2.4.1__tar.gz

{itd_sdk-2.3.0 → itd_sdk-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: itd-sdk
-Version: 2.3.0
+Version: 2.4.1
 Summary: ITD client for python
 Keywords: itd,itdsocial
 Author: firedotguy
@@ -14,18 +14,20 @@ Classifier: Framework :: Pydantic :: 2
 Requires-Dist: requests~=2.32.5
 Requires-Dist: pydantic>=2.12.5,<2.14.0
 Requires-Dist: sseclient-py~=1.9.0
+Requires-Dist: dateparser>=1.2.2 ; extra == 'date'
 Requires-Dist: filetype>=1.2.0 ; extra == 'filetype'
 Requires-Dist: rich>=15.0.0 ; extra == 'logs'
 Requires-Python: >=3.9
 Project-URL: Homepage, https://itdsdk.qzz.io
 Project-URL: Documentation, https://itdsdk.qzz.io/docs
+Provides-Extra: date
 Provides-Extra: filetype
 Provides-Extra: logs
 Description-Content-Type: text/markdown
 
 # itd-sdk
 Клиент ITD для python  
-Документация (beta): https://firedotguy.github.io/itd-sdk
+Документация (beta): https://itdsdk.qzz.io/docs
 
 ## Установка
 
@@ -123,7 +125,7 @@ fetch(c, 'метод', 'эндпоинт', {'данные': 'данные'})
 ## Прочее
  - Лицезия: [MIT](./LICENSE)
  - Автор:
-   - ИТД: [itd_sdk](https://xn--d1ah4a.com/@itd_sdk) или [@fdg](https://xn--d1ah4a.com/@pingbot)
+   - ИТД: [@itd_sdk](https://xn--d1ah4a.com/@itd_sdk) или [@fdg](https://xn--d1ah4a.com/@pingbot)
    - ТГ: [@desicars](https://t.me/desicars)
 
 [![Star History Chart](https://api.star-history.com/chart?repos=itd-sdk/itd-sdk&type=date&legend=top-left)](https://www.star-history.com/?repos=itd-sdk%2Fitd-sdk&type=date&legend=top-left)

{itd_sdk-2.3.0 → itd_sdk-2.4.1}/README.md

@@ -1,6 +1,6 @@
 # itd-sdk
 Клиент ITD для python  
-Документация (beta): https://firedotguy.github.io/itd-sdk
+Документация (beta): https://itdsdk.qzz.io/docs
 
 ## Установка
 
@@ -98,7 +98,7 @@ fetch(c, 'метод', 'эндпоинт', {'данные': 'данные'})
 ## Прочее
  - Лицезия: [MIT](./LICENSE)
  - Автор:
-   - ИТД: [itd_sdk](https://xn--d1ah4a.com/@itd_sdk) или [@fdg](https://xn--d1ah4a.com/@pingbot)
+   - ИТД: [@itd_sdk](https://xn--d1ah4a.com/@itd_sdk) или [@fdg](https://xn--d1ah4a.com/@pingbot)
    - ТГ: [@desicars](https://t.me/desicars)
 
 [![Star History Chart](https://api.star-history.com/chart?repos=itd-sdk/itd-sdk&type=date&legend=top-left)](https://www.star-history.com/?repos=itd-sdk%2Fitd-sdk&type=date&legend=top-left)

{itd_sdk-2.3.0 → itd_sdk-2.4.1}/itd/__init__.py

@@ -2,6 +2,7 @@ from importlib.metadata import version
 
 __version__ = version("itd-sdk")
 
+from itd.version import Changelog, Apps
 from itd.client import Client as ITDClient, Config as ITDConfig
 from itd.clan import Clan, TopClans
 from itd.file import File
@@ -9,4 +10,5 @@ from itd.hashtag import Hashtag, Hashtags
 from itd.notification import Notifications
 from itd.post import Post, Posts, UserPosts, HashtagPosts, LikedPosts
 from itd.poll import NewPoll
+from itd.session import Sessions
 from itd.user import User, Me

{itd_sdk-2.3.0 → itd_sdk-2.4.1}/itd/api/dwell.py

@@ -1,19 +1,19 @@
-from __future__ import annotations
-from typing import TYPE_CHECKING
-from uuid import UUID
-
-from itd.base import catch_errors, rate_limit
-if TYPE_CHECKING:
-    from itd.client import Client
-
-
-@rate_limit()
-@catch_errors()
-def send_views(client: Client, objects: list[dict], sid: UUID):
-    return client.request('post', 'v1/i', {'e': objects, 'sid': str(sid)})
-
-
-@rate_limit()
-@catch_errors()
-def send_interactions(client: Client, objects: list[dict], sid: UUID):
-    return client.request('post', 'v1/x', {'e': objects, 'sid': str(sid)})
+from __future__ import annotations
+from typing import TYPE_CHECKING
+from uuid import UUID
+
+from itd.base import catch_errors, rate_limit
+if TYPE_CHECKING:
+    from itd.client import Client
+
+
+@rate_limit()
+@catch_errors()
+def send_views(client: Client, objects: list[dict], sid: UUID):
+    return client.request('post', 'v1/i', {'e': objects, 'sid': str(sid)})
+
+
+@rate_limit()
+@catch_errors()
+def send_interactions(client: Client, objects: list[dict], sid: UUID):
+    return client.request('post', 'v1/x', {'e': objects, 'sid': str(sid)})

{itd_sdk-2.3.0 → itd_sdk-2.4.1}/itd/api/notifications.py

@@ -36,4 +36,4 @@ def stream_notifications(client: Client):
     Returns:
         Response: Streaming response для SSE
     """
-    return fetch_stream(client.token, 'notifications/stream', session=client.session)
+    return client.request_sse('notifications/stream')

itd_sdk-2.4.1/itd/api/platform.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from itd.client import Client
+from itd.enums import AuthLevel
+from itd.base import catch_errors, rate_limit
+
+@catch_errors()
+@rate_limit()
+def get_apps(client: Client):
+    return client.request('get', 'platform/version', level=AuthLevel.NO)
+
+@catch_errors()
+@rate_limit()
+def get_changelog(client: Client):
+    return client.request('get', 'platform/changelog', level=AuthLevel.NO)

{itd_sdk-2.3.0 → itd_sdk-2.4.1}/itd/api/posts.py

@@ -105,3 +105,8 @@ def like_post(client: Client, id: UUID):
 @catch_errors(NotFoundError('Post'))
 def unlike_post(client: Client, id: UUID):
     return client.request('delete', f'posts/{id}/like')
+
+@rate_limit()
+@catch_errors(ValidationError())
+def get_stats(client: Client, ids: list[UUID]):
+    return client.request('post', 'posts/stats', {'ids': [str(id) for id in ids]}) # if not found, will return empty list

itd_sdk-2.4.1/itd/api/sessions.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+from uuid import UUID
+
+if TYPE_CHECKING:
+    from itd.client import Client
+from itd.exceptions import ValidationError
+from itd.base import catch_errors, rate_limit
+
+@catch_errors()
+@rate_limit()
+def get_sessions(client: Client):
+    return client.request('get', 'v1/auth/sessions')
+
+@catch_errors()
+@rate_limit()
+def revoke(client: Client, id: UUID):
+    return client.request('delete', f'v1/auth/sessions/{id}')
+
+@catch_errors()
+@rate_limit()
+def revoke_all(client: Client):
+    return client.request('delete', 'v1/auth/sessions')

{itd_sdk-2.3.0 → itd_sdk-2.4.1}/itd/base.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Any, Callable, TYPE_CHECKING, Iterator, TypeVar
+from typing import Any, Callable, TYPE_CHECKING, Iterator, TypeVar, overload
 from functools import wraps
 from time import sleep
 from datetime import datetime, timedelta
@@ -12,14 +12,22 @@ from pydantic_core import PydanticUndefinedType
 
 from itd._default import get_default_client
 from itd.logger import get_logger
-from itd.exceptions import ITDException, ValidationError, RateLimitError, UnauthorizedError, AccessTokenExpiredError, DEFAULT_ERRORS, InternalError
-from itd.enums import All, ALL, DebugResponseMode, RateLimitMode, BATCH, Batch
+from itd.exceptions import (
+    ITDException, ValidationError, RateLimitError, UnauthorizedError, AccessTokenExpiredError,
+    DEFAULT_ERRORS, AccountDeletedError
+)
+from itd.enums import All, ALL, DebugResponseMode, RateLimitMode, BATCH, Batch, LoadStatus
 if TYPE_CHECKING:
     from itd.client import Client
 
 
 l = get_logger('base')
 
+def _is_comments_on_post(value: Any, self: Any) -> bool:
+    from itd.comment import Comments
+    from itd.post import Post
+    return isinstance(value, Comments) and isinstance(self, Post)
+
 def _getattr(self: object, name: str, default: Any | None = None) -> Any:
     try:
         return object.__getattribute__(self, name)
@@ -39,8 +47,7 @@ def _field_has_default(cls: type, name: str) -> bool:
 class ITDBaseModel:
     """Базовый класс модельки"""
     _refreshable: bool = True
-    _loaded: bool = False
-    _loading: bool = False
+    load_status: LoadStatus = LoadStatus.NO
     _load_with_parent: bool = True # load parent model if model called
     _validator: Callable[[Any], type[BaseModel]] | None = None # callable (pls use lambda), becuase we havent validator at that moment (it depends on this class)
 
@@ -53,49 +60,65 @@ class ITDBaseModel:
             value._client = client
         object.__setattr__(self, name, value)
 
-    def _post_refresh(self):
-        pass
+    def _post_refresh(self): ...
 
     @property
     def client(self) -> Client:
         return self._client
 
-    def refresh(self) -> Any:
-        l.warning('refresh is not implemented but have called')
-        self._loaded = True
+    def _refresh(self, *, client: Client) -> dict: ...
+
+    def refresh(self, *, client: Client | None = None) -> Any:
+        self.load_status = LoadStatus.LOADING
+        self._fill_from_data(self._refresh(client=client or self.client))
+        self.load_status = LoadStatus.FULL
+        return self
+
+
+    def _fill_from_data(self, data: dict):
+        assert self._validator, 'Unable to use fill_from_data without a validator'
+        validated = self._validator().model_validate(data) # pyright: ignore[reportCallIssue]
+        self._fields_from_data = validated.model_fields_set
+        for name, value in validated.__dict__.items():
+            setattr(self, name, value)
+
+        self._post_refresh()
+
+
+    @classmethod
+    def from_dict(cls, data: dict, *, client: Client | None = None):
+        instance = cls.__new__(cls)
+        ITDBaseModel.__init__(instance, client)
+
+        instance._fill_from_data(data)
+        instance.load_status = LoadStatus.PARTIALLY
+        return instance
 
 
     if not TYPE_CHECKING:
         def __getattribute__(self, name: str) -> Any:
-            if _getattr(self, '_refreshable') and not name.startswith('_') or name in ('client', 'model_fields_set'):
-                try:
-                    attr = _getattr(self, name)
-                except AttributeError:
-                    attr = None
-
-                if callable(attr):
-                    return object.__getattribute__(self, name)
-
-                fields_from_data = _getattr(self, '_fields_from_data', ())
-                triggers = {
-                    'default': name not in fields_from_data and _field_has_default(type(self), name),
-                    'none': attr is None and not _field_has_default(type(self), name),
-                    'field-info': isinstance(attr, FieldInfo)
-                }
-                if (
-                    not _getattr(self, '_loaded') and
-                    any(triggers.values()) and
-                    _getattr(self, 'client').config.auto_load and
-                    not (name == 'comments' and not _getattr(self, 'client').config.load_comments_from_post) # да я хотел сделать нормально, поставить проперти на comments и тд, но это херня кака ято крч просто нахардкожу
-                ):
-                    l.info('load %s.%s reason=%s', self.__class__.__name__.lower(), name,
-                        next((k for k, v in triggers.items() if v))
-                    )
-                    self.refresh()
+            value = _getattr(self, name)
+            if (
+                name.startswith('_') or # приватный аттрибут
+                name in ('client', 'model_fields_set', 'load_status') or
+                not _getattr(self, '_refreshable') or # не рефрешабельная модель
+                not _getattr(self, 'client').config.auto_load or # отключено в конфиге
+                callable(value) or # функция
+                self.load_status == LoadStatus.LOADING or
+                (not _getattr(self, 'client').config.load_comments_from_post and _is_comments_on_post(value, self)) or
+                (isinstance(value, ITDBaseModel) and not value._load_with_parent)
+            ):
+                # l.debug('return %s as is', name)
+                return object.__getattribute__(self, name)
+
+            if isinstance(value, FieldInfo) or (self.load_status != LoadStatus.FULL and name not in self._fields_from_data):
+                l.info('refresh %s field=%s load_status=%s', self.__class__.__name__, name, self.load_status.value)
+                self.refresh()
 
             return object.__getattribute__(self, name)
 
 
+
 T = TypeVar('T', bound=ITDBaseModel)
 
 class ITDList[T](ITDBaseModel, list[T]):
@@ -178,7 +201,7 @@ class ITDList[T](ITDBaseModel, list[T]):
     def _get_objects(data: dict) -> list[dict]:
         return []
 
-    def refresh(self, count: int | All | Batch | None = None, limit: int | Batch = BATCH, client: Client | None = None) -> list[T]:
+    def refresh(self, count: int | All | Batch | None = None, limit: int | Batch = BATCH, *, client: Client | None = None) -> list[T]:
         """Обновить список (удалить все элементы и загрузить заново)
 
         Args:
@@ -211,18 +234,33 @@ class ITDList[T](ITDBaseModel, list[T]):
         """
         return self.load(ALL, limit, client)
 
-    def __getitem__(self, index: int) -> T:  # pyright: ignore[reportIncompatibleMethodOverride]
-        if index > len(self) - 1 and self.client.config.load_on_getitem is not None:
-            self._min_total = index + 1
-            if isinstance(self.client.config.load_on_getitem, All):
+    @overload
+    def __getitem__(self, index: int) -> T: ...
+
+    @overload
+    def __getitem__(self, index: slice) -> list[T]: ...
+
+    def __getitem__(self, index: int | slice) -> T | list[T]:  # pyright: ignore[reportIncompatibleMethodOverride]
+
+        if isinstance(index, slice):
+            value: int | None = index.stop
+        else:
+            value = index
+
+        if ((value is not None and value > len(self) - 1) or value is None) and self.client.config.load_on_getitem is not None:
+            if value:
+                self._min_total = value + 1
+
+            if value is None or isinstance(self.client.config.load_on_getitem, All):
                 l.debug('getitem load all')
                 self.load_all()
             elif isinstance(self.client.config.load_on_getitem, Batch):
                 l.debug('getitem load batch')
                 self.load(BATCH)
             else:
-                l.debug('getitem load %s', index - len(self) + self.client.config.load_on_getitem)
-                self.load(index - len(self) + self.client.config.load_on_getitem)
+                l.debug('getitem load %s', value - len(self) + self.client.config.load_on_getitem)
+                self.load(value - len(self) + self.client.config.load_on_getitem)
+
         return super().__getitem__(index)
 
     def __next__(self) -> T:
@@ -249,29 +287,6 @@ class ITDList[T](ITDBaseModel, list[T]):
         return self.load_all()
 
 
-def refresh_wrapper(func):
-    """Декоратор для self.refresh"""
-    @wraps(func)
-    def wrapper(self, client: Client | None = None):
-        # if self._loading:
-        #     return
-
-        # self._loading = True
-        data = func(self, client or self.client)
-        if self._validator:
-            validated = self._validator().model_validate(data)
-            self._fields_from_data = validated.model_fields_set
-            l.debug('refresh %s', self.__class__.__name__.lower())
-            for name, value in validated.__dict__.items():
-                setattr(self, name, value)
-
-        # self._loading = False
-        self._loaded = True
-        self._post_refresh()
-
-    return wrapper
-
-
 def _filter_bytes(args: tuple):
     filtered = []
     for arg in args:
@@ -323,16 +338,17 @@ def catch_errors(*exceptions: ITDException):
                 ):
                     if isinstance(exception, ValidationError):
                         exception.text = json.get('error', {}).get('message', 'Failed validation')
+
                     if isinstance(exception, RateLimitError) and isinstance(json.get('error'), dict):
                         exception.retry_after = json.get('error', {}).get('retryAfter', 0)
-                    if isinstance(exception, (UnauthorizedError, AccessTokenExpiredError)) and client.refresh_token and not getattr(client, '_refreshing', False):
-                        client._refreshing = True
-                        try:
-                            client.refresh_auth()
-                        finally:
-                            client._refreshing = False
+
+                    if isinstance(exception, (UnauthorizedError, AccessTokenExpiredError)) and client.refresh_token:
+                        client.refresh_auth()
                         return wrapper(client, *args, **kwargs)
 
+                    if isinstance(exception, AccountDeletedError):
+                        exception.can_restore = json.get('error', {}).get('canRestore', True)
+
                     raise exception
 
             if client.config.debug_response == DebugResponseMode.AFTER:
@@ -369,7 +385,7 @@ def rate_limit(delay_min: float | None = None, delay_mid: float | None = None, d
             else:
                 delay = client.config._rate_limit_default
 
-            if datetime.now() - timedelta(seconds=delay) < client.last_actions.get(func.__name__, datetime(2013, 2, 16)):  # my birthday actually
+            if datetime.now() - timedelta(seconds=delay) < client.last_actions.get(func.__name__, datetime(1990, 1, 1)):
                 delay -= (datetime.now() - client.last_actions[func.__name__]).seconds
                 l.debug('anti rate limit on %s; wait %ss', func.__name__, delay)
                 sleep(max(delay, 0))
@@ -382,8 +398,12 @@ def rate_limit(delay_min: float | None = None, delay_mid: float | None = None, d
                 try:
                     return func(client, *args, **kwargs)
                 except (client.config._retry_exceptions) as e:
-                    retry_after = getattr(e, 'retry_after', client.config.rate_limit_wait) or client.config.retry_delay
-                    l.info('%s on %s: wait %ss', e.__class__.__name__, func.__name__, retry_after)
+                    if getattr(e, 'retry_after', 0) > client.config.retry_max_retry_after:
+                        l.error('too large rate limit')
+                        raise
+
+                    retry_after = getattr(e, 'retry_after', client.config.retry_delay)
+                    l.warning('%s on %s: wait %ss', e.__class__.__name__, func.__name__, retry_after)
                     sleep(retry_after)
 
         return wrapper

itd_sdk-2.4.1/itd/clan.py

@@ -0,0 +1,38 @@
+from pydantic import BaseModel, Field
+
+from itd.base import ITDBaseModel
+from itd.logger import get_logger
+from itd.api.etc import get_top_clans
+
+
+l = get_logger('clan')
+
+class Clan(BaseModel):
+    avatar: str
+    members_count: int = Field(0, alias='memberCount')
+
+    def __str__(self) -> str:
+        return self.avatar
+
+
+class TopClans(ITDBaseModel, list[Clan]):
+    _refreshable = False
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.load()
+
+    def load(self):
+        self.clear()
+        self.extend([Clan.model_validate(clan) for clan in get_top_clans(self.client).json()['clans']])
+        return self
+
+    def refresh(self, *, client = None):
+        l.warning('TopClans.refresh is deprecated and will be removed in 2.6.0. Please use TopClans.load')
+        self.load()
+
+    @classmethod
+    def empty(cls):
+        instance = cls.__new__(cls)
+        super(TopClans, instance).__init__()
+        return instance

{itd_sdk-2.3.0 → itd_sdk-2.4.1}/itd/client.py

@@ -2,6 +2,10 @@ from uuid import UUID
 from _io import BufferedReader
 from datetime import datetime
 from dataclasses import dataclass, field
+from atexit import register
+from time import sleep
+from threading import Thread
+from typing import overload
 
 from requests import Session
 from requests.utils import default_user_agent
@@ -9,14 +13,15 @@ from requests.adapters import HTTPAdapter
 from requests.exceptions import RequestException
 
 from itd._default import _default_client, set_default_client
-from itd.exceptions import UnauthorizedError, InsufficientAuthLevelError, AccessTokenExpiredError, RateLimitError, InternalError
+from itd.exceptions import InsufficientAuthLevelError, RateLimitError, InternalError, NotFoundError
 from itd.hashtag import Hashtag
-from itd.request import fetch, decode_jwt_payload
+from itd.request import fetch, decode_jwt_payload, fetch_stream
 from itd.enums import RateLimitMode, All, DebugResponseMode, ParseMode, Batch, BATCH, UserAgent, AuthLevel
 from itd.user import Me, User
-from itd.post import DwellTracker
+from itd.post import DwellTracker, Post
 from itd.api.auth import refresh_token, change_password, logout
 from itd.api.search import search
+from itd.api.posts import get_stats
 from itd.api.users import get_follow_status
 from itd.utils import to_uuid, get_sdk_user_agent
 from itd.logger import get_logger
@@ -57,12 +62,11 @@ class Config:
 
     parse_mode: ParseMode = ParseMode.NO
 
-    rate_limit_wait: int | None = None # DEPRECATED
-    retry_on_rate_limits: bool | None = None # DEPRECATED
     retry_enabled: bool = True
     retry_delay: float = 10 # delay before next attempt (after rate limit error) if retry_after is not provided in request
     retry_max_retries: int | None = None # none for no limit
     retry_exceptions: tuple[type[Exception]] | list[type[Exception]] | None = None
+    retry_max_retry_after: int = 500
 
     bypass_auth_level: bool = False
 
@@ -70,6 +74,14 @@ class Config:
     dwell_max_buffer: int = 20
     dwell_send_interval: float = 2
     dwell_save_on_quit: bool = True
+    dwell_wait_durations: bool = True
+    post_view_increment: bool = False
+
+    post_update_stats: bool = False
+    post_update_stats_interval: int = 3
+
+    view_read_speed: int = 250 # in WPM # https://scholarwithin.com/average-reading-speed
+    view_images_speed: int = 130 # https://news.mit.edu/2014/in-the-blink-of-an-eye-0116
 
     def __post_init__(self):
         if self.rate_limit_default:
@@ -96,28 +108,21 @@ class Config:
             case _:
                 self._user_agent = self.user_agent
 
-        if self.rate_limit_wait is not None:
-            l.warning('config.rate_limit_wait is deprecated and will be removed in 2.4.0. Please use config.retry_delay')
-            self.retry_delay = self.rate_limit_wait
-        if self.retry_on_rate_limits is not None:
-            l.warning('config.retry_on_rate_limits is deprecated and will be removed in 2.4.0. Please use config.retry_enabled')
-            self.retry_enabled = self.retry_on_rate_limits
 
         self._retry_exceptions = (tuple(self.retry_exceptions) if isinstance(self.retry_exceptions, list) else self.retry_exceptions) or (RateLimitError, InternalError, RequestException)
 
 
 
 class Client:
-    auth_level: AuthLevel = AuthLevel.NO
-    access_token: str | None = None
-    refresh_token: str | None = None
-    _user = None
-    _refreshing: bool = False
-
     def __init__(self, refresh: str | None = None, access: str | None = None, config: Config = Config()):
         l.info('init client refresh=%s access=%s', refresh is not None, access is not None)
         self.config = config
         self.last_actions: dict[str, datetime] = {}
+        self.auth_level: AuthLevel = AuthLevel.NO
+        self.access_token: str | None = None
+        self.refresh_token: str | None = None
+        self._user: Me | None = None
+        self.visible_posts: list[Post] = []
 
         self.session = Session()
         adapter = HTTPAdapter(pool_connections=1, pool_maxsize=10, pool_block=False) # idk what is this, (claude added) just for better stability
@@ -143,6 +148,32 @@ class Client:
         else:
             self.dwell_tracker = None
 
+        if self.config.post_update_stats:
+            self._start_update_timer()
+
+
+    def _start_update_timer(self):
+        l.debug('start update timer')
+        if not self.config.post_update_stats_interval:
+            return
+
+        def loop():
+            while True:
+                sleep(self.config.post_update_stats_interval)
+                self.update_post_stats()
+
+        self._thread = Thread(target=loop)
+        self._thread.daemon = True
+        self._thread.start()
+
+        def on_exit():
+            l.debug('stop update timer')
+            if self._thread:
+                self._thread.join(timeout=0)
+
+        register(on_exit)
+
+
     def request(self, method: str, url: str, params: dict = {}, files: dict[str, tuple[str, BufferedReader | bytes]] = {}, level=AuthLevel.ACCESS):
         """Сделать запрос
 
@@ -160,17 +191,29 @@ class Client:
         if level >= AuthLevel.ACCESS and self.access_token is None and url != 'v1/auth/refresh':
             self.refresh_auth()
 
-        def _fetch():
-            return fetch(self, method, url, params, files)
+        return fetch(self, method, url, params, files)
 
-        if not self.refresh_token or url == 'v1/auth/refresh':
-            return _fetch()
+    def request_sse(self, url: str):
+        l.debug('sse %s', url)
 
-        try:
-            return _fetch()
-        except (UnauthorizedError, AccessTokenExpiredError):
+        if self.access_token is None and url != 'v1/auth/refresh':
             self.refresh_auth()
-            return _fetch()
+
+        return fetch_stream(self, url)
+
+
+    def update_post_stats(self):
+        if len(self.visible_posts) == 0:
+            return
+
+        l.debug('update post stats count=%s', len(self.visible_posts))
+        stats: list[dict] = get_stats(self, [post.id for post in self.visible_posts]).json().get('posts', [])
+        if len(stats) != len(self.visible_posts):
+            raise NotFoundError('Post(s)')
+
+        for post in self.visible_posts:
+            post._set_stats(next((stat for stat in stats if stat['id'] == str(post.id))))
+
 
     def refresh_auth(self) -> str:
         """Обновить access token
@@ -243,7 +286,7 @@ class Client:
             tuple[list[User], list[Hashtag]]: Результат поиска
         """
         res = search(self, query, users_limit, hashtags_limit).json()['data']
-        return [User._from_dict(user, False, self) for user in res['users']], [Hashtag._from_dict(hashtag, self) for hashtag in res['hashtags']]
+        return [User._from_dict(user, client=self) for user in res['users']], [Hashtag._from_dict(hashtag, self) for hashtag in res['hashtags']]
 
     def search_users(self, query: str, limit: int = 20) -> list[User]:
         """Поиск пользователей
@@ -295,6 +338,12 @@ class Client:
         if hashtag:
             return hashtag[0]
 
+    @overload
+    def get_follow_status(self, users: list[User | UUID | str]) -> dict[UUID, bool]: ...
+
+    @overload
+    def get_follow_status(self, users: User | UUID | str) -> bool: ...
+
     def get_follow_status(self, users: list[User | UUID | str] | User | UUID | str) -> dict[UUID, bool] | bool:
         """Получить статус подписки
 

{itd_sdk-2.3.0 → itd_sdk-2.4.1}/itd/comment.py

@@ -152,12 +152,12 @@ class _CommentValidate(BaseModel, Comment):
     @classmethod
     def validate_reply_to(cls, reply_to: dict | None):
         if reply_to is not None:
-            return User._from_dict(reply_to, False)
+            return User._from_dict(reply_to)
 
     @field_validator('author', mode='plain')
     @classmethod
     def validate_author(cls, author: dict):
-        return User._from_dict(author, False)
+        return User._from_dict(author)