saarubetek-api 0.0.2b0__py3-none-any.whl

SAARubetekAPI/__init__.py

@@ -0,0 +1,3 @@
+from .wrapper import SAARubetekAPI
+
+__all__ = ["SAARubetekAPI"]

SAARubetekAPI/exceptions.py

@@ -0,0 +1,34 @@
+class RubetekAPIError(Exception):
+    """"""
+
+
+class AuthorizationRequiredRubetekAPIError(RubetekAPIError):
+    def __init__(self, message):
+        super().__init__("\n--------------------------------------------------------------------------\n"
+                         f"{message}"
+                         "rubetek_api = SAARubetekAPI()\n"
+                         "phone = input('Введите номер телефона (c +7): ')"
+                         "await rubetek_api.authentication(phone=phone)"
+                         "code = input('Введите последние 4 цифры номера звонившего телефона: ')"
+                         "await rubetek_api.authorization(phone=phone, code=code)"
+                         "\n--------------------------------------------------------------------------\n")
+
+
+class ClientConnectorRubetekAPIError(RubetekAPIError):
+    """"""
+
+
+class UnauthorizedRubetekAPIError(RubetekAPIError):
+    """"""
+
+
+class DDosRubetekAPIError(RubetekAPIError):
+    """"""
+
+
+class TimeoutRubetekAPIError(RubetekAPIError):
+    """"""
+
+
+class UnknownRubetekAPIError(RubetekAPIError):
+    """"""

SAARubetekAPI/logger.py

@@ -0,0 +1,44 @@
+import logging
+from typing import Any
+
+
+class SafeLogger(logging.Logger):
+    SENSITIVE_KEYS = {
+        'access_token', 'refresh_token', 'code', 'phone', 'email', 'authorization'
+    }
+
+    def __init__(self, name: str):
+        super().__init__(name)
+        if not self.handlers:
+            handler = logging.StreamHandler()
+            formatter = logging.Formatter(fmt='%(asctime)s %(levelname)s: %(name)s %(message)s', style='%')
+            handler.setFormatter(formatter)
+            self.addHandler(handler)
+            self.propagate = False
+
+    def mask_sensitive(self, obj: Any) -> Any:
+        if isinstance(obj, dict):
+            return {
+                k: (f"{str(v)[:3]}***" if k.lower() in self.SENSITIVE_KEYS and v is not None else self.mask_sensitive(v))
+                for k, v in obj.items()
+            }
+        if isinstance(obj, list):
+            return [self.mask_sensitive(v) for v in obj]
+        return obj
+
+    def safe(self, level: int, msg: str, *args: Any, **kwargs: Any):
+        safe_args = tuple(self.mask_sensitive(arg) for arg in args)
+        safe_kwargs = {k: self.mask_sensitive(v) for k, v in kwargs.items()}
+        super().log(level, msg, *safe_args, **safe_kwargs)
+
+    def info(self, msg: str, *args: Any, **kwargs: Any):
+        self.safe(logging.INFO, msg, *args, **kwargs)
+
+    def debug(self, msg: str, *args: Any, **kwargs: Any):
+        self.safe(logging.DEBUG, msg, *args, **kwargs)
+
+    def warning(self, msg: str, *args: Any, **kwargs: Any):
+        self.safe(logging.WARNING, msg, *args, **kwargs)
+
+    def error(self, msg: str, *args: Any, **kwargs: Any):
+        self.safe(logging.ERROR, msg, *args, **kwargs)

SAARubetekAPI/models.py

