pymammotion 0.4.0a2__py3-none-any.whl → 0.5.51__py3-none-any.whl

pymammotion/aliyun/model/aep_response.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Optional
 
 from mashumaro.config import BaseConfig
 from mashumaro.mixins.orjson import DataClassORJSONMixin
@@ -16,7 +15,7 @@ class DeviceData(DataClassORJSONMixin):
 class AepResponse(DataClassORJSONMixin):
     code: int
     data: DeviceData
-    id: Optional[str] = None
+    id: str | None = None
 
     class Config(BaseConfig):
         omit_default = True

pymammotion/aliyun/model/dev_by_account_response.py

@@ -1,36 +1,183 @@
 from dataclasses import dataclass
-from typing import Optional
+from typing import Annotated, Optional
 
 from mashumaro.config import BaseConfig
 from mashumaro.mixins.orjson import DataClassORJSONMixin
+from mashumaro.types import Alias
 
 
 @dataclass
 class Device(DataClassORJSONMixin):
-    gmtModified: int
-    netType: str
-    categoryKey: str
-    productKey: str
-    nodeType: str
-    isEdgeGateway: bool
-    deviceName: str
-    categoryName: str
-    identityAlias: str
-    productName: str
-    iotId: str
-    bindTime: int
-    owned: int
-    identityId: str
-    thingType: str
+    """Unified device model supporting both Device and ShareNotification data"""
+
+    # Core device fields (from Device model)
+    gmt_modified: Annotated[int, Alias("gmtModified")]
+    node_type: Annotated[str, Alias("nodeType")]
+    device_name: Annotated[str, Alias("deviceName")]
+    product_name: Annotated[str, Alias("productName")]
     status: int
-    nickName: Optional[str] = None
+    identity_id: Annotated[str, Alias("identityId")]
+
+    # Required fields from original Device model
+    net_type: Annotated[str, Alias("netType")]
+    category_key: Annotated[str, Alias("categoryKey")]
+    product_key: Annotated[str, Alias("productKey")]
+    is_edge_gateway: Annotated[bool, Alias("isEdgeGateway")]
+    category_name: Annotated[str, Alias("categoryName")]
+    identity_alias: Annotated[str, Alias("identityAlias")]
+    iot_id: Annotated[str, Alias("iotId")]
+    bind_time: Annotated[int, Alias("bindTime")]
+    owned: int
+    thing_type: Annotated[str, Alias("thingType")]
+
+    # Optional fields (common to both or nullable)
+    nick_name: Annotated[Optional[str], Alias("nickName")] = None
     description: Optional[str] = None
-    productImage: Optional[str] = None
-    categoryImage: Optional[str] = None
-    productModel: Optional[str] = None
+    product_image: Annotated[Optional[str], Alias("productImage")] = None
+    category_image: Annotated[Optional[str], Alias("categoryImage")] = None
+    product_model: Annotated[Optional[str], Alias("productModel")] = None
+
+    # Optional fields from ShareNotification only
+    target_id: Annotated[Optional[str], Alias("targetId")] = None
+    receiver_identity_id: Annotated[Optional[str], Alias("receiverIdentityId")] = None
+    target_type: Annotated[Optional[str], Alias("targetType")] = None
+    gmt_create: Annotated[Optional[int], Alias("gmtCreate")] = None
+    batch_id: Annotated[Optional[str], Alias("batchId")] = None
+    record_id: Annotated[Optional[str], Alias("recordId")] = None
+    initiator_identity_id: Annotated[Optional[str], Alias("initiatorIdentityId")] = None
+    is_receiver: Annotated[Optional[int], Alias("isReceiver")] = None
+    initiator_alias: Annotated[Optional[str], Alias("initiatorAlias")] = None
+    receiver_alias: Annotated[Optional[str], Alias("receiverAlias")] = None
 
     class Config(BaseConfig):
         omit_default = True
