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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: itd-sdk
-Version: 2.8.2
+Version: 2.9.1
 Summary: ITD client for python
 Keywords: itd,itdsocial
 Author: fi-res
@@ -17,16 +17,20 @@ Requires-Dist: sseclient-py~=1.9.0
 Requires-Dist: telegramify-markdown>=0.5.4
 Requires-Dist: lxml>=6.1.1
 Requires-Dist: platformdirs>=4.10.0
-Requires-Dist: websockets>=16.1.1
+Requires-Dist: camoufox[geoip]>=0.4.11 ; extra == 'captcha'
+Requires-Dist: playwright>=1.62.0 ; extra == 'captcha'
 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-Dist: qrcode>=8.2 ; extra == 'qrcode'
 Requires-Python: >=3.10
 Project-URL: Homepage, https://itdsdk.qzz.io
 Project-URL: Documentation, https://itdsdk.qzz.io/docs
+Provides-Extra: captcha
 Provides-Extra: date
 Provides-Extra: filetype
 Provides-Extra: logs
+Provides-Extra: qrcode
 Description-Content-Type: text/markdown
 
 # itd-sdk

itd_sdk-2.9.1/itd/api/auth.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from uuid import UUID
+
+from itd.core.request import endpoint
+from itd.enums import AuthLevel
+from itd.exceptions import (
+    CaptchaFailedError,
+    EmailDomainNotAllowedError,
+    InvalidCredentialsError,
+    InvalidEmailError,
+    InvalidOldPasswordError,
+    InvalidPasswordError,
+    SamePasswordError,
+    SessionExpiredError,
+    SessionNotFoundError,
+    SessionRevokedError
+)
+
+if TYPE_CHECKING:
+    from itd.core.client import Client
+
+
+@endpoint('post', 'v1/auth/refresh', SessionExpiredError(), SessionNotFoundError(), SessionRevokedError(), level=AuthLevel.REFRESH)
+def refresh_token(client: Client): ...
+
+
+@endpoint('post', 'v1/auth/change-password', InvalidPasswordError(), SamePasswordError(), InvalidOldPasswordError())
+def change_password(client: Client, old: str, new: str):
+    return {'newPassword': new, 'oldPassword': old}
+
+
+@endpoint('post', 'v1/auth/logout', level=AuthLevel.REFRESH)
+def logout(client: Client): ...
+
+
+@endpoint('get', 'v1/auth/captcha/provider', level=AuthLevel.NO)
+def get_captcha_provider(client: Client): ...
+
+
+@endpoint('post', 'v1/auth/sign-in', InvalidCredentialsError(), CaptchaFailedError(), EmailDomainNotAllowedError(), InvalidEmailError(), level=AuthLevel.NO)
+def sign_in(client: Client, email: str, password: str, token_field: str, token: str):  # token field: turnstileToken for клодфлер token for итд
+    return {'email': email, 'password': password, token_field: token}
+
+
+@endpoint('post', 'v1/auth/qr/start', level=AuthLevel.NO)
+def qr_start(cleint: Client): ...
+
+
+@endpoint('post', 'v1/auth/qr/claim', level=AuthLevel.NO)
+def qr_claim(client: Client, qr_id: UUID, claim_token: str):
+    return {'qrId': str(qr_id), 'claimToken': claim_token}
+
+
+@endpoint('post', 'v1/auth/qr/stream', sse=True, level=AuthLevel.NO)
+def qr_stream(client: Client, qr_id: UUID, claim_token: str):
+    return {'qrId': str(qr_id), 'claimToken': claim_token}

{itd_sdk-2.8.2 → itd_sdk-2.9.1}/itd/api/files.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
-from _io import BufferedReader
+from io import BufferedReader
 from typing import TYPE_CHECKING
 from uuid import UUID
 
-from itd.exceptions import InvalidFileTypeError, ModerationFailedError, TooLargeError, UploadError
 from itd.core.request import Payload, endpoint
+from itd.exceptions import InvalidFileTypeError, ModerationFailedError, TooLargeError, UploadError
 
 if TYPE_CHECKING:
     from itd.core.client import Client

{itd_sdk-2.8.2 → itd_sdk-2.9.1}/itd/api/notifications.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 from uuid import UUID
 
-from itd.exceptions import NotFoundError
 from itd.core.request import endpoint
+from itd.exceptions import NotFoundError
 
 if TYPE_CHECKING:
     from itd.core.client import Client
@@ -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')
@@ -36,5 +37,5 @@ def update_notifications_settings(client: Client, settings: dict):
     return settings
 
 
