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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: itd-sdk
-Version: 2.5.2
+Version: 2.6.1
 Summary: ITD client for python
 Keywords: itd,itdsocial
 Author: fi-res
@@ -29,7 +29,7 @@ Description-Content-Type: text/markdown
 
 # itd-sdk
 
-[![ncruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/fi-res/ncruff)
+[![ncruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/fi-res/ncruff) [![EffVer Versioning](https://img.shields.io/badge/version_scheme-EffVer-0097a7)](https://jacobtomlinson.dev/effver)
 
 SDK для работы с [https://xn--d1ah4a.com](итд.com) на python.
 

{itd_sdk-2.5.2 → itd_sdk-2.6.1}/README.md

@@ -1,6 +1,6 @@
 # itd-sdk
 
-[![ncruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/fi-res/ncruff)
+[![ncruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/fi-res/ncruff) [![EffVer Versioning](https://img.shields.io/badge/version_scheme-EffVer-0097a7)](https://jacobtomlinson.dev/effver)
 
 SDK для работы с [https://xn--d1ah4a.com](итд.com) на python.
 

{itd_sdk-2.5.2 → itd_sdk-2.6.1}/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.1}/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.1/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.1}/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}')
+@api_wrapper(NotFoundError('Comment'), AlreadyDeletedError('Comment'), ForbiddenError('delete comment'))
+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.1/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.1}/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.1}/itd/base.py

@@ -4,13 +4,14 @@ from abc import abstractmethod
 from functools import wraps
 from time import sleep
 from typing import TYPE_CHECKING, Any, Callable, Iterator, SupportsIndex, TypeVar, cast, overload
+from uuid import UUID
 
 from pydantic import BaseModel
+from pydantic.fields import FieldInfo
 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,7 +51,9 @@ class ITDBaseModel:
 
     def __init__(self, client: Client | None = None) -> None:
         self._client = client or get_default_client()
+
         self._loaded_attrs: set[str] = set()
+        self._extra_context = {}
 
     def __setattr__(self, name: str, value: Any) -> None:
         if isinstance(value, ITDBaseModel) and (client := _getattr(self, '_client')):  # ai
@@ -72,32 +75,33 @@ class ITDBaseModel:
         if not self._refreshable:
             l.warning(f'{self.__class__.__name__} is not refreshable but refresh is called')
         self.load_status = LoadStatus.LOADING
-        self._fill_from_data(self._refresh(client=client or self.client))
+        self._fill_from_data(self._refresh(client=client or self.client), context={'client': client or self.client})
         self.load_status = LoadStatus.FULL
         return self
 
-    def _fill_from_data(self, data: dict):
+    def _fill_from_data(self, data: dict, *, context: dict = {}):
         assert self._validator, 'Unable to use fill_from_data without a validator'
-        validated = self._validator().model_validate(data)  # ty: ignore[missing-argument]
+        context.update(self._extra_context)
+        validated = self._validator().model_validate(data, context=context)  # 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()
 
     @classmethod
-    def from_dict(cls, data: dict, *, client: Client | None = None):
+    def from_dict(cls, data: dict, *, context: dict = {}, client: Client | None = None):
         instance = cls.__new__(cls)
         ITDBaseModel.__init__(instance, client)
 
-        instance._fill_from_data(data)
+        context.setdefault('client', client or instance.client)
+        instance._fill_from_data(data, context=context)
         instance.load_status = LoadStatus.PARTIALLY
         return instance
 
     if not TYPE_CHECKING:
 
         def __getattribute__(self, name: str) -> Any:
-
             try:
                 value = object.__getattribute__(self, name)
                 exc = None
@@ -111,14 +115,38 @@ class ITDBaseModel:
                 and name not in ('client', 'model_fields_set', 'load_status')
                 and not callable(value)
                 and not isinstance(_getattr(type(self), name), property)
-                and name not in _getattr(self, '_loaded_attrs')
                 and _getattr(self, 'load_status') in (LoadStatus.NO, LoadStatus.PARTIALLY)
+                and name not in (_getattr(self, '_loaded_attrs') or {name})
+                and self.client.config.load_on_getattr
                 and not (isinstance(value, ITDBaseModel) and not value._load_with_parent)
             ):
                 l.info('refresh %s field=%s load_status=%s', self.__class__.__name__, name, _getattr(self, 'load_status').value)
                 self.refresh()
                 return object.__getattribute__(self, name)
 
+            annotations = {}
+            [annotations.update(_getattr(c, '__annotations__')) for c in _getattr(self, '__class__').__mro__ if _getattr(c, '__annotations__')]
+
+            if isinstance(value, FieldInfo) or (not name.startswith('_') and exc is not None and not _getattr(self, 'client').config.load_on_getattr):
+                value_type = annotations[name]
+                if 'None' in value_type:
+                    l.warning('returned fake value None for %s: please load data (call refresh()) before get attributes', name)
+                    return None
+                elif value_type == 'int':
+                    l.warning('returned fake value 0 for %s: please load data (call refresh()) before get attributes', name)
+                    return 0
+                elif value_type == 'UUID':
+                    l.warning('returned fake value 00000000-0000-0000-0000-000000000010 for %s: please load data (call refresh()) before get attributes', name)
+                    return UUID('00000000-0000-0000-0000-000000000000')
+                elif value_type == 'str':
+                    l.warning('returned fake value "" for %s: please load data (call refresh()) before get attributes', name)
+                    return ''
+                elif value_type == 'bool':
+                    l.warning('returned fake value False for %s: please load data (call refresh()) before get attributes', name)
+                    return False  # дилема
+                l.error('cannot fake data for %s (type %s): please load data (call refresh()) before get attributes', name, value_type)
+                raise RuntimeError(f'cannot fake data for {name} (type {value_type}): please load data (call refresh()) before get attributes')
+
             if exc is not None:
                 raise exc
             return value
@@ -134,6 +162,7 @@ class ITDList(ITDBaseModel, list[T]):
     _refreshable = False
     has_more = True
     idx = 0
+    _is_page_pagination: bool = False
 
     def _fetch(self, client: Client, limit: int) -> dict:
         return {}
@@ -155,9 +184,15 @@ class ITDList(ITDBaseModel, list[T]):
             l.warning('skip load because has_more=False')
             return []
 
-        limit = limit or (client or self.client).config.batch_sizes._values[self.__class__.__name__.lower()]
+        default_limit = (client or self.client).config.batch_sizes._values[self.__class__.__name__.lower()]
+        limit = limit or default_limit
         if isinstance(count, int) and count < limit:
             limit = count
+
+        if self._is_page_pagination and limit != default_limit:
+            l.warning('unable to change limit in %s (page pagination), using default %s', self.__class__.__name__.lower(), default_limit)
+            count = limit = default_limit
+
         l.debug('load %s count=%s limit=%s cursor=%s', self.__class__.__name__.lower(), count, limit, self.cursor)
 
         # Batch = load one batch (limit), All = load everything, int = load exactly N
@@ -263,7 +298,7 @@ class ITDList(ITDBaseModel, list[T]):
             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):
+            elif self._is_page_pagination or isinstance(self.client.config.load_on_getitem, Batch):
                 l.debug('getitem load batch')
                 self.load(BATCH)
             else:
@@ -277,7 +312,7 @@ class ITDList(ITDBaseModel, list[T]):
         if getattr(self, 'total', None) and self.idx >= self.total:
             raise StopIteration()
         if self.idx >= len(self) and (self.has_more or self.client.config.force_load_lists):
-            l.debug('not enough items to call next - load')
+            l.debug('not enough items to call next, load')
             self.load(self.client.config.load_on_iter)
         if self.idx >= len(self):
             raise StopIteration()
@@ -295,6 +330,11 @@ class ITDList(ITDBaseModel, list[T]):
     def all(self) -> list[T]:
         return self.load_all()
 
+    def clear(self):
+        super().clear()
+        self.cursor = None
+        self.has_more = True
+
 
 def _filter_bytes(args: tuple):
     filtered = []
@@ -306,7 +346,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 +361,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 +387,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 +457,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