+        allow_deserialization_not_by_alias = True
+
+
+# # Alternative: Keep them separate but with a common base class
+# @dataclass
+# class BaseDevice(DataClassORJSONMixin):
+#     """Base device model with common fields"""
+#
+#     gmt_modified: int
+#     node_type: str
+#     device_name: str
+#     product_name: str
+#     status: int
+#     product_image: Optional[str] = None
+#     category_image: Optional[str] = None
+#     description: Optional[str] = None
+#
+#     class Config(BaseConfig):
+#         omit_default = True
+#         serialize_by_alias = True
+#         aliases = {
+#             "gmt_modified": "gmtModified",
+#             "node_type": "nodeType",
+#             "device_name": "deviceName",
+#             "product_name": "productName",
+#             "product_image": "productImage",
+#             "category_image": "categoryImage",
+#         }
+#
+#
+# @dataclass
+# class Device(BaseDevice):
+#     """Full device model"""
+#
+#     net_type: str
+#     category_key: str
+#     product_key: str
+#     is_edge_gateway: bool
+#     category_name: str
+#     identity_alias: str
+#     iot_id: str
+#     bind_time: int
+#     owned: int
+#     identity_id: str
+#     thing_type: str
+#     nick_name: Optional[str] = None
+#     product_model: Optional[str] = None
+#
+#     class Config(BaseConfig):
+#         omit_default = True
+#         serialize_by_alias = True
+#         aliases = {
+#             **BaseDevice.Config.aliases,
+#             "net_type": "netType",
+#             "category_key": "categoryKey",
+#             "product_key": "productKey",
+#             "is_edge_gateway": "isEdgeGateway",
+#             "category_name": "categoryName",
+#             "identity_alias": "identityAlias",
+#             "iot_id": "iotId",
+#             "bind_time": "bindTime",
+#             "identity_id": "identityId",
+#             "thing_type": "thingType",
+#             "nick_name": "nickName",
+#             "product_model": "productModel",
+#         }
+#
+#
+# @dataclass
+# class ShareNotification(BaseDevice):
+#     """Share notification model extending base device"""
+#
+#     target_id: str
+#     receiver_identity_id: str
+#     target_type: str
+#     gmt_create: int
+#     batch_id: str
+#     record_id: str
+#     initiator_identity_id: str
+#     is_receiver: int
+#     initiator_alias: str
+#     receiver_alias: str
+#
+#     # Optional fields that Device has but ShareNotification might not
+#     net_type: Optional[str] = None
+#     category_key: Optional[str] = None
+#     product_key: Optional[str] = None
+#     is_edge_gateway: Optional[bool] = None
+#     category_name: Optional[str] = None
+#     identity_alias: Optional[str] = None
+#     iot_id: Optional[str] = None
+#     bind_time: Optional[int] = None
+#     owned: Optional[int] = None
+#     identity_id: Optional[str] = None
+#     thing_type: Optional[str] = None
+#     nick_name: Optional[str] = None
+#     product_model: Optional[str] = None
+#
+#     class Config(BaseConfig):
+#         omit_default = True
+#         serialize_by_alias = True
+#         aliases = {
+#             **BaseDevice.Config.aliases,
+#             "target_id": "targetId",
+#             "receiver_identity_id": "receiverIdentityId",
+#             "target_type": "targetType",
+#             "gmt_create": "gmtCreate",
+#             "batch_id": "batchId",
+#             "record_id": "recordId",
+#             "initiator_identity_id": "initiatorIdentityId",
+#             "is_receiver": "isReceiver",
+#             "initiator_alias": "initiatorAlias",
+#             "receiver_alias": "receiverAlias",
+#             # Device fields that might be present
+#             "net_type": "netType",
+#             "category_key": "categoryKey",
+#             "product_key": "productKey",
+#             "is_edge_gateway": "isEdgeGateway",
+#             "category_name": "categoryName",
+#             "identity_alias": "identityAlias",
+#             "iot_id": "iotId",
+#             "bind_time": "bindTime",
+#             "identity_id": "identityId",
+#             "thing_type": "thingType",
+#             "nick_name": "nickName",
+#             "product_model": "productModel",
+#         }
 
 
 @dataclass
@@ -42,7 +189,7 @@ class Data(DataClassORJSONMixin):
 
 
 @dataclass
