itd-sdk 2.9.0__tar.gz → 2.9.2__tar.gz

{itd_sdk-2.9.0 → itd_sdk-2.9.2}/PKG-INFO

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

{itd_sdk-2.9.0 → itd_sdk-2.9.2}/itd/__init__.py

@@ -37,7 +37,7 @@ from time import sleep
 __version__ = version('itd-sdk')
 
 from itd.core.client import Client as ITDClient
-from itd.core.client import init_client
+from itd.core.client import init_client, init_not_authed_client
 from itd.core.config import Config as ITDConfig
 from itd.core.default import LimiterConfig, limiters
 from itd.core.default import set_config as set_limiter_config
@@ -51,8 +51,9 @@ from itd.models.notification import Notification, Notifications, Ntf, Ntfs
 from itd.models.poll import NewPoll
 from itd.models.portal import Portal
 from itd.models.post import HashtagPosts, LikedPosts, Post, Posts, UserPosts
+from itd.models.search import Search
 from itd.models.session import Sessions
-from itd.models.user import Me, User, Users, get_follow_status
+from itd.models.user import Me, User, Users, WhoToFollow, get_follow_status
 from itd.models.version import Apps, Changelog
 
 
@@ -71,6 +72,7 @@ __all__ = [
     'ITDClient',
     'ITDConfig',
     'init_client',
+    'init_not_authed_client',
     'Comment',
     'Clan',
     'TopClans',
@@ -94,6 +96,8 @@ __all__ = [
     'Me',
     'Users',
     'Portal',
+    'WhoToFollow',
+    'Search',
     'get_follow_status',
     'set_limiter_config',
     'LimiterConfig',

{itd_sdk-2.9.0 → itd_sdk-2.9.2}/itd/api/notifications.py

@@ -15,8 +15,9 @@ def get_notifications(client: Client, limit: int = 20, offset: int = 0):
     return {'limit': limit, 'offset': offset}
 
 
-@endpoint('post', 'notifications/{id}/read', NotFoundError('Notification', json_check=lambda json: json.get('success') is False))
-def mark_as_read(client: Client, id: UUID): ...
+@endpoint('post', 'notifications/read-batch', NotFoundError('Notification', json_check=lambda json: json.get('success') is False))
+def mark_as_read(client: Client, id: UUID):
+    return {'ids': [str(id)]}
 
 
 @endpoint('post', 'notifications/read-all')

{itd_sdk-2.9.0 → itd_sdk-2.9.2}/itd/api/search.py

@@ -2,14 +2,14 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from itd.core.request import endpoint
 from itd.enums import AuthLevel
 from itd.exceptions import ValidationError
-from itd.core.request import endpoint
 
 if TYPE_CHECKING:
     from itd.core.client import Client
 
 
 @endpoint('get', 'search', ValidationError(), level=AuthLevel.NO)
-def search(client: Client, query: str, user_limit: int = 5, hashtag_limit: int = 5):
-    return {'userLimit': user_limit, 'hashtagLimit': hashtag_limit, 'q': query}
+def search(client: Client, query: str, users_limit: int = 10, hashtags_limit: int = 10):
+    return {'userLimit': users_limit, 'hashtagLimit': hashtags_limit, 'q': query}

{itd_sdk-2.9.0 → itd_sdk-2.9.2}/itd/core/auth.py

@@ -1,10 +1,12 @@
+from contextlib import contextmanager
+from dataclasses import dataclass
 from os import getenv
 from typing import TYPE_CHECKING
 
 from itd.api.auth import sign_in
 from itd.core.captcha import get_turnstile
 from itd.core.logger import RICH_AVAILABLE, get_logger, iprint, rich_input
-from itd.core.qr import auth_qr
+from itd.core.qr import interactive_auth_qr
 from itd.core.utils import shorten_token
 from itd.exceptions import (
     AccessTokenExpiredError,
@@ -28,17 +30,25 @@ if RICH_AVAILABLE:
 l = get_logger('auth')
 
 
-def _auth_login(client: 'Client', email: str, password: str):
-    client._profile.email = email
-    client._profile.password = password
-    client._profile.creds_valid = True
-    client._set_from_profile()
+@contextmanager
+def _status(text: str):
+    if not RICH_AVAILABLE:
+        iprint(l, text)
+        yield None
+        return
+    with Status(text) as status:
+        yield status
 
-    def _sign_in(turnstile):
+
+def _auth_login(client: 'Client', email: str, password: str) -> bool:
+    with _status('Solving captcha..') as status:
+        turnstile = get_turnstile(client, status=status)
+        if status:
+            status.update('Verifying..')
         try:
-            res = sign_in(client, client._profile.email, client._profile.password, 'turnstileToken', turnstile)
+            apply_auth(client, CredentialsAuth(email, password, turnstile))
         except CaptchaFailedError:
-            l.error('captcha verify failed. Please fill issue at https://github.com/itd-sdk/itd-sdk/issues/new')
+            l.error('captcha verify failed; please fill issue at https://github.com/itd-sdk/itd-sdk/issues/new')
         except InvalidCredentialsError:
             l.error('invalid email or password')
         except EmailDomainNotAllowedError:
@@ -46,34 +56,15 @@ def _auth_login(client: 'Client', email: str, password: str):
         except InvalidEmailError:
             l.error('invalid email format')
         else:
-            client._profile.set_refresh(res.cookies['refresh_token'], set_expire=True)
-            client._profile.set_access(res.json()['accessToken'])
-            client._profile.creds_valid = True
-            return True
-
-    if RICH_AVAILABLE:
-        with Status('Solving captcha..') as status:
-            turnstile = get_turnstile(client, status=status)
-            status.update('Verifying..')
-            if _sign_in(turnstile):
-                iprint(l, 'accepted')
-                return True
-    else:
-        iprint(l, 'solving captcha..')
-        if _sign_in(get_turnstile(client)):
             iprint(l, 'accepted')
             return True
+    return False
 
-    client._profile.creds_valid = False
-
-
-def _auth_refresh(client: 'Client', refresh: str):
-    client._profile.set_refresh(refresh, set_expire=True)
-    client._set_from_profile()
 
-    def _verify():
+def _auth_refresh(client: 'Client', refresh: str) -> bool:
+    with _status('Verifying..'):
         try:
-            client.refresh_auth()
+            apply_auth(client, RefreshAuth(refresh))
         except SessionExpiredError:
             l.error('refresh token expired')
         except SessionNotFoundError:
@@ -81,28 +72,15 @@ def _auth_refresh(client: 'Client', refresh: str):
         except SessionRevokedError:
             l.error('refresh token revoked')
         else:
-            return True
-
-    if RICH_AVAILABLE:
-        with Status('Verifying..'):
-            if _verify():
-                iprint(l, 'accepted')
-                return True
-    else:
-        if _verify():
             iprint(l, 'accepted')
             return True
+    return False
 
-    client._profile.refresh_valid = False
-
-
-def _auth_access(client: 'Client', access: str):
-    client._profile.set_access(access)
-    client._set_from_profile()
 
-    def _verify():
+def _auth_access(client: 'Client', access: str) -> bool:
+    with _status('Verifying..'):
         try:
-            client.user.refresh()
+            apply_auth(client, AccessAuth(access))
         except AccessTokenExpiredError:
             l.error('access token expired')
         except InvalidAccessTokenError:
@@ -110,19 +88,95 @@ def _auth_access(client: 'Client', access: str):
         except JWTAlgorithmUnsupportedError:
             l.error('jwt algorithm unsupported')
         else:
-            return True
-
-    if RICH_AVAILABLE:
-        with Status('Verifying..'):
-            if _verify():
-                iprint(l, 'accepted')
-                return True
-    else:
-        if _verify():
             iprint(l, 'accepted')
             return True
+    return False
+
+
+@dataclass
+class CredentialsAuth:
+    email: str
+    password: str
+    turnstile: str | None = None
 
-    client._profile.access_valid = False
+
+@dataclass
+class RefreshAuth:
+    refresh: str
+    access: str | None = None
+
+
+@dataclass
+class AccessAuth:
+    access: str
+
+
+AuthMethod = CredentialsAuth | RefreshAuth | AccessAuth
+
+
+def apply_auth(client: 'Client', auth: AuthMethod | None) -> None:
+    match auth:
+        case CredentialsAuth():
+            client._profile.email = auth.email
+            client._profile.password = auth.password
+            client._profile.creds_valid = True
+            client._set_from_profile()
+            try:
+                res = sign_in(client, auth.email, auth.password, 'turnstileToken', auth.turnstile or get_turnstile(client)[1])
+            except Exception:
+                client._profile.email = None
+                client._profile.password = None
+                client._profile.creds_valid = False
+                client._set_from_profile()
+                raise
+            client._profile.set_refresh(res.cookies['refresh_token'], set_expire=True)
+            client._profile.set_access(res.json()['accessToken'])
+
+        case RefreshAuth():
+            client._profile.set_refresh(auth.refresh, set_expire=True)
+            if auth.access:
+                client._profile.set_access(auth.access)
+            client._set_from_profile()
+            try:
+                client.refresh_auth()
+            except Exception:
+                client._profile.refresh_valid = False
+                client._set_from_profile()
+                raise
+
+        case AccessAuth():
+            client._profile.set_access(auth.access)
+            client._set_from_profile()
+            try:
+                client.user.refresh()
+            except Exception:
+                client._profile.access_valid = False
+                client._set_from_profile()
+                raise
+
+    client._profile.flush()
+
+
+def env_auth(client: 'Client') -> bool:
+    method = getenv('ITD_AUTH_METHOD')
+    if not method:
+        return False
+
+    match method:
+        case 'login':
+            auth = CredentialsAuth(getenv('ITD_LOGIN', ''), getenv('ITD_PASSWORD', ''))
+        case 'refresh':
+            auth = RefreshAuth(getenv('ITD_REFRESH', ''))
+        case 'access':
+            auth = AccessAuth(getenv('ITD_ACCESS', ''))
+        case 'no':
+            auth = None
+        case _:
+            raise ValueError(f'unknown env auth method {method}')
+
+    apply_auth(client, auth)
+    l.info('authorized env method=%s', method)
+    return True
 
 
 def interactive_auth(client: 'Client') -> bool:
@@ -141,24 +195,6 @@ def interactive_auth(client: 'Client') -> bool:
         return True
     client._credtest = True
 
-    if getenv('ITD_AUTH_METHOD'):
-        match getenv('ITD_AUTH_METHOD'):
-            case 'login':
-                if _auth_login(client, getenv('ITD_LOGIN', ''), getenv('ITD_PASSWORD', '')):
-                    return True
-            case 'refresh':
-                if _auth_refresh(client, getenv('ITD_REFRESH', '')):
-                    return True
-            case 'access':
-                if _auth_access(client, getenv('ITD_ACCESS', '')):
-                    return True
-            case _:
-                l.error('unknown option')
-                quit()
-
-        l.error('auth failed')
-        quit()
-
     if not client._profile.refresh_valid and client._profile.refresh:
         l.warning('session file refresh token is not valid')
 
@@ -173,7 +209,8 @@ def interactive_auth(client: 'Client') -> bool:
     iprint(l, '[2] Login via QR code')
     iprint(l, '[3] Manually auth using refresh token')
     iprint(l, '[4] Manually auth using access token')
-    iprint(l, '[5] Quit')
+    iprint(l, '[5] Init client with authorization')
+    iprint(l, '[6] Quit')
 
     while True:
         option = rich_input('option', 'magenta')
@@ -183,7 +220,7 @@ def interactive_auth(client: 'Client') -> bool:
                 if _auth_login(client, rich_input('email', 'green'), rich_input('password', 'green', password=True)):
                     return True
             case '2':
-                if auth_qr(client):
+                if interactive_auth_qr(client):
                     return True
             case '3':
                 if _auth_refresh(client, rich_input('refresh token', 'cyan', password=True)):
@@ -192,7 +229,9 @@ def interactive_auth(client: 'Client') -> bool:
                 l.info('note: authorization will work only for ~15min')
                 if _auth_access(client, rich_input('access token', 'cyan')):
                     return True
-            case '5' | 'q' | 'quit':
+            case '5':
+                return True
+            case '6' | 'q' | 'quit':
                 quit()
             case _:
                 l.error('unknown option')

{itd_sdk-2.9.0 → itd_sdk-2.9.2}/itd/core/captcha/__init__.py

@@ -19,7 +19,7 @@ def get_turnstile(client: 'Client | None' = None, status=None) -> str:  # tuple[
     #     raise RuntimeError(f'Unknown provider: {provider_data["provider"]}')
 
     # provider = providers[provider_data['provider']]()
-    if client and client.config.captcha_solve:
+    if client and not client.config.captcha_solve:
         l.warning('captcha solving disabled')
         iprint(l, 'solve captcha on other devices via `uv run itd captcha`, then paste result here')
         iprint(l, 'enter `continue` to force solve captcha on this device')
@@ -32,7 +32,7 @@ def get_turnstile(client: 'Client | None' = None, status=None) -> str:  # tuple[
             status.start()
 
     if not CAPTCHA_AVAILABLE:
-        l.error('captcha libraries not installed; install via `uv add itd-sdk[captcha]`')
+        l.error(r'captcha libraries not installed; install via `uv add itd-sdk\[captcha]`')
     provider = CloudflareProvider(False if not client else client.config.captcha_headless)
     provider.launch()
     turnstile = provider.solve()

{itd_sdk-2.9.0 → itd_sdk-2.9.2}/itd/core/client.py

@@ -12,7 +12,7 @@ from requests import Response, Session
 from requests.adapters import HTTPAdapter
 
 from itd.api.auth import change_password, logout, refresh_token, sign_in
-from itd.core.auth import interactive_auth
+from itd.core.auth import AuthMethod, apply_auth, env_auth, interactive_auth
 from itd.core.captcha import get_turnstile
 from itd.core.config import Config
 from itd.core.default import maybe_get_default_client, set_default_client
@@ -20,7 +20,6 @@ from itd.core.dwell import DwellTracker
 from itd.core.logger import get_logger
 from itd.core.profile import Profile, clear_anon_profile
 from itd.core.request import fetch
-from itd.core.utils import get_profile
 from itd.core.visibility import VisibilityTracker
 from itd.enums import AuthLevel
 from itd.exceptions import AccessTokenExpiredError, InsufficientAuthLevelError, SessionExpiredError
@@ -33,26 +32,31 @@ l = get_logger('client')
 
 
 class Client:
-    def __init__(self, name: str, config: Config | None = None):
+    def __init__(self, name: str, config: Config | None = None, auth: AuthMethod | None = None):
         l.info('init client %s', name)
         self.config = config or Config()
 
-        self.auth_level: AuthLevel = AuthLevel.NO
-        self._profile: Profile = get_profile(name)
-
-        self._refresh_lock = RLock()  # so background timers and main thread dont refresh token simultaneously # еба он мой стиль коментов спиздил
-
         self.session = Session()
         adapter = HTTPAdapter(pool_connections=1, pool_maxsize=10, pool_block=False)  # idk what is this, (claude added) just for better stability
         self.session.mount('https://', adapter)
 
+        self.auth_level: AuthLevel = AuthLevel.NO
+        self._profile: Profile = Profile.get(name)
+        self._set_from_profile()
+
+        self._refresh_lock = RLock()  # so background timers and main thread dont refresh token simultaneously # еба он мой стиль коментов спиздил
+
         if maybe_get_default_client() is None or self.config.is_default:
             set_default_client(self)
 
-        interactive_auth(self)
-        self._set_from_profile()
+        self._credtest = True
+        if auth is not None:
+            apply_auth(self, auth)
+        if name != 'no-auth' and self.auth_level == AuthLevel.NO:
+            if not env_auth(self) and self.config._interactive_auth:
+                interactive_auth(self)
         self._profile.flush()
-        self._credtest = False  # skip all checks and refreshing to test credentials
+        self._credtest = False
 
         self.dwell_tracker = DwellTracker(self)
         self.dwell_tracker.start()
@@ -132,6 +136,7 @@ class Client:
 
         if level >= AuthLevel.REFRESH and ((self._profile.refresh and self._profile.is_refresh_expired) or not self._profile.refresh_valid):
             self._profile.refresh_valid = False
+            self._profile.flush()
             if self.auth_level == AuthLevel.LOGIN:
                 self.login()
             else:
@@ -145,6 +150,7 @@ class Client:
             and ((self._profile.access_data and self._profile.access_data.is_expired) or not self._profile.access_valid)
         ):
             self._profile.access_valid = False
+            self._profile.flush()
             if self.auth_level >= AuthLevel.REFRESH:
                 self.refresh_auth()
             else:
@@ -209,8 +215,12 @@ class Client:
         change_password(self, old, new)
 
 
-def init_client(name: str | None = None, config: Config = Config()) -> Client:
+def init_client(name: str | None = None, config: Config | None = None, auth: AuthMethod | None = None) -> Client:
     if name == 'anon':
         clear_anon_profile()
         register(clear_anon_profile)
-    return Client(name or 'default', config=config)
+    return Client(name or 'default', config=config, auth=auth)
+
+
+def init_not_authed_client(config: Config | None = None):
+    return Client('no-auth', config=config)

{itd_sdk-2.9.0 → itd_sdk-2.9.2}/itd/core/config.py

@@ -114,7 +114,8 @@ class Config:
     on_exceptions: dict[type[Exception], Callable[[Exception], None]] = field(default_factory=dict)
     batch_sizes: BatchSizes = field(default_factory=BatchSizes)
     refresh_token_cookie_name: str = 'refresh_token'
-    token_expiry_margin: float = 60  # how many seconds before expiration access token is considered expired (margin for network and clock skew)
+
+    interactive_auth: bool | None = None
 
     def __post_init__(self):
         match self.user_agent:
@@ -162,3 +163,8 @@ class Config:
                 self._retry_exceptions = ()
         else:
             self._retry_exceptions = self.retry_exceptions
+
+        if self.interactive_auth is None:
+            self._interactive_auth = self.client_type != 'client'
+        else:
+            self._interactive_auth = self.interactive_auth

{itd_sdk-2.9.0 → itd_sdk-2.9.2}/itd/core/profile.py

@@ -51,16 +51,18 @@ class Profile(BaseModel):
     def flush(self):
         assert self._file
         self.updated_at = datetime.now()
+        if self._file.name == 'no-auth':
+            return
         self._file.write_text(dumps(self.model_dump(mode='json')))
 
     def update(self):
         assert self._file
+        if self._file.name == 'no-auth':
+            return False
         new = self.model_validate(loads(self._file.read_text()))
-        if self.updated_at <= new.updated_at:
-            for field in Profile.model_fields:
-                setattr(self, field, getattr(new, field))
-            return True
-        return False
+        for field in Profile.model_fields:
+            setattr(self, field, getattr(new, field))
+        return True
 
     @property
     def is_refresh_expired(self) -> bool:
@@ -88,9 +90,10 @@ class Profile(BaseModel):
     @classmethod
     def get(cls, name: str):
         file = user_data_path('itd_sdk', False, ensure_exists=True) / f'{name}.json'
-        instance = cls(_file=file)
+        instance = cls()
+        instance._file = file
         if not file.exists():
-            instance = cls(_file=file)
+            instance.flush()
         else:
             instance.update()
 

itd_sdk-2.9.2/itd/core/qr.py

@@ -0,0 +1,169 @@
+from json import loads
+from time import sleep
+from typing import TYPE_CHECKING, Iterator
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+from sseclient import SSEClient
+
+from itd.api.auth import qr_claim, qr_start, qr_stream
+from itd.core.logger import RICH_AVAILABLE, get_logger, iprint
+
+if TYPE_CHECKING:
+    from itd.core.client import Client
+    from itd.core.config import Config
+
+try:
+    from qrcode import QRCode
+
+    QR_AVAILABLE = True
+except ImportError:
+    QR_AVAILABLE = False
+
+try:
+    from rich.status import Status
+except ImportError:
+    pass
+
+l = get_logger('qr')
+
+
+class ITDQRCode(BaseModel):
+    id: UUID = Field(alias='qrId')
+    payload: str
+    claim_token: str = Field(alias='claimToken')
+    expires_in: int = Field(90, alias='expiresIn')
+
+
+class QRLogin:
+    def __init__(self):
+        from itd import init_not_authed_client
+
+        self.client = init_not_authed_client()
+        self.stream = None
+        self.qr = None
+        self.auth = None
+        self.status = 'pending'
+        self.refresh()
+
+    def refresh(self) -> ITDQRCode:
+        self.close()
+        self.qr = ITDQRCode.model_validate(qr_start(self.client).json())
+        l.debug('qr code: id=%s claim_token=%s', self.qr.id, self.qr.claim_token)
+        return self.qr
+
+    def events(self) -> Iterator[str]:
+        assert self.qr
+        self.stream = qr_stream(self.client, qr_id=self.qr.id, claim_token=self.qr.claim_token)
+        l.debug('start stream')
+        try:
+            for event in SSEClient(self.stream).events():
+                self.status = loads(event.data)['status']
+                l.debug('qr code status: %s', self.status)
+                yield self.status
+                if self.status in ('approved', 'rejected'):
+                    break
+
+            if self.status == 'approved':
+                self.claim()
+                self.status = 'authorized'
+                yield 'authorized'
+            elif self.status != 'rejected':
+                l.debug('expire qr')
+                self.status = 'expired'
+                yield 'expired'
+
+        finally:
+            self.close()
+            l.debug('stop stream')
+
+    def claim(self):
+        from itd.core.auth import RefreshAuth
+
+        assert self.qr
+        res = qr_claim(self.client, qr_id=self.qr.id, claim_token=self.qr.claim_token)
+        self.auth = RefreshAuth(res.cookies['refresh_token'], res.json()['accessToken'])
+
+    def get_client(self, name: str | None = None, config: 'Config | None' = None):
+        from itd import ITDConfig, init_client
+
+        if config is None:
+            config = ITDConfig()
+        config.is_default = True
+
+        assert self.auth
+        return init_client(name, config, auth=self.auth)
+
+    def close(self):
+        if self.stream:
+            self.stream.close()
+            self.stream = None
+
+    def __enter__(self) -> 'QRLogin':
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.close()
+
+
+def interactive_auth_qr(client: 'Client'):
+    if not QR_AVAILABLE:
+        l.error(r'qrcode library not installed; install via `uv add itd-sdk\[qrcode]`')
+        return False
+
+    if RICH_AVAILABLE:
+        status = Status('Waiting for scan')
+        status.start()
+    else:
+        status = None
+
+    with QRLogin() as qr:
+        try:
+            for _ in range(5):
+                qr.refresh()
+                if status:
+                    status.update('Generating QR')
+                assert qr.qr
+                ascii_qr = QRCode(border=2)
+                ascii_qr.add_data(qr.qr.payload)
+                iprint(l, 'scan QR code with mobile app:')
+                ascii_qr.print_ascii(invert=True)
+                if status:
+                    status.update('Waiting for scan')
+
+                for event in qr.events():
+                    if event == 'approved':
+                        iprint(l, 'qr code approved')
+                        assert qr.auth
+                        assert qr.auth.access
+                        client._profile.set_access(qr.auth.access)
+                        client._profile.set_refresh(qr.auth.refresh, set_expire=True)
+                        return True
+
+                    elif event == 'rejected':
+                        l.error('qr code rejected')
+                        break
+
+                    elif event == 'scanned':
+                        iprint(l, 'qr code scanned')
+                        if status:
+                            status.update('Waiting for accept')
+
+                    elif event == 'pending':
+                        iprint(l, 'qr code pending')
+
+                    # elif res['status'] == 'captcha_required':
+                    #     iprint(l, 'captcha required')
+                    #     if status:
+                    #         status.update('Solving captcha')
+                    #     turnstile = get_turnstile(client)
+
+                sleep(5)
+
+            l.error('all retries to auth qr exceeded')
+            return False
+        finally:
+            if status:
+                status.stop()
+            if qr.stream:
+                qr.stream.close()

{itd_sdk-2.9.0 → itd_sdk-2.9.2}/itd/core/request.py

@@ -241,6 +241,7 @@ def api_wrapper(*exceptions: ITDException):
                     # token is checked before the request, but server still can reject it (clock skew, revoked session) - refresh and repeat the request once, before callbacks
                     if isinstance(exception, (AccessTokenExpiredError, InvalidAccessTokenError)) and not access_reauthed and not client._credtest:
                         client._profile.access_valid = False
+                        client._profile.flush()
                         if name != 'refresh_token':
                             access_reauthed = True
                             l.warning('%s on %s: refresh access_token and retry', exception.__class__.__name__, name)
@@ -252,9 +253,10 @@ def api_wrapper(*exceptions: ITDException):
                         and not refresh_reauthed
                         and not client._credtest
                     ):
-                        refresh_reauthed = True
+                        client._profile.refresh_valid = False
+                        client._profile.flush()
                         if name != 'sign_in':
-                            client._profile.refresh_valid = False
+                            refresh_reauthed = True
                             l.warning('%s on %s: refresh refresh_token and retry', exception.__class__.__name__, name)
                             client.login()
                             return exec()

{itd_sdk-2.9.0 → itd_sdk-2.9.2}/itd/core/utils.py

@@ -1,12 +1,7 @@
 from datetime import datetime
-from json import dumps, loads
 from sys import version
 from uuid import UUID
 
-from platformdirs import user_data_path
-
-from itd.core.profile import Profile
-
 
 def get_sdk_user_agent():
     from itd import __version__  # i fucking hate circular imports this is sooo stupid
@@ -14,17 +9,6 @@ def get_sdk_user_agent():
     return f'itd-sdk/{__version__} (Python/{version})'
 
 
-def get_profile(name: str) -> Profile:
-    file = user_data_path('itd_sdk', False, ensure_exists=True) / f'{name}.json'
-    if not file.exists():
-        model = Profile(_file=file)
-        file.write_text(dumps(model.model_dump(mode='json')))
-    else:
-        model = Profile.model_validate(loads(file.read_text()))
-    model._file = file
-    return model
-
-
 def shorten_token(value: str | None, max_len: int = 20):
     if value is None:
         return None

{itd_sdk-2.9.0 → itd_sdk-2.9.2}/itd/enums.py

@@ -51,7 +51,7 @@ class AuthLevel(Enum):
     NO = 'no'
     ACCESS = 'access'
     REFRESH = 'refresh'
-    LOGIN = 'login'
+    LOGIN = 'login'  # todo rename to creds
 
     def __gt__(self, other):
         return _AUTH_LEVEL_HIERARCHY.index(self) > _AUTH_LEVEL_HIERARCHY.index(other)

itd_sdk-2.9.2/itd/models/search.py

@@ -0,0 +1,38 @@
+from typing import TYPE_CHECKING
+
+from itd.api.search import search
+from itd.core.base import ITDBaseModel
+from itd.models.hashtag import Hashtag
+from itd.models.user import User
+
+if TYPE_CHECKING:
+    from itd.core.client import Client
+
+
+class Search(ITDBaseModel):
+    _refreshable = False
+    users: list[User]
+    hashtags: list[Hashtag]
+
+    def __init__(self, query: str, users_limit: int = 20, hashtags_limit: int = 20, *, client: 'Client | None' = None):
+        super().__init__(client=client)
+        self.query = query
+        self.users_limit = users_limit
+        self.hashtags_limit = hashtags_limit
+        self.refresh()
+
+    def refresh(self, client: 'Client | None' = None):
+        client = client or self.client
+        res = search(client, self.query, self.users_limit, self.hashtags_limit).json()['data']
+        self.users = [User.from_dict(user, client=client) for user in res['users']]
+        self.hashtags = [Hashtag.from_dict(hashtags, client=client) for hashtags in res['hashtags']]
+
+    def __iter__(self):
+        yield from self.users
+        yield from self.hashtags
+
+    def __len__(self) -> int:
+        return len(self.users) + len(self.hashtags)
+
+    def __bool__(self) -> bool:
+        return bool(self.users or self.hashtags)

{itd_sdk-2.9.0 → itd_sdk-2.9.2}/itd/models/utils.py

@@ -58,10 +58,11 @@ def parse_html(text: str) -> tuple[str, list[Span]]:
     """Спарсить HTML
 
     Поддерживаемые теги:
-    - <b>, <i>, <s>, <u>, <code>, <spoiler>, <q>, <a href="url">text</a>, <a>url</a>
+    - `<b>, <i>, <s>, <u>, <code>, <spoiler>, <q>`
+    - `<a href="url">text</a>` или `<а>url</а>` (ссылки)
 
     Args:
-        text: HTML-строка для парсинга
+        text (str): HTML-строка для парсинга
 
     Returns:
         str: чистая строка
@@ -84,18 +85,18 @@ def parse_html(text: str) -> tuple[str, list[Span]]:
     return root.text_content(), spans
 
 
-def parse_md(md: str) -> tuple[str, list[Span]]:
+def parse_md(text: str) -> tuple[str, list[Span]]:
     """Спарсить markdown
 
     Поддерживаемые теги:
     - *, _, **, __, ~, ~~, `, ||, \\[text](url)
 
     Args:
-        text: строка для парсинга
+        text (str): строка для парсинга
 
     Returns:
         str: чистая строка
         list[Span]: список спанов
     """
-    text, spans = convert(md, latex_escape=False)
+    text, spans = convert(text, latex_escape=False)
     return text, [Span.model_validate(span, from_attributes=True) for span in spans]

{itd_sdk-2.9.0 → itd_sdk-2.9.2}/pyproject.toml

@@ -14,7 +14,7 @@ version_provider = "uv"
 
 [project]
 name = "itd-sdk"
-version = "2.9.0"
+version = "2.9.2"
 description = "ITD client for python"
 readme = "README.md"
 authors = [
@@ -66,6 +66,10 @@ captcha = [
 dev = [
     "pytest>=8.4.2",
     "python-dotenv>=1.2.1",
+    "griffe-typingdoc>=0.3.0",
+    "mkdocs>=1.6.1",
+    "mkdocs-material>=9.7.6",
+    "mkdocstrings[python]>=0.30.1"
 ]
 
 [project.scripts]

itd_sdk-2.9.0/itd/core/qr.py

@@ -1,112 +0,0 @@
-from json import loads
-from time import sleep
-from typing import TYPE_CHECKING
-from uuid import UUID
-
-from pydantic import BaseModel, Field
-from sseclient import SSEClient
-
-from itd.api.auth import qr_claim, qr_start, qr_stream
-from itd.core.logger import RICH_AVAILABLE, get_logger, iprint
-
-if TYPE_CHECKING:
-    from itd.core.client import Client
-
-try:
-    from qrcode import QRCode
-
-    QR_AVAILABLE = True
-except ImportError:
-    QR_AVAILABLE = False
-
-try:
-    from rich.status import Status
-except ImportError:
-    pass
-
-l = get_logger('qr')
-
-
-class ITDQRCode(BaseModel):
-    id: UUID = Field(alias='qrId')
-    payload: str
-    claim_token: str = Field(alias='claimToken')
-    expires_in: int = Field(90, alias='expiresIn')
-
-
-def auth_qr(client: 'Client'):
-    if not QR_AVAILABLE:
-        l.error('qrcode library not installed; install via `uv add itd-sdk[qrcode]`')
-        return False
-
-    itd_qr = None
-
-    def generate_qr():
-        nonlocal itd_qr
-        if status:
-            status.update('Generating QR')
-        itd_qr = ITDQRCode.model_validate(qr_start(client).json())
-        l.debug('qr code: id=%s claim_token=%s', itd_qr.id, itd_qr.claim_token)
-        qr = QRCode(border=0)
-        qr.add_data(itd_qr.payload)
-        iprint(l, 'scan QR code with mobile app:')
-        qr.print_ascii(invert=False)
-        if status:
-            status.update('Waiting for scan')
-
-    if RICH_AVAILABLE:
-        status = Status('Waiting for scan')
-        status.start()
-    else:
-        status = None
-    stream = None
-
-    try:
-        for _ in range(5):
-            generate_qr()
-            assert itd_qr
-
-            stream = qr_stream(client, qr_id=itd_qr.id, claim_token=itd_qr.claim_token)
-            l.info('start stream')
-            for event in SSEClient(stream).events():
-                res = loads(event.data)
-                l.debug('qr code status: %s', res['status'])
-
-                if res['status'] == 'approved':
-                    iprint(l, 'qr code approved')
-                    claim_res = qr_claim(client, qr_id=itd_qr.id, claim_token=itd_qr.claim_token)
-                    client._profile.set_refresh(claim_res.cookies['refresh_token'])
-                    client._profile.set_access(claim_res.json()['accessToken'])
-                    stream.close()
-                    return True
-
-                elif res['status'] == 'rejected':
-                    l.error('qr code rejected')
-                    generate_qr()
-                    stream.close()
-                    break
-
-                elif res['status'] == 'scanned':
-                    iprint(l, 'qr code scanned')
-                    if status:
-                        status.update('Waiting for accept')
-
-                elif res['status'] == 'pending':
-                    iprint(l, 'qr code pending')
-
-                # elif res['status'] == 'captcha_required':
-                #     iprint(l, 'captcha required')
-                #     if status:
-                #         status.update('Solving captcha')
-                #     turnstile = get_turnstile(client)
-
-            l.info('stop stream')
-            sleep(5)
-
-        l.error('all retries to auth qr exceeded')
-        return False
-    finally:
-        if status:
-            status.stop()
-        if stream:
-            stream.close()

itd_sdk-2.9.0/itd/models/__init__.py

@@ -1,4 +0,0 @@
-"""Модели предметной области: пользователи, посты, комментарии и остальное
-
-Могут импортировать itd.core и itd.api
-"""