-def stream_notifications(client: Client):
-    return client.request_sse('notifications/stream')
+@endpoint('get', 'notifications/stream', sse=True)
+def stream_notifications(client: Client): ...

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

@@ -0,0 +1,233 @@
+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.utils import shorten_token
+from itd.exceptions import (
+    AccessTokenExpiredError,
+    CaptchaFailedError,
+    EmailDomainNotAllowedError,
+    InvalidAccessTokenError,
+    InvalidCredentialsError,
+    InvalidEmailError,
+    JWTAlgorithmUnsupportedError,
+    SessionExpiredError,
+    SessionNotFoundError,
+    SessionRevokedError
+)
+
+if TYPE_CHECKING:
+    from itd.core.client import Client
+
+if RICH_AVAILABLE:
+    from rich.status import Status
+
+l = get_logger('auth')
+
+
+@contextmanager
+def _status(text: str):
+    if not RICH_AVAILABLE:
+        iprint(l, text)
+        yield None
+        return
+    with Status(text) as status:
+        yield status
+
+
+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:
+            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')
+        except InvalidCredentialsError:
+            l.error('invalid email or password')
+        except EmailDomainNotAllowedError:
+            l.error('email domain not allowed')
+        except InvalidEmailError:
+            l.error('invalid email format')
+        else:
+            iprint(l, 'accepted')
+            return True
+    return False
+
+
+def _auth_refresh(client: 'Client', refresh: str) -> bool:
+    with _status('Verifying..'):
+        try:
+            apply_auth(client, RefreshAuth(refresh))
+        except SessionExpiredError:
+            l.error('refresh token expired')
+        except SessionNotFoundError:
+            l.error('invalid refresh token')
+        except SessionRevokedError:
+            l.error('refresh token revoked')
+        else:
+            iprint(l, 'accepted')
+            return True
+    return False
+
+
+def _auth_access(client: 'Client', access: str) -> bool:
+    with _status('Verifying..'):
+        try:
+            apply_auth(client, AccessAuth(access))
+        except AccessTokenExpiredError:
+            l.error('access token expired')
+        except InvalidAccessTokenError:
+            l.error('invalid access token')
+        except JWTAlgorithmUnsupportedError:
+            l.error('jwt algorithm unsupported')
+        else:
+            iprint(l, 'accepted')
+            return True
+    return False
+
+
+@dataclass
+class CredentialsAuth:
+    email: str
+    password: str
+    turnstile: str | None = None
+
+
+@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:
+    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:
+    """Auth from ITD_* environment variables. Returns False if none set."""
+    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 _:
+            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:
+    if client._profile._file is None:
+        l.debug('create new profile')
+
+    if client._profile.creds_valid or client._profile.refresh_valid or client._profile.access_valid:
+        # if not client._profile.access_valid:
+        #     client._profile.access = None
+        # if not client._profile.refresh_valid:
+        #     client._profile.refresh = None
+        # if not client._profile.creds_valid:
+        #     client._profile.email = None
+        #     client._profile.password = None
+
+        return True
+    client._credtest = True
+
+    if not client._profile.refresh_valid and client._profile.refresh:
+        l.warning('session file refresh token is not valid')
+
+    if not client._profile.creds_valid and client._profile.email:
+        l.warning('session file credentials is not valid')
+
+    iprint(
+        l, f'session file data: access={shorten_token(client._profile.access)} refresh={shorten_token(client._profile.refresh)} email={client._profile.email}'
+    )
+    iprint(l, 'select auth option:')
+    iprint(l, '[1] Login using credentials')
+    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')
+
+    while True:
+        option = rich_input('option', 'magenta')
+
+        match option:
+            case '1':
+                if _auth_login(client, rich_input('email', 'green'), rich_input('password', 'green', password=True)):
+                    return True
+            case '2':
+                if auth_qr(client):
+                    return True
+            case '3':
+                if _auth_refresh(client, rich_input('refresh token', 'cyan', password=True)):
+                    return True
+            case '4':
+                l.info('note: authorization will work only for ~15min')
+                if _auth_access(client, rich_input('access token', 'cyan')):
+                    return True
+            case '5' | 'q' | 'quit':
+                quit()
+            case _:
+                l.error('unknown option')

itd_sdk-2.9.1/itd/core/captcha/__init__.py