@@ -0,0 +1,120 @@
+from datetime import datetime
+
+from pydantic import BaseModel, model_validator
+from typing import Any, Optional
+
+class User(BaseModel):
+    id: str
+    _id: int
+    phone: str
+    last_name: str
+    first_name: str
+    middle_name: str
+
+class House(BaseModel):
+    id: str
+    name: str
+    iot_locked_id: Optional[str] = None
+    address: Optional[str] = None
+
+    @model_validator(mode="before")
+    @classmethod
+    def parse_location(cls, data: Any) -> Any:
+        if isinstance(data, dict) and data.get("location"):
+            addr = data["location"].get("address", {})
+            parts = [addr.get("city"), addr.get("street"), addr.get("house")]
+            data["address"] = ", ".join(filter(None, parts))
+        return data
+
+class Intercom(BaseModel):
+    id: int
+    intercom_id: int
+    ble_allowed: bool
+    is_ble: bool
+    live_snapshot_url: Optional[str] = None
+    name: str
+    status: str
+    webrtc_supported: bool
+    sip_account_ex_user: Optional[int] = None
+    sip_account_proxy: Optional[str] = None
+    real_name: Optional[str] = None
+
+    @model_validator(mode="before")
+    @classmethod
+    def parse_visible_name(cls, data: Any) -> Any:
+        if isinstance(data, dict) and data.get("user_settings"):
+            name = data["user_settings"].get("custom_name", None)
+            if name is not None:
+                data["real_name"] = data["name"]
+                data["name"] = name
+        return data
+
+class DeviceState(BaseModel):
+    status: str
+    current_value: str
+    units: str
+    battery: Optional[float] = None
+    error_code: Optional[str] = None
+
+class Device(BaseModel):
+    id: str
+    natural_id: str
+    type: str
+    updated_at: Optional[datetime] = None
+    name: Optional[str] = None
+    room: Optional[str] = None
+    last_activity: Optional[datetime] = None
+    state: DeviceState
+
+    @model_validator(mode="before")
+    @classmethod
+    def parse_last_activity(cls, data: Any) -> Any:
+        if isinstance(data, dict) and data.get("state"):
+            last_activity = data["state"].get("last_activity", None)
+            if last_activity is not None:
+                data["last_activity"] = last_activity
+        return data
+
+    @model_validator(mode="before")
+    @classmethod
+    def parse_parameters(cls, data: Any) -> Any:
+        if isinstance(data, dict) and data.get("parameters"):
+            name = data["parameters"].get("name", None)
+            room = data["parameters"].get("room", None)
+            if name is not None:
+                data["name"] = name
+            if room is not None:
+                data["room"] = room
+        return data
+
+class Camera(BaseModel):
+    id: str
+    natural_id: int
+    live_snapshot_url: Optional[str] = None
+    rtsp_url: Optional[str] = None
+    status: Optional[str] = None
+    type: str
+    name: Optional[str] = None
+
+    @model_validator(mode="before")
+    @classmethod
+    def parse_state(cls, data: Any) -> Any:
+        if isinstance(data, dict) and data.get("state"):
+            live_snapshot_url = data["state"].get("live_snapshot_url", None)
+            rtsp = data["state"].get("rtsp_url", None)
+            status = data["state"].get("status", "offline")
+            if live_snapshot_url is not None:
+                data["live_snapshot_url"] = live_snapshot_url
+            if rtsp is not None:
+                data["rtsp_url"] = rtsp
+            data["status"] = status
+        return data
+
+    @model_validator(mode="before")
+    @classmethod
+    def parse_name(cls, data: Any) -> Any:
+        if isinstance(data, dict) and data.get("parameters"):
+            name = data["parameters"].get("name", None)
+            if name is not None:
+                data["name"] = name
+        return data

SAARubetekAPI/wrapper.py

