itd-sdk 2.6.0__tar.gz → 2.7.0__tar.gz

{itd_sdk-2.6.0 → itd_sdk-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: itd-sdk
-Version: 2.6.0
+Version: 2.7.0
 Summary: ITD client for python
 Keywords: itd,itdsocial
 Author: fi-res
@@ -16,6 +16,7 @@ Requires-Dist: pydantic>=2.12.5,<2.14.0
 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: dateparser>=1.2.2 ; extra == 'date'
 Requires-Dist: filetype>=1.2.0 ; extra == 'filetype'
 Requires-Dist: rich>=15.0.0 ; extra == 'logs'
@@ -29,7 +30,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.6.0 → itd_sdk-2.7.0}/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.7.0/itd/_credfile.py

@@ -0,0 +1,43 @@
+from datetime import datetime
+from json import dumps, loads
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+# class CredfileSession(BaseModel):
+#     id: int
+#     last_active: datetime
+#     main: bool
+
+#     @classmethod
+#     def current(cls, main: bool = False):
+#         return cls(id=getpid(), last_active=datetime.now(), main=main)
+
+
+class Credfile(BaseModel):
+    access: str | None = None
+    refresh: str | None = None
+    valid: bool = True
+    updated_at: datetime = Field(default_factory=datetime.now)
+    # sessions: list[CredfileSession] = Field(default_factory=lambda: [])
+    _file: Path
+
+    def flush(self):
+        self.updated_at = datetime.now()
+        self._file.write_text(dumps(self.model_dump(mode='json')))
+
+    def update(self):
+        new = self.model_validate(loads(self._file.read_text()))
+        if self.updated_at <= new.updated_at:
+            for field in Credfile.model_fields:
+                setattr(self, field, getattr(new, field))
+            return True
+        return False
+
+    # @field_validator('sessions', mode='after')
+    # def validate_sessions(self, sessions: list[CredfileSession]):
+    #     for session in sessions.copy():
+    #         if session.last_active < datetime.now() - timedelta(minutes=30):
+    #             sessions.remove(session)
+
+    #     sessions.append(CredfileSession.current(main=not any(session.main for session in sessions)))

{itd_sdk-2.6.0 → itd_sdk-2.7.0}/itd/api/comments.py

@@ -50,7 +50,7 @@ def unlike_comment(client: Client, id: UUID):
     return client.request('delete', f'comments/{id}/like')
 
 
-@api_wrapper(NotFoundError('Comment'), AlreadyDeletedError('Comment'))
+@api_wrapper(NotFoundError('Comment'), AlreadyDeletedError('Comment'), ForbiddenError('delete comment'))
 def delete_comment(client: Client, id: UUID):
     return client.request('delete', f'comments/{id}')
 

{itd_sdk-2.6.0 → itd_sdk-2.7.0}/itd/api/notifications.py