@@ -0,0 +1,41 @@
+from typing import TYPE_CHECKING
+
+# from itd.api.auth import get_captcha_provider
+# from itd.core.captcha import cloudflare, itd  # required to they fill "providers" value # noqa
+# from itd.core.captcha.base import providers
+from itd.core.captcha.base import CAPTCHA_AVAILABLE
+from itd.core.captcha.cloudflare import CloudflareProvider
+from itd.core.logger import get_logger, iprint, rich_input
+
+if TYPE_CHECKING:
+    from itd.core.client import Client
+
+l = get_logger('captcha')
+
+
+def get_turnstile(client: 'Client | None' = None, status=None) -> str:  # tuple[str, str]:
+    # provider_data = {'provider': 'cloudflare', 'token': 'turnstileToken'}  # get_captcha_provider(client)
+    # if provider_data['provider'] not in providers:
+    #     raise RuntimeError(f'Unknown provider: {provider_data["provider"]}')
+
+    # provider = providers[provider_data['provider']]()
+    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')
+        if status:
+            status.stop()
+        turnstile = rich_input('turnstile', 'yellow')
+        if turnstile != 'continue':
+            return turnstile
+        if status:
+            status.start()
+
+    if not CAPTCHA_AVAILABLE:
+        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()
+    provider.close()
+
+    return turnstile  # provider_data.get('token', 'token'), turnstile

itd_sdk-2.9.1/itd/core/captcha/base.py

@@ -0,0 +1,43 @@
+from typing import Literal, cast
+
+try:
+    from camoufox.sync_api import Camoufox
+    from playwright.sync_api import Browser, ViewportSize
+except ImportError:
+    CAPTCHA_AVAILABLE = False
+else:
+    CAPTCHA_AVAILABLE = True
+
+
+class BaseProvider:
+    url: str
+    _init_script: str
+
+    def __init__(self, headless: bool | Literal['virtual'] = 'virtual'):
+        self.camoufox = Camoufox(headless=headless, geoip=True, humanize=True)
+        self.browser = None
+        self.context = None
+
+    def launch(self):
+        self.browser = cast(Browser, self.camoufox.__enter__())
+        self.context = self.browser.new_context(
+            viewport=ViewportSize(width=1920, height=1080),
+            screen=ViewportSize(width=1920, height=1080)
+            # locale='ru',
+            # user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:140.0) Gecko/20100101 Firefox/140.0'
+        )
+        self.context.add_init_script(self._init_script)
+        self.page = self.context.new_page()
+        self.page.goto(self.url, wait_until='domcontentloaded', timeout=25000)
+
+    def solve(self): ...
+
+    def close(self):
+        if self.context:
+            self.context.close()
+        if self.browser:
+            self.browser.close()
+        self.camoufox.__exit__(None, None, None)
+
+
+# providers: dict[str, type[BaseProvider]] = {}

itd_sdk-2.9.1/itd/core/captcha/cloudflare.py

@@ -0,0 +1,96 @@
+# credits: @itdStatus
+
+from time import sleep, time
+
+from itd.core.captcha.base import BaseProvider  # , providers
+
+
+class CloudflareProvider(BaseProvider):
+    url = 'https://xn--d1ah4a.com/turnstile.html?theme=dark'
+    _init_script = """
+    () => {
+        if (window.__t_patched) return;
+        window.__t_patched = true;
+        window.__t__ = null;
+
+        window.onSuccess = tk => { window.__t__ = tk; };
+
+        window.addEventListener('message', ev => {
+            try {
+                const data = (typeof ev.data === 'string') ? JSON.parse(ev.data) : ev.data;
+                if (!data) return;
+                const tk = data.token || data['cf-turnstile-response'] || data.cfToken;
+                if (tk && typeof tk === 'string' && tk.length > 20) window.__t__ = tk;
+            } catch (_) {}
+        }, true);
+
+        let attempts = 0;
+        const iv = setInterval(() => {
+            if (typeof window.turnstile !== 'undefined') {
+                clearInterval(iv);
+                const orig = window.turnstile.render.bind(window.turnstile);
+                window.turnstile.render = (container, opts) => {
+                    const cb = opts.callback;
+                    opts.callback = tk => {
+                        window.__t__ = tk;
+                        if (typeof cb === 'function') cb(tk);
+                    };
+                    return orig(container, opts);
+                };
+            } else if (++attempts > 150) {
+                clearInterval(iv);
+            }
+        }, 100);
+
+        const origFetch = window.fetch;
+        window.fetch = async (...args) => {
+            const res = await origFetch(...args);
+            try {
+                const clone = res.clone();
+                const text  = await clone.text();
+                const json  = JSON.parse(text);
+                const tk    = json.token || json['cf-turnstile-response'];
+                if (tk && tk.length > 20) window.__t__ = tk;
+            } catch (_) {}
+            return res;
+        };
+
+        const observer = new MutationObserver(() => {
+            const inp = document.querySelector(
+                'input[name="cf-turnstile-response"], input[name="cf_turnstile_response"]'
+            );
+            if (inp && inp.value && inp.value.length > 20) window.__t__ = inp.value;
+        });
+        observer.observe(document.documentElement, { subtree: true, attributes: true, childList: true });
+    }
+    """
+
+    def solve(self):
+        sleep(5)
+        self.page.mouse.move(20, 30)
+        sleep(0.15)
+        self.page.mouse.click(20, 30)
+
+        start = time()
+        while start + 30 > time():
+            token = self.page.evaluate("""
+                (() => {
+                    if (window.__t__ && window.__t__.length > 20) return window.__t__;
+                    const inp = document.querySelector(
+                        'input[name="cf-turnstile-response"], input[name="cf_turnstile_response"], textarea[name="cf-turnstile-response"]'
+                    );
+                    if (inp && inp.value && inp.value.length > 20) return inp.value;
+                    return null;
+                })()
+            """)
+            if token:
+                break
+            sleep(0.3)
+
+        if not token:
+            raise RuntimeError('Cloudflare token timeout')
+
+        return token
+
+
+# providers['cloudflare'] = CloudflareProvider

