itd-sdk 2.1.2__tar.gz → 2.2.0__tar.gz

{itd_sdk-2.1.2 → itd_sdk-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: itd-sdk
-Version: 2.1.2
+Version: 2.2.0
 Summary: ITD client for python
 Keywords: itd,itdsocial
 Author: firedotguy

{itd_sdk-2.1.2 → itd_sdk-2.2.0}/itd/api/auth.py

@@ -3,15 +3,16 @@ from typing import TYPE_CHECKING
 
 from requests import Response
 
-from itd.base import catch_errors
-from itd.request import fetch
+from itd.base import catch_errors, rate_limit
+from itd.enums import AuthLevel
 from itd.exceptions import InvalidPasswordError, SamePasswordError, InvalidOldPasswordError, SessionNotFoundError, SessionExpiredError, SessionRevokedError
 if TYPE_CHECKING:
     from itd.client import Client
 
+@rate_limit()
 @catch_errors(SessionExpiredError(), SessionNotFoundError(), SessionRevokedError())
 def refresh_token(client: Client) -> Response:
-    return fetch(client, 'post', 'v1/auth/refresh')
+    return client.request('post', 'v1/auth/refresh', level=AuthLevel.REFRESH)
 
 @catch_errors(InvalidPasswordError(), SamePasswordError(), InvalidOldPasswordError())
 def change_password(client: Client, old: str, new: str) -> Response:
@@ -19,4 +20,4 @@ def change_password(client: Client, old: str, new: str) -> Response:
 
 @catch_errors()
 def logout(client: Client) -> Response:
-    return client.request('post', 'v1/auth/logout')
+    return client.request('post', 'v1/auth/logout', level=AuthLevel.REFRESH)

{itd_sdk-2.1.2 → itd_sdk-2.2.0}/itd/api/hashtags.py

@@ -4,15 +4,16 @@ from typing import TYPE_CHECKING
 
 from itd.exceptions import TooLargeError, NotFoundError
 from itd.base import catch_errors, rate_limit
+from itd.enums import AuthLevel
 if TYPE_CHECKING:
     from itd.client import Client
 
 @rate_limit()
 @catch_errors()
 def get_hashtags(client: Client, limit: int = 10):
-    return client.request('get', 'hashtags/trending', {'limit': limit})
+    return client.request('get', 'hashtags/trending', {'limit': limit}, level=AuthLevel.NO)
 
 @rate_limit()
 @catch_errors(TooLargeError('Hashtag'), NotFoundError('Hashtag', json_check=lambda json: json.get('data', {}).get('hashtag', '') is None))
 def get_posts_by_hashtag(client: Client, hashtag: str, cursor: UUID | None = None, limit: int = 20):
-    return client.request('get', f'hashtags/{hashtag}/posts', {'limit': limit, 'cursor': cursor})
+    return client.request('get', f'hashtags/{hashtag}/posts', {'limit': limit, 'cursor': cursor}, level=AuthLevel.NO)

{itd_sdk-2.1.2 → itd_sdk-2.2.0}/itd/api/search.py

@@ -4,9 +4,10 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from itd.client import Client
 from itd.exceptions import ValidationError
+from itd.enums import AuthLevel
 from itd.base import catch_errors, rate_limit
 
 @rate_limit(None, 0.5, 3)
 @catch_errors(ValidationError())
 def search(client: Client, query: str, user_limit: int = 5, hashtag_limit: int = 5):
-    return client.request('get', 'search', {'userLimit': user_limit, 'hashtagLimit': hashtag_limit, 'q': query})
+    return client.request('get', 'search', {'userLimit': user_limit, 'hashtagLimit': hashtag_limit, 'q': query}, level=AuthLevel.NO)

{itd_sdk-2.1.2 → itd_sdk-2.2.0}/itd/base.py

@@ -147,7 +147,6 @@ class ITDList[T](ITDBaseModel, list[T]):
             length = len(objects)
             if objects and (client or self.client).config.userposts_add_pinned_post and length == batch + 1: # skip pinned post
                 length -= 1
-            l.debug('%s', objects)
 
             if left is not None:
                 left -= length
@@ -370,15 +369,15 @@ def rate_limit(delay_min: float | None = None, delay_mid: float | None = None, d
                 sleep(max(delay, 0))
             client.last_actions[func.__name__] = datetime.now()
 
-            if not client.config.retry_on_rate_limits:
+            if not client.config.retry_enabled:
                 return func(client, *args, **kwargs)
 
             while True:
                 try:
                     return func(client, *args, **kwargs)
-                except (RateLimitError, InternalError) as e:
-                    retry_after = getattr(e, 'retry_after', client.config.rate_limit_wait) or client.config.rate_limit_wait
-                    l.info('rate limit on %s; wait %ss', func.__name__, retry_after)
+                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)
                     sleep(retry_after)
 
         return wrapper

{itd_sdk-2.1.2 → itd_sdk-2.2.0}/itd/client.py

@@ -6,12 +6,13 @@ from dataclasses import dataclass, field
 from requests import Session
 from requests.utils import default_user_agent
 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
+from itd.exceptions import UnauthorizedError, InsufficientAuthLevelError, AccessTokenExpiredError, RateLimitError, InternalError
 from itd.hashtag import Hashtag
 from itd.request import fetch, decode_jwt_payload
-from itd.enums import RateLimitMode, All, DebugResponseMode, ParseMode, Batch, BATCH, UserAgent
+from itd.enums import RateLimitMode, All, DebugResponseMode, ParseMode, Batch, BATCH, UserAgent, AuthLevel
 from itd.user import Me, User
 from itd.api.auth import refresh_token, change_password, logout
 from itd.api.search import search
@@ -45,8 +46,13 @@ class Config:
     solve_challenge: bool = True
     load_comments_from_post: bool = False
     parse_mode: ParseMode = ParseMode.NO
-    rate_limit_wait: int = 10 # delay before next attempt (after rate limit error) if retry_after is not provided
-    retry_on_rate_limits: bool = True
+    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
+    bypass_auth_level: bool = False
 
     def __post_init__(self):
         if self.rate_limit_default:
@@ -73,10 +79,19 @@ 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
@@ -92,18 +107,20 @@ class Client:
         self.session.mount('https://', adapter)
 
         if access:
+            self.auth_level = AuthLevel.ACCESS
             self.access_token = access.replace('Bearer ', '')
 
         if refresh:
+            self.auth_level = AuthLevel.REFRESH
             self.refresh_token = refresh
             self.session.cookies.set('refresh_token', refresh, path='/', domain=self.config.url)
-            if access is None:
-                self.refresh_auth()
+            # if access is None:
+            #     self.refresh_auth()
 
         if _default_client is None or config.is_default:
             set_default_client(self)
 
-    def request(self, method: str, url: str, params: dict = {}, files: dict[str, tuple[str, BufferedReader | bytes]] = {}):
+    def request(self, method: str, url: str, params: dict = {}, files: dict[str, tuple[str, BufferedReader | bytes]] = {}, level=AuthLevel.ACCESS):
         """Сделать запрос
 
         Args:
@@ -112,11 +129,18 @@ class Client:
             params (dict, optional): Параметры. Defaults to {}.
             files (dict[str, tuple[str, BufferedReader | bytes]], optional): Файлы. Defaults to {}.
         """
-        l.debug('%s %s params=%s', method.upper(), url, params)
+        l.debug('%s %s params=%s authlevel=%s', method.upper(), url, params, level.value)
+
+        if level > self.auth_level and not self.config.bypass_auth_level:
+            raise InsufficientAuthLevelError(self.auth_level, level)
+
+        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)
 
