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

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

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

{itd_sdk-2.9.1 → 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.1 → itd_sdk-2.9.2}/itd/core/auth.py

@@ -6,7 +6,7 @@ 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,
@@ -114,7 +114,7 @@ class AccessAuth:
 AuthMethod = CredentialsAuth | RefreshAuth | AccessAuth
 
 
-def apply_auth(client: 'Client', auth: AuthMethod) -> None:
+def apply_auth(client: 'Client', auth: AuthMethod | None) -> None:
     match auth:
         case CredentialsAuth():
             client._profile.email = auth.email
@@ -158,7 +158,6 @@ def apply_auth(client: 'Client', auth: AuthMethod) -> None:
 
 
 def env_auth(client: 'Client') -> bool:
-    """Auth from ITD_* environment variables. Returns False if none set."""
     method = getenv('ITD_AUTH_METHOD')
     if not method:
         return False
@@ -170,6 +169,8 @@ def env_auth(client: 'Client') -> bool:
             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}')
 
@@ -208,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')
@@ -218,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)):
@@ -227,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.1 → itd_sdk-2.9.2}/itd/core/client.py

@@ -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
@@ -37,27 +36,27 @@ class Client:
         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)
 
         self._credtest = True
         if auth is not None:
             apply_auth(self, auth)
-        elif not env_auth(self):
-            interactive_auth(self)
-        self._credtest = False
-
-        self._set_from_profile()
+        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
 
         self.dwell_tracker = DwellTracker(self)
         self.dwell_tracker.start()
@@ -137,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:
@@ -150,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:
@@ -214,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.1 → 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.1 → 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.1 → itd_sdk-2.9.2}/itd/core/qr.py

@@ -11,6 +11,7 @@ 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
@@ -35,10 +36,14 @@ class ITDQRCode(BaseModel):
 
 
 class QRLogin:
-    def __init__(self, client: 'Client'):
-        self.client = client
+    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:
@@ -53,21 +58,41 @@ class QRLogin:
         l.debug('start stream')
         try:
             for event in SSEClient(self.stream).events():
-                status = loads(event.data)['status']
-                l.debug('qr code status: %s', status)
-                yield status
-                if status in ('approved', 'rejected'):
-                    return
+                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.client._profile.set_refresh(res.cookies['refresh_token'], set_expire=True)
-        self.client._profile.set_access(res.json()['accessToken'])
+        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:
@@ -81,7 +106,7 @@ class QRLogin:
         self.close()
 
 
-def auth_qr(client: 'Client'):
+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
@@ -92,7 +117,7 @@ def auth_qr(client: 'Client'):
     else:
         status = None
 
-    with QRLogin(client) as qr:
+    with QRLogin() as qr:
         try:
             for _ in range(5):
                 qr.refresh()
@@ -109,7 +134,10 @@ def auth_qr(client: 'Client'):
                 for event in qr.events():
                     if event == 'approved':
                         iprint(l, 'qr code approved')
-                        qr.claim()
+                        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':

{itd_sdk-2.9.1 → 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.1 → 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.1 → 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.1 → 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.1 → itd_sdk-2.9.2}/pyproject.toml

@@ -14,7 +14,7 @@ version_provider = "uv"
 
 [project]
 name = "itd-sdk"
-version = "2.9.1"
+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]