itd_sdk-2.9.1/itd/core/captcha/itd.py

@@ -0,0 +1,66 @@
+from time import sleep
+
+from itd.core.captcha.base import BaseProvider  # , providers
+
+SITEKEY = 'sk_44d64cf7bf8bc8377f5b'
+
+
+class ItdProvider(BaseProvider):
+    url = f'https://captcha.xn--d1ah4a.com/widget.html?sitekey={SITEKEY}'
+    _init_script = """
+    const plugins = [new Object(), new Object(), new Object(), new Object(), new Object()];
+    plugins.item = (i) => plugins[i];
+    Object.defineProperty(navigator, 'plugins', { get: () => plugins});
+    window.Plugin = Object;
+
+    Object.defineProperty(navigator, 'webdriver', { get: () => false });
+    Object.defineProperty(navigator, 'languages', { get: () => ['ru-RU', 'ru', 'en-US', 'en']});
+    Object.defineProperty(navigator, 'platform', { get: () => 'Windows 11'});
+    Object.defineProperty(navigator, 'mimeTypes', { get: () => [0, 0]});
+
+    matchMedia = (a) => ({matches: a.includes('dark')}) ;
+
+    const _origOwnProp = Object.getOwnPropertyDescriptor;
+    Object.defineProperty(Object, 'getOwnPropertyDescriptor', { value: (o, p) => o == navigator && p == "webdriver"? undefined : _origOwnProp(o, p)});
+
+    const _origAttach = Element.prototype.attachShadow;
+    Object.defineProperty(Element.prototype, 'attachShadow', {
+      configurable: true,
+      writable: true,
+      value: function (init) {
+        const root = _origAttach.call(this, { ...init, mode: 'open' });
+        (window.__roots ??= []).push({ host: this, root });
+        return root;
+      },
+    });
+
+    window.turnstile = null;
+    const _origFetch = window.fetch;
+    window.fetch = async function (u, p) {
+        console.log(`invoke headers ${u}`);
+        p.headers = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Accept-Language': 'ru-RU,ru;q=0.8,en-US;q=0.5,en;q=0.3',
+            'Cache-Control': 'no-cache',
+            'Pragma': 'no-cache'
+        };
+        const res = await _origFetch(u, p);
+        if (u.includes('/api/v1/c')) {
+            const json = await res.json();
+            window.turnstile = json.t;
+            console.log(`fetched turnstile ${window.turnstile}`);
+            return new Response(JSON.stringify(json), {status: res.status, statusText: res.statusText, headers: res.headers});
+        }
+        return res;
+    }
+    """
+
+    def solve(self):
+        sleep(0.5)
+        self.page.locator('#c').evaluate('(c) => c.shadowRoot.querySelector(".cb").click()')
+        sleep(3)
+        return self.page.evaluate('() => window.turnstile')
+
+
+# providers['itd'] = ItdProvider

itd_sdk-2.9.1/itd/core/cli.py

@@ -0,0 +1,11 @@
+from sys import argv
+
+from itd.core.captcha import get_turnstile
+
+
+def main():
+    if argv[-1] == 'captcha':
+        print(get_turnstile())
+
+    else:
+        print('unknown command')