pymammotion 0.5.69__py3-none-any.whl

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

pymammotion/aliyun/tmp_constant.py

@@ -0,0 +1,171 @@
+class tmp_constant:
+    ALGECC = "ecc"
+    ALGHMACMD5 = "hmacmd5"
+    ALGNONE = "none"
+    ALINK_SECURE_URI_SCHEME = "coaps"
+    ALINK_URI_SCHEME = "coap"
+    AUTH_VER = "1.0"
+    CONFIG_TYPE_CLIENT = "ClientAuthInfo"
+    CONFIG_TYPE_PROVISION_RECEIVER = "SetupData"
+    CONFIG_TYPE_SERVER = "ServerAuthInfo"
+    DATA_KEY_DEVICENAME = "MAC"
+    DATA_KEY_DEVICE_WIFI_STATUS = "wifiEnabled"
+    DEFAULT_COAP_SECURE_PORT = 5684
+    DEFAULT_COAP_UDP_PORT = 5683
+    DEFAULT_MULTI_CAST_ADDRESS = "224.0.1.187"
+    DEVICES = "devices"
+    DEVICE_DATA_FORMAT_ALINK = "ALINK_FORMAT"
+    DEVICE_IOTID = "iotId"
+    DEVICE_MODEL = "deviceModel"
+    DEVICE_MODEL_EVENTS = "events"
+    DEVICE_MODEL_PROPERTIES = "properties"
+    DEVICE_MODEL_SERVICES = "services"
+    DEVICE_MODEL_TYPE = "model"
+    DEVICE_NAME = "deviceName"
+    DEVICE_NAME_POSITION = 2
+    DEVICE_PRODUCT_KEY = "productKey"
+    DEVICE_PROFILE = "profile"
+    EVENT_PROPERTY_URI_POST = "post"
+    EVENT_PROPERTY_URI_POST_REPLY = "post_reply"
+    EVENT_PROPERTY_URI_PRE = "thing/event/property"
+    EVENT_URI_POST = "post"
+    EVENT_URI_PRE = "thing/event"
+    EXPAND_SPLITE = "."
+    GROUP_CLOUD_ROLE_COTROLLER = "COTROLLER"
+    GROUP_CLOUD_ROLE_DEVICE = "DEVICE"
+    GROUP_DEVICE_LOCAL_STATUS_OFFLINE = 3
+    GROUP_DEVICE_LOCAL_STATUS_ONLINE = 1
+    GROUP_LOCAL_SATUS_ALLOFFLINE = 2
+    GROUP_LOCAL_SATUS_ALLONLINE = 0
+    GROUP_LOCAL_SATUS_PARTONLINE = 1
+    GROUP_OP_ADD = "add"
+    GROUP_OP_DEL = "del"
+    GROUP_ROLE_CONTROLLER = "cloud_ctl"
+    GROUP_ROLE_DEVICE = "cloud_dev"
+    GROUP_ROLE_UNKNOWN = "null"
+    HEARTBEAT_DEFAULT_TIME = 600000
+    HEARTBEAT_MAX_RETRY_TIME = 3
+    IDENTIFIER_DEVICENOTIFY = "devnotify"
+    IDENTIFIER_RAW_DATA_DOWN = "raw_data_down"
+    IDENTIFIER_SETUP = "setup"
+    IDENTITY_ADMIN = "0"
+    IDENTITY_GUEST = "1"
+    IDENTITY_PROVISION = "2"
+    KEY_CLIENT_ID = "clientId"
+    KEY_IOT_NeedRsp = "NeedRsp"
+    KEY_IOT_NeedRsp_EX = "NeedRspEx"
+    KEY_IOT_PERFORMANCE_EVENT_REQ = "req"
+    KEY_IOT_PERFORMANCE_EVENT_RES = "res"
+    KEY_IOT_PERFORMANCE_ID = "IotPerformanceId"
+    KEY_IOT_QOS = "QosLevel"
+    KEY_IOT_QOS_EX = "QosLevelEx"
+    KEY_SIGN_METHOD = "signMethod"
+    KEY_SIGN_VALUE = "sign"
+    LINK_DEFAULT_CONNECT_ID = "LINK_DEAFULT"
+    MAX_BLOCK_SIZE = 3072
+    MAX_DEVICE_MODEL_LENGTH = 3072
+    METHOD_AUTH_USER = "core.service.user"
+    METHOD_DEVICE_NOTIFY = "core.service.notify"
+    METHOD_HEART_BEAT = "core.service.heartBeat"
+    METHOD_IDENTIFIER_DEV = "dev"
+    METHOD_PROPERTY_GET = "thing.service.property.get"
+    METHOD_PROPERTY_POST = "thing.event.property.post"
+    METHOD_PROPERTY_SET = "thing.service.property.set"
+    METHOD_SERVICE_AUTH = "core.service.auth"
+    METHOD_SERVICE_AUTH_INFO = "core.service.auth_info"
+    METHOD_SERVICE_DISCOVERY = "core.service.dev"
+    METHOD_SERVICE_PRE = "thing.service."
+    METHOD_SETUP = "core.service.setup"
+    METHOD_TSL_TEMPLATE = "thing.dsltemplate.get"
+    METHOD_URI_PRE = "thing/service"
+    METHOD_USER_SERVICE = "core.service.user"
+    MODEL_TYPE_ALI_LCA_CLOUD = "4"
+    MODE_VALUE_RANDW = "rw"
+    MODE_VALUE_READ = "r"
+    MODE_VALUE_WRITE = "w"
+    MQTT_NOTIFY_TOPIC_PREFIX = "/app/down/_thing"
+    MQTT_TOPIC_EVENTS = "/app/down/thing/events"
+    MQTT_TOPIC_NOTIFY = "/app/down/_thing/event/notify"
+    MQTT_TOPIC_PREFIX = "/app/down/thing"
+    MQTT_TOPIC_PROPERTIES = "/app/down/thing/properties"
+    MQTT_TOPIC_SERVICE_REPLY = "/app/down/thing/service/invoke/reply"
+    MQTT_TOPIC_STATUS = "/app/down/thing/status"
+    OPTIONNUMREGISTRY_ACCESSKEY = 36  # deprecated
+    PATH_DISCOVERY = "/dev/core/service/dev"
+    PATH_GROUP_PRE = "/thing/service/"
+    PATH_NOTIFY = "/dev/core/service/notify"
+    PATH_SETUP = "/core/service/setup"
+    PAYLOAD_CODE = "code"
+    PRODUCT_KEY_POSITION = 1
+    PROPERTY_IDENTIFIER = "identifier"
+    PROPERTY_IDENTIFIER_GET = "get"
+    PROPERTY_IDENTIFIER_SET = "set"
+    PROPERTY_NAME = "name"
+    PROPERTY_TIME = "time"
+    PROPERTY_URI_PRE = "thing/service/property"
+    PROPERTY_VALUE = "value"
+    REQUEST_DELAYTIME = "delayTime"
+    REQUEST_ID = "id"
+    REQUEST_METHOD = "method"
+    REQUEST_PARAMS = "params"
+    REQUEST_SESSIONKEY = "sessionKey"
+    REQUEST_VERSION = "version"
+    RESULT_FAIL = "Failed"
+    RESULT_OK = "Success"
+    RRESPONSE_DATA = "data"
+    RRESPONSE_MESSAGEID = "messageId"
+    SERVICE_CALLTYPE = "callType"
+    SERVICE_DESC = "desc"
+    SERVICE_IDENTIFIER = "identifier"
+    SERVICE_INPUTDATA = "inputData"
+    SERVICE_METHOD = "method"
+    SERVICE_NAME = "name"
+    SERVICE_OUTPUTDATA = "outputData"
+    SESSION_VALID_TIME = 86400  # deprecated
+    TAG = "[Tmp]"
+    THING_WIFI_STATUS_NOTIFY = "thing/wifi/status/notify"
+    TMP_MODEL_TYPE_ALI_BREEZE = "breeze"
+    TMP_MODEL_TYPE_ALI_LCA_CLOUD = "cloudlca"
+    TMP_MODEL_TYPE_ALI_THIRD_PART = "third"
+    TMP_MODEL_TYPE_ALI_WIFI = "wifi"
+    TYPE_VALUE_ARRAY = "array"
+    TYPE_VALUE_BOOLEAN = "bool"
+    TYPE_VALUE_DATE = "date"
+    TYPE_VALUE_DOUBLE = "double"
+    TYPE_VALUE_ENUM = "enum"
+    TYPE_VALUE_FLOAT = "float"
+    TYPE_VALUE_INTEGER = "int"
+    TYPE_VALUE_STRING = "string"
+    TYPE_VALUE_STRUCT = "struct"
+    TYPE_VALUE_TEXT = "text"
+    UNKNOWN_CODE = 0  # deprecated
+    URI_ALINK_DEVICE_DATA = "alink/deviceStatus"  # deprecated
+    URI_ALINK_SERVICE = "alink/service"  # deprecated
+    URI_AUTH = "/auth"  # deprecated
+    URI_AUTHEN_REGISTER = "/sys/{productKey}/{deviceName}/thing/authen/sub/register"
+    URI_AUTHEN_REGISTER_REPLY = "/sys/{productKey}/{deviceName}/thing/authen/sub/register_reply"
+    URI_BLACKLIST_UPDATE_POST = "/thing/lan/blacklist/update"
+    URI_BLACKLIST_UPDATE_REPLY_POST = "/thing/lan/blacklist/update_reply"
+    URI_DEVICE = "/device/core/dev"
+    URI_DEV_PATH_PRE = "dev"
+    URI_METHOD = "/device/core/method"
+    URI_MODEL = "/model"
+    URI_PATH_SPLITER = "/"
+    URI_PERMISSION = "/permission"
+    URI_PREFIX_ALCS_SERVICE = "core/service"
+    URI_PREFIX_UPDATE_POST = "/thing/lan/prefix/update"
+    URI_PREFIX_UPDATE_REPLY_POST = "/thing/lan/prefix/update_reply"
+    URI_PRODUCT_DEVICE_REPLACE = "{deviceName}"
+    URI_PRODUCT_PRODUCT_REPLACE = "{productKey}"
+    URI_PROPERTY_SET = "/thing/service/property/set"
+    URI_SYS_PATH_PRE = "sys"
+    URI_THING = "/thing"
+    URI_TOPIC_LOCALDEVICE_STATECHANGE = "group/localstatechange"
+    URI_TOPIC_REPLY_POST = "_reply"
+    URI_UPDATE_DEVICE_INFO = "/sys/{productKey}/{deviceName}/thing/deviceinfo/update"
+    URI_UPDATE_DEVICE_INFO_REPLY = "/sys/{productKey}/{deviceName}/thing/deviceinfo/update_reply"
+    URI_USER = "/user"
+    VALUE_SHA256 = "sha256"
+    VERSION = "1.0"
+    WIFI_STATUS_KEY = "status"
+    WIFI_STATUS_NOTIFY_PARAMS = "params"