-class ListingDevByAccountResponse(DataClassORJSONMixin):
+class ListingDevAccountResponse(DataClassORJSONMixin):
     code: int
-    data: Optional[Data]
-    id: Optional[str] = None
+    data: Data | None
+    id: str | None = None

pymammotion/aliyun/model/login_by_oauth_response.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Optional
 
 from mashumaro.mixins.orjson import DataClassORJSONMixin
 
@@ -18,7 +17,7 @@ class OpenAccount(DataClassORJSONMixin):
     domainId: int
     enableDevice: str
     status: int
-    country: Optional[str] = None
+    country: str | None = None
 
 
 @dataclass
@@ -54,7 +53,7 @@ class InnerData(DataClassORJSONMixin):
     subCode: int
     message: str
     successful: str
-    deviceId: Optional[str] = None
+    deviceId: str | None = None
 
 
 @dataclass

pymammotion/aliyun/model/regions_response.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Optional, TypeVar
+from typing import TypeVar
 
 from mashumaro.config import BaseConfig
 from mashumaro.mixins.orjson import DataClassORJSONMixin
@@ -22,8 +22,8 @@ class RegionResponseData(DataClassORJSONMixin):
 class RegionResponse(DataClassORJSONMixin):
     data: RegionResponseData
     code: int
-    id: Optional[str] = None
-    msg: Optional[str] = None
+    id: str | None = None
+    msg: str | None = None
 
     class Config(BaseConfig):
         omit_default = True

pymammotion/aliyun/model/session_by_authcode_response.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Optional
 
 from mashumaro.mixins.orjson import DataClassORJSONMixin
 
@@ -16,4 +15,5 @@ class SessionOauthToken(DataClassORJSONMixin):
 @dataclass
 class SessionByAuthCodeResponse(DataClassORJSONMixin):
     code: int
-    data: Optional[SessionOauthToken] = None
+    data: SessionOauthToken | None = None
+    token_issued_at: int | None = None

pymammotion/aliyun/model/thing_response.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass
+
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+
+from pymammotion.data.mqtt.properties import Items
+
+
+@dataclass
+class ThingPropertiesResponse(DataClassORJSONMixin):
+    code: int
+    data: Items | None
+    id: str | None = None

pymammotion/aliyun/regions.py

@@ -0,0 +1,62 @@
+region_mappings = {
+    # Asia Pacific
+    "CN": "cn-hongkong",  # China -> Hong Kong
+    "HK": "cn-hongkong",  # Hong Kong
+    "TW": "cn-hongkong",  # Taiwan -> Hong Kong
+    "MO": "cn-hongkong",  # Macau -> Hong Kong
+    # Southeast Asia
+    "SG": "ap-southeast-1",  # Singapore
+    "MY": "ap-southeast-3",  # Malaysia
+    "ID": "ap-southeast-5",  # Indonesia
+    "TH": "ap-southeast-1",  # Thailand -> Singapore
+    "VN": "ap-southeast-1",  # Vietnam -> Singapore
+    "PH": "ap-southeast-1",  # Philippines -> Singapore
+    "BN": "ap-southeast-1",  # Brunei -> Singapore
+    "KH": "ap-southeast-1",  # Cambodia -> Singapore
+    "LA": "ap-southeast-1",  # Laos -> Singapore
+    "MM": "ap-southeast-1",  # Myanmar -> Singapore
+    # Australia/Oceania
+    "AU": "ap-southeast-2",  # Australia
+    "NZ": "ap-southeast-2",  # New Zealand -> Australia
+    "FJ": "ap-southeast-2",  # Fiji -> Australia
+    "PG": "ap-southeast-2",  # Papua New Guinea -> Australia
+    # South Asia
+    "IN": "ap-south-1",  # India
+    "LK": "ap-south-1",  # Sri Lanka -> India
+    "PK": "ap-south-1",  # Pakistan -> India
+    "BD": "ap-south-1",  # Bangladesh -> India
+    "NP": "ap-south-1",  # Nepal -> India
+    "BT": "ap-south-1",  # Bhutan -> India
+    "MV": "ap-south-1",  # Maldives -> India
+    # Middle East
+    "AE": "me-east-1",  # UAE
+    "SA": "me-east-1",  # Saudi Arabia -> UAE
+    "QA": "me-east-1",  # Qatar -> UAE
+    "KW": "me-east-1",  # Kuwait -> UAE
+    "BH": "me-east-1",  # Bahrain -> UAE
+    "OM": "me-east-1",  # Oman -> UAE
+    "IL": "me-east-1",  # Israel -> UAE
+    "TR": "me-east-1",  # Turkey -> UAE
+    # Europe
+    "DE": "eu-central-1",  # Germany
+    "FR": "eu-central-1",  # France -> Germany
+    "IT": "eu-central-1",  # Italy -> Germany
+    "ES": "eu-central-1",  # Spain -> Germany
+    "GB": "eu-central-1",  # UK -> Germany
+    "IE": "eu-central-1",  # Ireland -> Germany
+    "NL": "eu-central-1",  # Netherlands -> Germany
+    "BE": "eu-central-1",  # Belgium -> Germany
+    "CH": "eu-central-1",  # Switzerland -> Germany
+    "AT": "eu-central-1",  # Austria -> Germany
+    "PL": "eu-central-1",  # poland -> Germany
+    # North America
+    "US": "us-east-1",  # USA
+    "CA": "us-east-1",  # Canada -> US East
+    "MX": "us-west-1",  # Mexico -> US West
+    # South America
+    "BR": "us-east-1",  # Brazil -> US East
+    "AR": "us-east-1",  # Argentina -> US East
+    "CL": "us-east-1",  # Chile -> US East
+    "CO": "us-east-1",  # Colombia -> US East
+    "PE": "us-east-1",  # Peru -> US East
+}