-        if not self.refresh_token:
+        if not self.refresh_token or url == 'v1/auth/refresh':
             return _fetch()
 
         try:
@@ -132,8 +156,6 @@ class Client:
             str: Токен
         """
         l.debug('refresh token')
-        if not self.refresh_token:
-            raise InsufficientAuthLevelError()
 
         res = refresh_token(self)
         res.raise_for_status()

{itd_sdk-2.1.2 → itd_sdk-2.2.0}/itd/enums.py

@@ -1,6 +1,26 @@
 from enum import Enum
 from typing import Literal
 
+class AuthLevel(Enum):
+    NO = 'no'
+    ACCESS = 'access'
+    REFRESH = 'refresh'
+    # LOGIN = 'login' # 🤫
+
+    def __gt__(self, other):
+        return _AUTH_LEVEL_HIERARCHY.index(self) > _AUTH_LEVEL_HIERARCHY.index(other)
+
+    def __lt__(self, other):
+        return _AUTH_LEVEL_HIERARCHY.index(self) < _AUTH_LEVEL_HIERARCHY.index(other)
+
+    def __ge__(self, other):
+        return _AUTH_LEVEL_HIERARCHY.index(self) >= _AUTH_LEVEL_HIERARCHY.index(other)
+
+    def __le__(self, other):
+        return _AUTH_LEVEL_HIERARCHY.index(self) <= _AUTH_LEVEL_HIERARCHY.index(other)
+
+_AUTH_LEVEL_HIERARCHY = [AuthLevel.NO, AuthLevel.ACCESS, AuthLevel.REFRESH]
+
 class RateLimitMode(Enum):
     NO = 'no'
     MIN = 'min' # for one-time actions (eg script just to like post)
@@ -81,18 +101,18 @@ class AccessType(Enum):
     EVERYONE = 'everyone' # все
 
     def __gt__(self, other):
-        return _HIERARCHY.index(self) > _HIERARCHY.index(other)
+        return _ACCESS_TYPE_HIERARCHY.index(self) > _ACCESS_TYPE_HIERARCHY.index(other)
 
     def __lt__(self, other):
-        return _HIERARCHY.index(self) < _HIERARCHY.index(other)
+        return _ACCESS_TYPE_HIERARCHY.index(self) < _ACCESS_TYPE_HIERARCHY.index(other)
 
     def __ge__(self, other):
-        return _HIERARCHY.index(self) >= _HIERARCHY.index(other)
+        return _ACCESS_TYPE_HIERARCHY.index(self) >= _ACCESS_TYPE_HIERARCHY.index(other)
 
     def __le__(self, other):
-        return _HIERARCHY.index(self) <= _HIERARCHY.index(other)
+        return _ACCESS_TYPE_HIERARCHY.index(self) <= _ACCESS_TYPE_HIERARCHY.index(other)
 
-_HIERARCHY = [AccessType.EVERYONE, AccessType.FOLLOWERS, AccessType.MUTUAL, AccessType.EVERYONE] # 100% that hierarcy is spelled wrong
+_ACCESS_TYPE_HIERARCHY = [AccessType.EVERYONE, AccessType.FOLLOWERS, AccessType.MUTUAL, AccessType.EVERYONE] # 100% that hierarcy is spelled wrong
 
 
 class SpanType(Enum):

{itd_sdk-2.1.2 → itd_sdk-2.2.0}/itd/exceptions.py

@@ -2,6 +2,9 @@ from typing import Callable
 
 from requests import Response
 
+from itd.enums import AuthLevel
+
+
 class ITDException(Exception):
     code: str | None = None # ['error']['code']
     message: str | None = None # ['error']['message']
@@ -110,8 +113,8 @@ class InvalidPasswordError(PasswordError, ValidateError):
 class NoRightsError(ITDException): pass
 
 class InsufficientAuthLevelError(NoRightsError):
-    def __init__(self) :
-        self.text = 'Insufficient auth level'
+    def __init__(self, current: AuthLevel, requires: AuthLevel) :
+        self.text = f'Insufficient auth level (current is {current.name}, requires {requires.name})'
 
 class PinNotOwnedError(NoRightsError):
     code = "PIN_NOT_OWNED"
@@ -253,4 +256,4 @@ class ProfileRequiredError(ITDException):
     text = 'No profile. Please create your profile first'
 
 
-DEFAULT_ERRORS = (RateLimitError(), InvalidAccessTokenError(), UnauthorizedError(), AccessTokenExpiredError(), AccountBannedError(), InternalError(), ProfileRequiredError())
+DEFAULT_ERRORS = (RateLimitError(), InvalidAccessTokenError(), UnauthorizedError(), AccessTokenExpiredError(), AccountBannedError(), InternalError(), ProfileRequiredError(), RefreshTokenMissingError())

{itd_sdk-2.1.2 → itd_sdk-2.2.0}/itd/post.py

@@ -5,26 +5,37 @@ from time import sleep
 
 from pydantic import Field, BaseModel, field_validator
 
-from itd.base import ITDBaseModel, refresh_wrapper, ITDList
-from itd.client import Client
 from itd.comment import Comment, Comments
-from itd.enums import PostsTab, UserPostSorting, ReportReason, ReportTargetType, ParseMode, ALL
 from itd.file import PostAttach
 from itd.hashtag import Hashtag
 from itd.poll import Poll, NewPoll, PollOption
 from itd.report import Report
 from itd.span import Span
 from itd.user import User, _UserBase, Me
-from itd.utils import to_uuid, parse_datetime, format_attachments, ATTACHMENTS, parse_html, parse_md
+
 from itd.api.posts import (
     get_post, create_post, like_post, unlike_post, repost, view_post, pin_post, unpin_post,
     delete_post, restore_post, edit_post, get_posts, get_user_posts, get_liked_posts
 )
 from itd.api.hashtags import get_posts_by_hashtag
+from itd.base import ITDBaseModel, refresh_wrapper, ITDList
+from itd.client import Client
+from itd.enums import PostsTab, UserPostSorting, ReportReason, ReportTargetType, ParseMode, ALL
 from itd.logger import get_logger
+from itd.utils import to_uuid, parse_datetime, format_attachments, ATTACHMENTS, parse_html, parse_md
 
 l = get_logger('post')
 
+# class ViewerSession:
+#     def __init__(self, payload: dict) -> None:
+#         self.p = self.post_id = UUID(payload['p'])
+#         self.u = self.user_id = UUID(payload['u'])
+#         self.e = self.expires_at = datetime.fromtimestamp(payload['e'])
+#         if isinstance(payload['s'], list):
+#             self.s = self.source = [ViewSource(source) for source in payload['s']]
+#         else:
+#             self.s = self.source = ViewSource(payload['s'])
+
 
 class Post(ITDBaseModel):
     _validator = lambda _: _PostValidate
@@ -58,6 +69,8 @@ class Post(ITDBaseModel):
 
     wall_recipient_id: UUID | None = Field(None, alias='wallRecipientId')
     wall_recipient: User | None = Field(None, alias='wallRecipient')
+    # vs: ViewerSession
+    vs: str # from 13.05 it is string token
 
 
     def __init__(self, id: str | UUID, client: Client | None = None) -> None:
@@ -370,6 +383,11 @@ class _PostValidate(BaseModel, Post): # BaseModel MUST be first or you ll have s
         if wall_recipient is not None:
             return User._from_dict(wall_recipient, False)
 
+    # @field_validator('vs', mode='plain')
+    # @classmethod
+    # def validate_vs(cls, vs: str):
+    #     return ViewerSession(decode_jwt_payload(vs))
+
 
 
 class _BasePosts(ITDList[Post]):

{itd_sdk-2.1.2 → itd_sdk-2.2.0}/pyproject.toml

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