pymammotion/bluetooth/__init__.py

@@ -0,0 +1 @@
+from .ble_message import BleMessage

pymammotion/bluetooth/ble.py

@@ -0,0 +1,62 @@
+from bleak import BleakClient, BleakScanner, BLEDevice
+from bleak.backends.characteristic import BleakGATTCharacteristic
+
+from pymammotion.bluetooth.const import SERVICE_CHANGED_CHARACTERISTIC, UUID_NOTIFICATION_CHARACTERISTIC
+from pymammotion.event.event import BleNotificationEvent
+
+
+class MammotionBLE:
+    """Class for basic ble connections to mowers."""
+
+    client: BleakClient
+
+    def __init__(self, bleEvt: BleNotificationEvent) -> None:
+        self._bleEvt = bleEvt
+
+    async def scanForLubaAndConnect(self) -> bool:
+        scanner = BleakScanner()
+
+        def scanCallback(device, advertising_data) -> bool:
+            # TODO: do something with incoming data
+            print(device)
+            print(advertising_data)
+            if advertising_data.local_name and (
+                "Luba-" in advertising_data.local_name or "Yuka-" in advertising_data.local_name
+            ):
+                return True
+            return False
+
+        device = await scanner.find_device_by_filter(scanCallback)
+        if device is not None:
+            return await self.create_client(device)
+        return False
+
+    async def create_client(self, device: BLEDevice):
+        self.client = BleakClient(device.address)
+        return await self.connect()
+
+    async def connect(self) -> bool:
+        return await self.client.connect() if self.client is not None else False
+
+    async def disconnect(self) -> bool:
+        return await self.client.disconnect() if self.client is not None else False
+
+    async def notification_handler(self, _characteristic: BleakGATTCharacteristic, data: bytearray) -> None:
+        """Simple notification handler which prints the data received."""
+        await self._bleEvt.BleNotification(data)
+
+    def service_changed_handler(self, characteristic: BleakGATTCharacteristic, data: bytearray) -> None:
+        """Simple notification handler which prints the data received."""
+        print(f"Response 2 {characteristic.description}: {data}")
+        print(data.decode("utf-8"))
+        # BlufiNotifyData
+        # run an event handler back to somewhere
+
+    async def notifications(self) -> None:
+        if self.client.is_connected:
+            await self.client.start_notify(UUID_NOTIFICATION_CHARACTERISTIC, self.notification_handler)
+            await self.client.start_notify(SERVICE_CHANGED_CHARACTERISTIC, self.service_changed_handler)
+
+    def get_client(self):
+        """Returns the ble client."""
+        return self.client