pymammotion/aliyun/tea/core.py

@@ -0,0 +1,297 @@
+import asyncio
+import logging
+import os
+import socket
+import ssl
+import time
+from typing import Any
+from urllib.parse import urlencode, urlparse
+
+import aiohttp
+import certifi
+from requests import PreparedRequest, adapters, status_codes
+from Tea.exceptions import RequiredArgumentException, RetryError
+from Tea.model import TeaModel
+from Tea.request import TeaRequest
+from Tea.response import TeaResponse
+from Tea.stream import BaseStream
+
+DEFAULT_CONNECT_TIMEOUT = 5000
+DEFAULT_READ_TIMEOUT = 10000
+DEFAULT_POOL_SIZE = 10
+
+logger = logging.getLogger("alibabacloud-tea")
+logger.setLevel(logging.DEBUG)
+ch = logging.StreamHandler()
+logger.addHandler(ch)
+
+
+class TeaCore:
+    http_adapter = adapters.HTTPAdapter(pool_connections=DEFAULT_POOL_SIZE, pool_maxsize=DEFAULT_POOL_SIZE * 4)
+    https_adapter = adapters.HTTPAdapter(pool_connections=DEFAULT_POOL_SIZE, pool_maxsize=DEFAULT_POOL_SIZE * 4)
+
+    @staticmethod
+    def get_adapter(prefix):
+        if prefix.upper() == "HTTP":
+            return TeaCore.http_adapter
+        else:
+            return TeaCore.https_adapter
+
+    @staticmethod
+    def _prepare_http_debug(request, symbol):
+        base = ""
+        for key, value in request.headers.items():
+            base += f"\n{symbol} {key} : {value}"
+        return base
+
+    @staticmethod
+    def _do_http_debug(request, response) -> None:
+        # logger the request
+        url = urlparse(request.url)
+        request_base = f"\n> {request.method.upper()} {url.path + url.query} HTTP/1.1"
+        logger.debug(request_base + TeaCore._prepare_http_debug(request, ">"))
+
+        # logger the response
+        response_base = (
+            f"\n< HTTP/1.1 {response.status_code}" f" {status_codes._codes.get(response.status_code)[0].upper()}"
+        )
+        logger.debug(response_base + TeaCore._prepare_http_debug(response, "<"))
+
+    @staticmethod
+    def compose_url(request):
+        host = request.headers.get("host")
+        if not host:
+            raise RequiredArgumentException("endpoint")
+        else:
+            host = host.rstrip("/")
+        protocol = f"{request.protocol.lower()}://"
+        pathname = request.pathname
+
+        if host.startswith(("http://", "https://")):
+            protocol = ""
+
+        if request.port == 80:
+            port = ""
+        else:
+            port = f":{request.port}"
+
+        url = protocol + host + port + pathname
+
+        if request.query:
+            if "?" in url:
+                if not url.endswith("&"):
+                    url += "&"
+            else:
+                url += "?"
+
+            encode_query = {}
+            for key in request.query:
+                value = request.query[key]
+                if value is not None:
+                    encode_query[key] = str(value)
+            url += urlencode(encode_query)
+        return url.rstrip("?&")
+
+    @staticmethod
+    async def async_do_action(request: TeaRequest, runtime_option=None) -> TeaResponse:
+        runtime_option = runtime_option or {}
+
+        url = TeaCore.compose_url(request)
+        verify = not runtime_option.get("ignoreSSL", False)
+
+        timeout = runtime_option.get("timeout")
+        connect_timeout = runtime_option.get("connectTimeout") or timeout or DEFAULT_CONNECT_TIMEOUT
+        read_timeout = runtime_option.get("readTimeout") or timeout or DEFAULT_READ_TIMEOUT
+
+        connect_timeout, read_timeout = (int(connect_timeout) / 1000, int(read_timeout) / 1000)
+
+        proxy = None
+        if request.protocol.upper() == "HTTP":
+            proxy = runtime_option.get("httpProxy")
+            if not proxy:
+                proxy = os.environ.get("HTTP_PROXY") or os.environ.get("http_proxy")
+        elif request.protocol.upper() == "HTTPS":
+            proxy = runtime_option.get("httpsProxy")
+            if not proxy:
+                proxy = os.environ.get("HTTPS_PROXY") or os.environ.get("https_proxy")
+
+        connector = None
+        ca_cert = certifi.where()
+        if ca_cert and request.protocol.upper() == "HTTPS":
+            loop = asyncio.get_event_loop()
+
+            ssl_context = await loop.run_in_executor(None, ssl.create_default_context, ssl.Purpose.SERVER_AUTH)
+            await loop.run_in_executor(None, ssl_context.load_verify_locations, ca_cert)
+            connector = aiohttp.TCPConnector(
+                ssl=ssl_context,
+                family=socket.AF_INET,
+            )
+        else:
+            verify = False
+
+        timeout = aiohttp.ClientTimeout(sock_read=read_timeout, sock_connect=connect_timeout)
+        async with aiohttp.ClientSession(connector=connector) as s:
+            body = b""
+            if isinstance(request.body, BaseStream):
+                for content in request.body:
+                    body += content
+            elif isinstance(request.body, str):
+                body = request.body.encode("utf-8")
+            else:
+                body = request.body
+            try:
+                async with s.request(
+                    request.method, url, data=body, headers=request.headers, ssl=verify, proxy=proxy, timeout=timeout
+                ) as response:
+                    tea_resp = TeaResponse()
+                    tea_resp.body = await response.read()
+                    tea_resp.headers = {k.lower(): v for k, v in response.headers.items()}
+                    tea_resp.status_code = response.status
+                    tea_resp.status_message = response.reason
+                    tea_resp.response = response
+            except OSError as e:
+                raise RetryError(str(e))
+        return tea_resp
+
+    @staticmethod
+    def do_action(request: TeaRequest, runtime_option=None) -> TeaResponse:
+        url = TeaCore.compose_url(request)
+
+        runtime_option = runtime_option or {}
+
+        verify = not runtime_option.get("ignoreSSL", False)
+        if verify:
+            verify = runtime_option.get("ca", True) if runtime_option.get("ca", True) is not None else True
+        cert = runtime_option.get("cert", None)
+
+        timeout = runtime_option.get("timeout")
+        connect_timeout = runtime_option.get("connectTimeout") or timeout or DEFAULT_CONNECT_TIMEOUT
+        read_timeout = runtime_option.get("readTimeout") or timeout or DEFAULT_READ_TIMEOUT
+
+        timeout = (int(connect_timeout) / 1000, int(read_timeout) / 1000)
+
+        if isinstance(request.body, str):
+            request.body = request.body.encode("utf-8")
+
+        p = PreparedRequest()
+        p.prepare(
+            method=request.method.upper(),
+            url=url,
+            data=request.body,
+            headers=request.headers,
+        )
+
+        proxies = {}
+        http_proxy = runtime_option.get("httpProxy")
+        https_proxy = runtime_option.get("httpsProxy")
+        no_proxy = runtime_option.get("noProxy")
+
+        if not http_proxy:
+            http_proxy = os.environ.get("HTTP_PROXY") or os.environ.get("http_proxy")
+        if not https_proxy:
+            https_proxy = os.environ.get("HTTPS_PROXY") or os.environ.get("https_proxy")
+
+        if http_proxy:
+            proxies["http"] = http_proxy
+        if https_proxy:
+            proxies["https"] = https_proxy
+        if no_proxy:
+            proxies["no_proxy"] = no_proxy
+
+        adapter = TeaCore.get_adapter(request.protocol)
+        try:
+            resp = adapter.send(
+                p,
+                proxies=proxies,
+                timeout=timeout,
+                verify=verify,
+                cert=cert,
+            )
+        except OSError as e:
+            raise RetryError(str(e))
+
+        debug = runtime_option.get("debug") or os.getenv("DEBUG")
+        if debug and debug.lower() == "sdk":
+            TeaCore._do_http_debug(p, resp)
+
+        response = TeaResponse()
+        response.status_message = resp.reason
+        response.status_code = resp.status_code
+        response.headers = {k.lower(): v for k, v in resp.headers.items()}
+        response.body = resp.content
+        response.response = resp
+        return response
+
+    @staticmethod
+    def get_response_body(resp) -> str:
+        return resp.content.decode("utf-8")
+
+    @staticmethod
+    def allow_retry(dic, retry_times, now=None) -> bool:
+        if retry_times == 0:
+            return True
+        if dic is None or not dic.__contains__("maxAttempts") or dic.get("retryable") is not True and retry_times >= 1:
+            return False
+        else:
+            retry = 0 if dic.get("maxAttempts") is None else int(dic.get("maxAttempts"))
+        return retry >= retry_times
+
+    @staticmethod
+    def get_backoff_time(dic, retry_times) -> int:
+        default_back_off_time = 0
+        if dic is None or not dic.get("policy") or dic.get("policy") == "no":
+            return default_back_off_time
+
+        back_off_time = dic.get("period", default_back_off_time)
+        if not isinstance(back_off_time, int) and not (isinstance(back_off_time, str) and back_off_time.isdigit()):
+            return default_back_off_time
+
+        back_off_time = int(back_off_time)
+        if back_off_time < 0:
+            return retry_times
+
+        return back_off_time
+
+    @staticmethod
+    async def sleep_async(t) -> None:
+        await asyncio.sleep(t)
+
+    @staticmethod
+    def sleep(t) -> None:
+        time.sleep(t)
+
+    @staticmethod
+    def is_retryable(ex) -> bool:
+        return isinstance(ex, RetryError)
+
+    @staticmethod
+    def bytes_readable(body):
+        return body
+
+    @staticmethod
+    def merge(*dic_list) -> dict:
+        dic_result = {}
+        for item in dic_list:
+            if isinstance(item, dict):
+                dic_result.update(item)
+            elif isinstance(item, TeaModel):
+                dic_result.update(item.to_map())
+        return dic_result
+
+    @staticmethod
+    def to_map(model: TeaModel | None) -> dict[str, Any]:
+        if isinstance(model, TeaModel):
+            return model.to_map()
+        else:
+            return dict()
+
+    @staticmethod
+    def from_map(model: TeaModel, dic: dict[str, Any]) -> TeaModel:
+        if isinstance(model, TeaModel):
+            try:
+                return model.from_map(dic)
+            except Exception:
+                model._map = dic
+                return model
+        else:
+            return model