@@ -0,0 +1,378 @@
+from urllib.parse import urljoin
+import asyncio
+import logging
+import ssl
+import secrets
+import string
+
+from types import SimpleNamespace
+
+from .logger import SafeLogger
+from json.decoder import JSONDecodeError
+from pathlib import Path
+
+from uuid import uuid4
+from typing import (Any,
+                    Dict,
+                    Optional,
+                    Union)
+
+import certifi
+from aiohttp import (ClientSession,
+                     ClientTimeout,
+                     TCPConnector)
+from aiohttp.client_exceptions import (ClientConnectorError,
+                                       ContentTypeError)
+
+from .exceptions import (AuthorizationRequiredRubetekAPIError,
+                         ClientConnectorRubetekAPIError,
+                         TimeoutRubetekAPIError,
+                         UnauthorizedRubetekAPIError,
+                         DDosRubetekAPIError,
+                         UnknownRubetekAPIError)
+
+from contextlib import suppress
+
+from .models import User, House, Intercom, Device, Camera
+
+
+class SAARubetekAPI:
+    __iot_url: str = "https://iot.rubetek.com/"
+    __base_url: str = "https://ccc.rubetek.com/"
+    __client_id: str = "ckvfvkClm2IdPrkSlvWSe3KiEWJOAbyKOQR5giCYYAo" # Harcode
+    __cl_sec: str = "_TiXiy8xkVmVEpTBoYndqvyYbldXFs00wBtgLNmSOCE" # Hardcode
+    __logger = SafeLogger('RubetekAPI')
+    refresh_token: Optional[str] = None
+    iot_access_token: Optional[str] = None
+    access_token: Optional[str] = None
+    house_id: Optional[str] = None
+    personal_id: Optional[str] = None
+    device_id: Optional[str] = None
+
+    __initial_cookies: str = '_iot_rubetek_com_session=IRsv98v2DswIJJ1i2VKdWcVzOyv8%2BVlPAldUGbFqUe3eKwLT8VK%2BfuWvHFo1JJKapEAqoQOfMTBhfuQ14xgkV7TBQy2hllQTtu2R8J2oo8sgCtPQWRO9aInCxeJB4wQ7UX%2F%2FXiZafoIAjT%2BKrHWAueo6HaH232cje1h2vT4HX0vQarHhLk75SQipMrOuIhefdOQW7fzKamFavxtyquxtrBV9uEhOdQULVbbxQt3AjqGAbAY%2BsHzjgI%2FEIfw0qI8XJcjry1aD3yFex316kDABTGU4PCDJdOm1telhF8rAjpCKe2CMISv3g8okyvx9oc3ELAlbvREG%2BxVonOH2--4WBiJmIgZZT825rb--45HBPHoCrH8aa9ly%2B6cVyA%3D%3D; locale=ru'
+
+
+    def __init__(self, refresh_token: Optional[str] = None,
+                 refresh_token_file: Optional[Path] = Path("./rr_token"),
+                 save_token_file: Optional[bool] = True,
+                 enabledCaptcha: Optional[bool] = True,
+                 insecure: Optional[bool] = False,
+                 timeout: Optional[int] = 30,
+                 retry_count: Optional[int] = 5,
+                 retry_timeout_ms: Optional[int] = 1000,
+                 logging_level: Optional[str] = "INFO",
+                 device_id: Optional[str] = None):
+
+        if logging_level.upper() == "INFO":
+            self.__logger.setLevel(logging.INFO)
+        elif logging_level.upper() == "WARNING":
+            self.__logger.setLevel(logging.WARNING)
+        elif logging_level.upper() == "ERROR":
+            self.__logger.setLevel(logging.ERROR)
+        elif logging_level.upper() == "DEBUG":
+            self.__logger.setLevel(logging.DEBUG)
+        else:
+            # Default INFO
+            self.__logger.setLevel(logging.INFO)
+
+        self.refresh_token: Optional[str] = refresh_token
+        self.refresh_token_file: Optional[Path] = refresh_token_file
+        self.save_token_file: Optional[bool] = save_token_file
+        self.enabledCaptcha: Optional[bool] = enabledCaptcha
+        self.insecure: Optional[bool] = insecure
+        self.timeout: Optional[int] = timeout
+        self.retry_count: Optional[int] = retry_count
+        self.retry_timeout_ms: Optional[int] = retry_timeout_ms
+        self.device_id: Optional[str] = device_id or self.generate_device_uid()
+
+        self.session = None
+
+        self.__logger.debug(f"Initialization done. Items=({', '.join(f'{k}={v}' for k, v in vars(self).items())})")
+
+    async def _ensure_session(self) -> ClientSession:
+        if self.session and not self.session.closed:
+            return self.session
+        if not self.insecure:
+            ssl_context = ssl.create_default_context(cafile=certifi.where())
+            self.session = ClientSession(connector=TCPConnector(ssl=ssl_context), timeout=ClientTimeout(total=self.timeout))
+        else:
+            connector = TCPConnector(ssl=False)
+            self.session = ClientSession(connector=connector, timeout=ClientTimeout(total=self.timeout))
+
+        return self.session
+
+    async def __aenter__(self):
+        await self._ensure_session()
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        await self.close()
+
+    async def send_request(self, url: str,
+                           method: str = "GET",
+                           headers: Dict[str, Any] = None,
+                           params: Dict[str, Any] = None,
+                           json_data: Dict[str, Any] = None,
+                           name: str = "UNKNOWN",
+                           request_uid: Optional[str] = None,
+                           refresh_on_unauthorized: bool = True):
+
+        headers = headers or {}
+        params = params or {}
+        json_data = json_data or {}
+
+        if request_uid is None:
+            request_uid = uuid4().hex
+
+        attempt = 0
+        last_error: Optional[Exception] = None
+
+        while attempt < self.retry_count:
+            _headers = self.default_headers(headers)
+            self.__logger.info('[%s] Request=%s method=%s url=%s params=%s json=%s headers=%s',
+                               name, request_uid, method, url, params, json_data, _headers)
+            try:
+                session = await self._ensure_session()
+                async with session.request(method, url, params=params, json=json_data, headers=_headers) as response:
+                    try:
+                        json_response = await response.json() if response.status == 200 else {}
+                    except (JSONDecodeError, ContentTypeError) as e:
+                        raw_response = await response.text()
+                        self.__logger.error('[%s] Response=%s unsuccessful request status=%s reason=%s raw=%s error=%s',
+                                            name, request_uid, response.status, response.reason, raw_response, e)
+                        raise UnknownRubetekAPIError(f'Unknown error: {response.status} {response.reason}')
+                    if response.status == 401:
+                        self.__logger.error("[%s] Response=%s Status=%s. Body=%s", name, request_uid, response.status, str(await response.text()))
+                        raise UnauthorizedRubetekAPIError(json_response)
+                    if response.status == 429:
+                        self.__logger.error("[%s] Response=%s Status=%s. Body=%s", name, request_uid, response.status, str(await response.text()))
+                        raise DDosRubetekAPIError("429 DDoS")
+                    if response.status not in (200, 201, 204):
+                        self.__logger.error('[%s] Response=%s unsuccessful request json_response=%s Status=%s Reason=%s',
+                                            name, request_uid, json_response, response.status, response.reason)
+                        raise UnknownRubetekAPIError(json_response.get('error_description') or json_response.get('error') or json_response)
+
+                    return json_response
+
+            except asyncio.exceptions.TimeoutError:
+                self.__logger.error('[%s] Response=%s TimeoutRubetekAPIError', name, request_uid)
+                raise TimeoutRubetekAPIError('Timeout error')
+            except ClientConnectorError:
+
+                self.__logger.error('[%s] Response=%s ClientConnectorRubetekAPIError', name, request_uid)
+                raise ClientConnectorRubetekAPIError('Client connector error')
+            except DDosRubetekAPIError:
+                last_error = DDosRubetekAPIError("429 DDoS")
+                await asyncio.sleep((self.retry_timeout_ms / 1000) * attempt)
+            except UnauthorizedRubetekAPIError as error:
+                if not refresh_on_unauthorized:
+                    raise
+                last_error = error
+                self.__logger.warning("[%s] The token may have expired. Get a new one")
+                await self.refresh_tokens(request_uid = request_uid)
+                await asyncio.sleep((self.retry_timeout_ms / 1000) * attempt)
+            finally:
+                attempt += 1
+
+        if last_error is not None:
+            raise last_error
+        raise UnknownRubetekAPIError("Request failed after all retry attempts")
+
+    @staticmethod
+    def generate_device_uid() -> str:
+        charset = string.ascii_letters + string.digits
+        device_id = ''.join(secrets.choice(charset) for _ in range(16))
+        return device_id
+
+    def default_headers(self, new_headers: dict | None = None) -> dict:
+        headers = {
+            "Content-Type": "application/json; charset=UTF-8",
+            "Device-Client-UID": self.device_id,
+            "Device-Client-App": "Rubetek",
+            "Accept-Language": "ru",
+            "Device-Client-OS": "Android",
+            "User-Agent": "okhttp/5.3.2"
+        }
+        if new_headers is not None:
+            headers.update(new_headers)
+        return headers
+
+    async def authentication(self, email: str = None, phone: str = None, method: str = "flash_call"):
+        length_code = 4 if method == "flash_call" and email is None else 6
+
+        if not ((email is not None) ^ (phone is not None)):
+            raise ValueError('Either "email" or "phone" must be provided.')
+
+        url = urljoin(self.__iot_url, 'api/v1/code_requests')
+        payload = {
+            'code_request': {
+                'length': length_code
+            }
+        }
+        if email is not None:
+            payload['code_request'].update({'email': email, 'method': 'email'})
+        elif method == "flash_call":
+            payload['code_request'].update({'phone': phone, 'method': 'flash_call'})
+        else:
+            payload['code_request'].update({'phone': phone, 'method': 'sms'})
+        headers = {
+            'Cookie': self.__initial_cookies
+        } if self.__initial_cookies else {}
+
+        self.__logger.info("Sending a confirmation request method=%s target=%s...", method, email if email else phone)
+        await self.send_request(url=url, method='POST', json_data=payload, headers=headers, name="AUTHENTICATION")
+
+    async def authorization(self, code: Union[int, str], email: Optional[str] = None, phone: Optional[str] = None):
+        if not ((email is not None) ^ (phone is not None)):
+            raise ValueError('Either "email" or "phone" must be provided.')
+
+        url = urljoin(self.__iot_url, 'oauth/token')
+        params = {
+            'client_id': self.__client_id,
+            'client_secret': self.__cl_sec,
+            'grant_type': 'password',
+            'code': str(code),
+        }
+        if email is not None:
+            params['email'] = email
+        else:
+            params['phone'] = phone
+
+        self.__logger.debug("Get iot token...")
+        headers = {
+            'Content-Type': 'application/json; charset=UTF-8',
+            'User-Agent': 'okhttp/4.12.0'
+        }
+        response = await self.send_request(url=url, method='POST', headers=headers, params=params, name="AUTHORIZATION.STEP_1", refresh_on_unauthorized=False)
+        token = SimpleNamespace(**response)
+        self.__logger.debug("IOT: %s", token)
+
+        self.iot_access_token = getattr(token, 'access_token', None)
+
+        url = urljoin(self.__base_url, 'v5/oauth/iot')
+        payload = {
+            'client_id': 'rubetek_android',
+            'token': f'Bearer {self.iot_access_token}'
+        }
+
+        self.__logger.debug("Get refresh token and access token...")
+        response = await self.send_request(url=url, method='POST', json_data=payload, name="AUTHORIZATION.STEP_2", refresh_on_unauthorized=False)
+        token = SimpleNamespace(**response)
+        self.access_token = getattr(token, 'access_token', None)
+        self.save_refresh_token(refresh_token=getattr(token, 'refresh_token', None))
+        return self.refresh_token, self.access_token, self.iot_access_token
+
+
+    def save_refresh_token(self, refresh_token):
+        if self.refresh_token_file and self.save_token_file:
+            with open(self.refresh_token_file, 'w', encoding='utf-8') as f:
+                f.write(refresh_token)
+            self.__logger.info('New refresh token saved to file %s', self.refresh_token_file)
+        else:
+            self.__logger.warning('We do not save the token to a file')
+        self.refresh_token = refresh_token
+
+    async def refresh_tokens(self, request_uid: str=None):
+        if not self.refresh_token and self.refresh_token_file and self.save_token_file:
+            with suppress(FileNotFoundError):
+                with open(self.refresh_token_file, encoding='utf-8') as f:
+                    self.refresh_token = f.read()
+            if not self.refresh_token:
+                self.__logger.error('Response=%s AuthorizationRequiredRubetekAPIError', request_uid)
+                raise AuthorizationRequiredRubetekAPIError("Not found refresh token. Need to authorize")
+        await self.get_access_token(request_uid=request_uid)
+        await self.get_iot_access_token(request_uid=request_uid)
+        return self.refresh_token, self.access_token, self.iot_access_token
+
+    async def get_access_token(self, request_uid: str = None) -> str:
+        url = urljoin(self.__base_url, 'v5/oauth/access_token')
+        payload = {
+            'client_id': 'rubetek_android',
+            'grant_type': 'refresh_token',
+            'refresh_token': self.refresh_token
+        }
+        response = await self.send_request(url=url, method='POST', json_data=payload, name="REFRESH_ACCESS_TOKEN", request_uid=request_uid, refresh_on_unauthorized=False)
+        token = SimpleNamespace(**response)
+        self.__logger.debug("Access token updated")
+        self.access_token = getattr(token, 'access_token', None)
+
+        return self.access_token
+
+    async def get_iot_access_token(self, request_uid: str = None) -> str:
+        url = urljoin(self.__base_url, 'v5/iot/auth_token')
+        headers = {
+            "Authorization": f"Bearer {self.access_token}",
+            "Accept": "application/json"
+        }
+        payload = {
+            'client_id': self.__client_id
+        }
+        response = await self.send_request(url=url, method='POST', json_data=payload, headers=headers, name="REFRESH_IOT_ACCESS_TOKEN", request_uid=request_uid, refresh_on_unauthorized=False)
+        token = SimpleNamespace(**response)
+        self.__logger.debug("IoT Access token updated")
+        self.iot_access_token = getattr(token, 'access_token', None)
+        return self.iot_access_token
+
+    async def get_user(self) -> User:
+        url = urljoin(self.__base_url, 'v5/user')
+        headers = {
+            "Authorization": f"Bearer {self.access_token}"
+        }
+        response = await self.send_request(url=url, headers=headers, name="GET_USER")
+        return User(**response)
+
+    async def get_homes(self):
+        url = urljoin(self.__base_url, 'v6/houses')
+        headers = {
+            "Authorization": f"Bearer {self.access_token}"
+        }
+        response = await self.send_request(url=url, headers=headers, name="GET_HOUSES")
+        return [House(**h) for h in response]
+
+
+    async def get_devices(self):
+        if self.house_id is None:
+            raise ValueError("House ID not set")
+        url = urljoin(self.__iot_url, f'api/personal/v1/homes/{self.house_id}/devices')
+        params = {'page': 1, 'per_page': 500, 'include_deleted': 'true', 'q[model_type_not_eq]': 'Cameras::Device'}
+        headers = {
+            "Authorization": f"Bearer {self.iot_access_token}"
+        }
+        response = await self.send_request(url=url, params=params, headers=headers, name="GET_DEVICES")
+        return [Device(**d) for d in response]
+
+    async def get_device(self, device_id: str) -> Optional[Device]:
+        devices = await self.get_devices()
+        device = next((d for d in devices if d.id == device_id), None)
+        return device
+
+    async def get_cameras(self):
+        if self.house_id is None:
+            raise ValueError("House ID not set")
+        url = urljoin(self.__iot_url, f'api/personal/v1/homes/{self.house_id}/devices')
+        params = {'page': 1, 'per_page': 500, 'include_deleted': 'true', 'q[model_type_eq]': 'Cameras::Device'}
+        headers = {
+            "Authorization": f"Bearer {self.iot_access_token}"
+        }
+        response = await self.send_request(url=url, params=params, headers=headers, name="GET_CAMERAS")
+        return [Camera(**c) for c in response]
+
+    async def get_camera(self, camera_id: str) -> Optional[Camera]:
+        cameras = await self.get_cameras()
+        camera = next((d for d in cameras if d.id == camera_id), None)
+        return camera
+
+    async def get_intercoms(self):
+        if self.house_id is None:
+            raise ValueError("House ID not set")
+        url = urljoin(self.__iot_url, f'api/personal/v1/homes/{self.house_id}/relays')
+        headers = {
+            "Authorization": f"Bearer {self.iot_access_token}"
+        }
+        response = await self.send_request(method='GET', url=url, headers=headers, name="GET_INTERCOMS")
+        return [Intercom(**c) for c in response]
+
+    async def close(self):
+        if self.session and not self.session.closed:
+            await self.session.close()
+            self.session = None