@@ -44,10 +44,7 @@ def update_notifications_settings(client: Client, settings: NotificationsSetting
 
     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(

{itd_sdk-2.6.0 → itd_sdk-2.7.0}/itd/base.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
-import inspect
 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
 
@@ -52,6 +53,7 @@ class ITDBaseModel:
         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
@@ -73,13 +75,14 @@ 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():
             object.__setattr__(self, name, value)
@@ -87,11 +90,12 @@ class ITDBaseModel:
         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
 
@@ -105,22 +109,44 @@ class ITDBaseModel:
                 value = None
                 exc = e
 
-            if name == 'is_following':
-                l.debug(_getattr(self, '_loaded_attrs'))
             if (
                 _getattr(self, '_refreshable')
                 and not name.startswith('_')
                 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
@@ -136,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 {}
@@ -157,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
@@ -265,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:
@@ -279,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()
@@ -297,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 = []
@@ -385,9 +423,10 @@ def api_wrapper(*exceptions: ITDException):
                         if isinstance(exception, RateLimitError) and isinstance(json.get('error'), dict):
                             exception.retry_after = json.get('error', {}).get('retryAfter', 0)
 
-                        if isinstance(exception, (UnauthorizedError, AccessTokenExpiredError)) and client.refresh_token:
-                            client.refresh_auth()
-                            return wrapper(client, *args, **kwargs)
+                        # now checks token before request
+                        # if isinstance(exception, (UnauthorizedError, AccessTokenExpiredError)) and client.refresh_token:
+                        #     client.refresh_auth()
+                        #     return wrapper(client, *args, **kwargs)
 
                         if isinstance(exception, AccountDeletedError):
                             exception.can_restore = json.get('error', {}).get('canRestore', True)

{itd_sdk-2.6.0 → itd_sdk-2.7.0}/itd/client.py

@@ -1,7 +1,10 @@
 from _io import BufferedReader
 from atexit import register
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import datetime, timedelta
+from functools import cached_property
+from json import dumps, loads
+from pathlib import Path
 from threading import Thread
 from time import sleep
 from typing import Callable, Literal, overload
@@ -12,19 +15,19 @@ from requests import Session
 from requests.adapters import HTTPAdapter
 from requests.utils import default_user_agent
 
-from itd import BurstRateLimiter, HalfRateLimiter, IPRateLimiter, LimiterConfig, set_limiter_config
+from itd._credfile import Credfile
 from itd._default import _default_client, set_default_client
 from itd.api.auth import change_password, logout, refresh_token
 from itd.api.posts import get_stats
 from itd.api.search import search
-from itd.enums import BATCH, All, AuthLevel, Batch, DebugResponseMode, ParseMode, RateLimitMode, Role, UserAgent
-from itd.exceptions import InsufficientAuthLevelError, NotFoundError, RateLimitError
+from itd.enums import BATCH, All, AuthLevel, Batch, DebugResponseMode, ParseMode, Role, UserAgent, ViewReason
+from itd.exceptions import InsufficientAuthLevelError, NotFoundError, RateLimitError, SessionExpiredError, SessionNotFoundError, SessionRevokedError
 from itd.hashtag import Hashtag, Hashtags
 from itd.logger import get_logger
 from itd.post import DwellTracker, Post
 from itd.request import decode_jwt_payload, fetch, fetch_stream
 from itd.user import Me, User, Users, get_follow_status
-from itd.utils import get_sdk_user_agent
+from itd.utils import get_credfile, get_sdk_user_agent, shorten_token
 
 l = get_logger('client')  # noqa: E741
 
@@ -75,13 +78,6 @@ class Config:
     # ^ это если что просто мысли, не обращайте внимания
     client_type: Literal['client', 'bot', 'onetime'] = 'onetime'
 
-    rate_limit: RateLimitMode | None = None  # deprecated
-    rate_limit_default: int | None = None  # deprecated
-    rate_limit_actions: dict[str, float | int] | None = None  # deprecated
-    anti_rate_limit: bool | None = None  # deprecated
-    burst_requests: bool | None = None  # deprecated
-    anti_ip_ban: bool | None = None  # deprecated
-    limit_coefficient: float | None = None  # deprecated
     auto_acquire: bool | None = None
 
     # enable_logging: bool | None = None
@@ -91,8 +87,8 @@ class Config:
 
     userposts_add_pinned_post: bool = True
 
-    # load_on_init: bool = True
-    # load_on_getattr: bool = False
+    # load_on_init: bool = False
+    load_on_getattr: bool = True
     auto_load: bool | None = None
     load_on_getitem: int | All | Batch | None = 1
     load_on_iter: int | All | Batch | None = BATCH
@@ -105,7 +101,6 @@ class Config:
     timeout_file_download: float | None = None
 
     url: str = 'https://xn--d1ah4a.com/api'
-    url_api: str | None = None  # deprecated
     user_agent: UserAgent | str = UserAgent.BROWSER
     solve_challenge: bool = True
 
@@ -116,7 +111,7 @@ class Config:
     retry_enabled: bool | None = None
     retry_delay: float = 10  # delay before next attempt (after rate limit error) if retry_after is not provided in response
     retry_max_retries: int | None = 10  # none for no limit
-    retry_exceptions: tuple[type[Exception]] = field(default_factory=lambda: (RateLimitError,))
+    retry_exceptions: tuple[type[Exception], ...] = field(default_factory=lambda: (RateLimitError,))
     retry_max_retry_after: int = 500
 
     bypass_auth_level: bool = False
@@ -126,6 +121,11 @@ class Config:
     dwell_send_interval: float = 2
     dwell_save_on_quit: bool = True
     dwell_wait_durations: bool = False
+    dwell_max_duration: int = 30000
+    dwell_min_duration: int = 250
+    dwell_check_active: bool | None = None
+    dwell_check_active_interval: float = 5
+    dwell_inactive_timeout: int = 30
     post_view_increment: bool = False
     post_auto_view: bool = True  # view when called post.set_invisible()
 
@@ -140,10 +140,6 @@ class Config:
     refresh_token_cookie_name: str = 'refresh_token'
 
     def __post_init__(self):
-        if self.url_api is not None:
-            l.warning('config.url_api is deprecated and will be removed in 2.7.0. Please use config.url.')
-            self.url = self.url_api
-
         match self.user_agent:
             case UserAgent.DEFAULT:
                 self._user_agent = default_user_agent()
@@ -156,39 +152,6 @@ class Config:
             case _:
                 self._user_agent = self.user_agent
 
-        if self.dwell_wait_durations:
-            l.warning('config.dwell_wait_durations is deprecated and will be removed in 2.6.0.')
-
-        if self.rate_limit is not None:
-            l.warning('config.rate_limit is deprecated and will be removed in 2.7.0.')
-        if self.rate_limit_default is not None:
-            l.warning('config.rate_limit_default is deprecated and will be removed in 2.7.0.')
-        if self.rate_limit_actions is not None:
-            l.warning('config.rate_limit_actions is deprecated and will be removed in 2.7.0.')
-        if self.anti_ip_ban is not None:
-            l.warning(
-                f'config.anti_ip_ban is deprecated and will be removed in 2.7.0. '
-                f'Please use set_limiter_config(LimiterConfig(ip_limiter={"IPRateLimiter" if self.anti_ip_ban else None})).'
-            )
-            set_limiter_config(LimiterConfig(ip_limiter=IPRateLimiter() if self.anti_ip_ban else None))
-        if self.anti_rate_limit is not None:
-            l.warning(
-                f'config.anti_rate_limit is depreacred and will be removed in 2.7.0. '
-                f'Please use set_limiter_config(limiter={"HalfRateLimiter" if self.anti_rate_limit else None}).'
-            )
-            set_limiter_config(LimiterConfig(limiter=HalfRateLimiter if self.anti_rate_limit else None))
-        if self.burst_requests is not None:
-            l.warning(
-                f'config.anti_rate_limit is depreacred and will be removed in 2.7.0. '
-                f'Please use set_limiter_config(limiter={"BurstRateLimiter" if self.burst_requests else None}).'
-            )
-            set_limiter_config(LimiterConfig(limiter=BurstRateLimiter if self.burst_requests else None))
-        if self.limit_coefficient is not None:
-            l.warning(
-                'config.limit_coefficient is deprecated and will be removed in 2.7.0. '
-                'Please define your own rate limiter that will override sync function of RateLimiter class and apply coefficient to remaining.'
-            )
-
         if self.timeout is None:
             match self.client_type:
                 case 'onetime':
@@ -210,8 +173,17 @@ class Config:
         else:
             self._post_update_stats = self.post_update_stats
 
+        if self.dwell_check_active is None:
+            self._dwell_check_active = self.client_type == 'client'
+        else:
+            self._dwell_check_active = self.dwell_check_active
+
         if self.load_comments_from_post is not None:
-            l.warning('load_comments_from_post is deprecated and will be removed in 2.7.0.')
+            l.warning('config.load_comments_from_post is deprecated and will be removed in 2.7.0.')
+
+        if self.auto_load is not None:
+            l.warning('config.auto_load is deprecated and will be removed in 2.8.0. Please use load_on_getattr.')
+            self.load_on_getattr = self.auto_load
 
 
 class AccessToken(BaseModel):
@@ -239,8 +211,10 @@ class Client:
         self.access_token: str | None = None
         self.access_token_data: AccessToken | None = None
         self.refresh_token: str | None = None
-        self._user: Me | None = None
         self.visible_posts: list[Post] = []
+        self._visible_posts_buffer: list[Post] = []
+        self.last_active = datetime.now()
+        self._credfile: Credfile | None = None
 
         self.session = Session()
         adapter = HTTPAdapter(pool_connections=1, pool_maxsize=10, pool_block=False)  # idk what is this, (claude added) just for better stability
@@ -248,7 +222,7 @@ class Client:
 
         if access:
             self.auth_level = AuthLevel.ACCESS
-            self.access_token = access.replace('Bearer ', '')
+            self.token = access.replace('Bearer ', '')
 
         if refresh:
             self.session.cookies.set(config.refresh_token_cookie_name, refresh, path='/')
@@ -260,14 +234,117 @@ class Client:
         if _default_client is None or config.is_default:
             set_default_client(self)
 
-        if self.auth_level > AuthLevel.NO and self.config.dwell_enabled:
-            self.dwell_tracker = DwellTracker(self)
-            self.dwell_tracker._start_timer()
-        else:
-            self.dwell_tracker = None
+        self.dwell_tracker = DwellTracker(self)
+        self.dwell_tracker._start_timer()
 
-        if self.config.post_update_stats:
+        if self.config._post_update_stats:
             self._start_update_timer()
+        if self.config._dwell_check_active:
+            self._start_check_active_timer()
+
+    @classmethod
+    def from_file(cls, name: str, config: Config = Config()):
+        credfile = get_credfile(name)
+        l.debug('get credentials file refresh=%s access=%s', shorten_token(credfile.refresh), shorten_token(credfile.access))
+        if not credfile.valid:
+            l.warning('last refresh token was expired or not found. Please enter a new one:')
+            update = True
+        else:
+            update = credfile.refresh is None
+
+        if update:
+            try:
+                from rich.prompt import Prompt
+            except ImportError:
+                credfile.refresh = input('refresh token: ')
+            else:
+                credfile.refresh = Prompt.ask('[cyan]refresh token[/]')
+
+        instance = cls(credfile.refresh, credfile.access, config=config)
+        if instance.access_token_data and instance.access_token_data.expired_at < datetime.now():
+            instance.access_token = instance.access_token_data = None
+        instance._credfile = credfile
+        if update:
+            instance._update_file()
+
+    def _update_file(self, valid: bool = True):
+        if self._credfile is None:
+            return
+
+        l.debug('update credentials file refresh=%s access=%s', shorten_token(self.refresh_token), shorten_token(self.access_token))
+        if not valid:
+            l.warning('mark %s as not valid', shorten_token(self.refresh_token))
+
+        self._credfile.access = self.access_token
+        self._credfile.refresh = self.refresh_token
+        self._credfile.valid = valid
+        self._credfile.flush()
+
+    def refresh_auth(self, force: bool = False) -> str:
+        """Обновить access token
+
+        Returns:
+            str: Токен
+        """
+
+        l.debug('refresh access_token')
+        if not force and self._credfile and self._credfile.update():
+            self.token = self._credfile.access
+            self.refresh_token = self._credfile.refresh
+
+            if self.access_token:
+                assert self.access_token_data
+                if self.access_token_data.expired_at > datetime.now():
+                    l.debug('update access_token from credfile')
+                    return self.access_token
+                else:
+                    l.info('credfile access_token expired')
+            else:
+                l.info('crefile access_token is none')
+
+        try:
+            res = refresh_token(self)
+        except (SessionExpiredError, SessionNotFoundError, SessionRevokedError):
+            self._update_file(valid=False)
+            raise
+
+        self.token = res.json().get('accessToken') or res.json()['token']
+        if 'refresh_token' in res.cookies:
+            self.refresh_token = res.cookies['refresh_token']
+        self._update_file()
+
+        return self.token
+
+    def _start_check_active_timer(self):
+        l.debug('start check active timer')
+        if not self.config.dwell_check_active_interval:
+            return
+
+        def loop():
+            while True:
+                sleep(self.config.dwell_check_active_interval)
+                if self.last_active + timedelta(seconds=self.config.dwell_inactive_timeout) < datetime.now():
+                    self._visible_posts_buffer = self.visible_posts.copy()
+                    for post in self._visible_posts_buffer:
+                        post.set_invisible(reason=ViewReason.INACTIVE)
+                elif self._visible_posts_buffer:
+                    for post in self._visible_posts_buffer:
+                        post.set_visible()
+                    self._visible_posts_buffer.clear()
+
+        self._check_active_thread = Thread(target=loop)
+        self._check_active_thread.daemon = True
+        self._check_active_thread.start()
+
+        def on_exit():
+            l.debug('stop check active timer')
+            if self._check_active_thread:
+                self._check_active_thread.join(timeout=0)
+
+        register(on_exit)
+
+    def set_active(self):  # call when user is active (scroll, move etc)
+        self.last_active = datetime.now()
 
     def _start_update_timer(self):
         l.debug('start update timer')
@@ -279,14 +356,14 @@ class Client:
                 sleep(self.config.post_update_stats_interval)
                 self.update_post_stats()
 
-        self._thread = Thread(target=loop)
-        self._thread.daemon = True
-        self._thread.start()
+        self._update_thread = Thread(target=loop)
+        self._update_thread.daemon = True
+        self._update_thread.start()
 
         def on_exit():
             l.debug('stop update timer')
-            if self._thread:
-                self._thread.join(timeout=0)
+            if self._update_thread:
+                self._update_thread.join(timeout=0)
 
         register(on_exit)
 
@@ -304,7 +381,11 @@ class Client:
         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':
+        if (
+            level >= AuthLevel.ACCESS
+            and (self.access_token is None or (self.access_token_data and self.access_token_data.expired_at <= datetime.now()))
+            and url != 'v1/auth/refresh'
+        ):
             self.refresh_auth()
 
         return fetch(self, method, url, params, files)
@@ -334,39 +415,28 @@ class Client:
         assert self.access_token, 'Access token not refreshed yet'
         return self.access_token
 
+    @token.setter
+    def token(self, token: str | None):
+        self.access_token = token
+        if token is None:
+            self.access_token_data = None
+        else:
+            self.access_token_data = AccessToken.model_validate(decode_jwt_payload(token))
+
     @property
     def user_id(self) -> UUID:
         assert self.access_token_data
         return self.access_token_data.subject_id
 
-    @property
+    @cached_property
     def user(self) -> Me:
-        if not self._user:
-            self._user = Me(self)
-        return self._user
+        return Me(self)
 
     def _process_exc_callbacks(self, exception: Exception):
         # l.debug([v for k, v in self.config.on_exceptions.items() if k in exception.__class__.mro()])
         for callback in [v for k, v in self.config.on_exceptions.items() if k in exception.__class__.mro()]:
             callback(exception)
 
-    def refresh_auth(self) -> str:
-        """Обновить access token
-
-        Returns:
-            str: Токен
-        """
-        l.debug('refresh token')
-
-        res = refresh_token(self)
-        res.raise_for_status()
-
-        self.access_token = res.json().get('accessToken') or res.json()['token']
-        self.access_token_data = AccessToken.model_validate(decode_jwt_payload(self.access_token))
-
-        assert self.access_token
-        return self.access_token
-
     def logout(self):
         """Выход из аккаунта"""
         res = logout(self)
@@ -479,5 +549,5 @@ class Client:
         return get_follow_status(users)
 
 
-def init_client(refresh: str | None = None, access: str | None = None, config: Config = Config()):
-    return Client(refresh, access, config)
+def init_client(name: str | None = None, config: Config = Config()):
+    return Client.from_file(name or 'default', config=config)