saarubetek_api-0.0.2b0.dist-info/METADATA

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: saarubetek-api
+Version: 0.0.2b0
+Summary: A Python library for the Rubetek API – control smart home devices, manage scenes, get device status, and automate your Rubetek ecosystem
+Project-URL: Homepage, https://github.com/RuFiHome/RubetekAPI
+Project-URL: Repository, https://github.com/RuFiHome/RubetekAPI
+Project-URL: Issues, https://github.com/RuFiHome/RubetekAPI/issues
+Author-email: AlexVot <alexey.shamray@yandex.ru>
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: certifi>=2023.7.22
+Requires-Dist: pydantic>=2.0.0
+Description-Content-Type: text/markdown
+
+# Rubetek API Library
+
+[![Python Version](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![HACS](https://img.shields.io/badge/HACS-custom-orange.svg)](https://hacs.xyz)
+
+> Python-библиотека для работы с экосистемой умного дома Rubetek с расширенным функционалом
+
+## 📋 Описание
+
+Библиотека предоставляет удобный интерфейс для подключения к облачной платформе Rubetek, получения данных об устройствах, камерах и мониторинга показаний счётчиков водоснабжения. Основана на [RubetekSocketApi](https://github.com/regenara/rubetek_socket_api)
+
+## ✨ Возможности
+
+- 🔐 Авторизация и управление сессией подключения к Rubetek Cloud
+- 📡 Получение списка устройств и их текущего состояния
+- 🎥 Работа с камерами: статус, поток, события
+- 💧 Мониторинг показаний счётчиков ХВС и ГВС с историей данных
+- 🔔 Подписка на события в реальном времени (WebSocket)
+- 🔄 Автоматическое переподключение при обрыве связи
+- 🪵 Логирование с настраиваемым уровнем детализации
+
+## 🚀 Установка
+
+```bash
+# Установка из PyPI (когда будет опубликовано)
+pip install ...
+
+# Или установка из исходников
+pip install git+https://github.com/RuFiHome/RubetekAPI.git
+
+НЕ ИМЕЕТ ОТНОШЕНИЯ К RUBETEK!!!

saarubetek_api-0.0.2b0.dist-info/RECORD

@@ -0,0 +1,9 @@
+SAARubetekAPI/__init__.py,sha256=BqgNa0moEXeZjtDrRZ31EaYoZ-b95u3zS53QROP81D4,64
+SAARubetekAPI/exceptions.py,sha256=IF2KVd4tVgcGs2pztyO-36OGt4prQASN4OHEbyPjMh8,1156
+SAARubetekAPI/logger.py,sha256=czXvDHF3FdZ3AQXqF4NGUXuQABFEV4QcAnHL03rHWhc,1674
+SAARubetekAPI/models.py,sha256=AGl5BbhAmxCaNndx_ybju1y4hcWUA6xIGTDD2JI8Y5A,3725
+SAARubetekAPI/wrapper.py,sha256=WzB_07zj4UGzc685KiQpL8BqOXXeYXC7VXSzFNkPvSY,17465
+saarubetek_api-0.0.2b0.dist-info/METADATA,sha256=RgG0f9QdGi7Fv-HTFSED3QO6kFomadRZOYA65WYaPlw,2545
+saarubetek_api-0.0.2b0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+saarubetek_api-0.0.2b0.dist-info/licenses/LICENSE,sha256=9JnvwqkPZIr54e5L2NGQxrwn2OazW6FeuisPmyqkS_M,1064
+saarubetek_api-0.0.2b0.dist-info/RECORD,,

saarubetek_api-0.0.2b0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

saarubetek_api-0.0.2b0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AlexVot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.