wyzeapy 0.5.28__py3-none-any.whl → 0.5.30__py3-none-any.whl

wyzeapy/services/bulb_service.py

@@ -15,55 +15,86 @@ _LOGGER = logging.getLogger(__name__)
 
 
 class Bulb(Device):
+    """Bulb class for interacting with Wyze bulbs."""
+
     _brightness: int = 0
     _color_temp: int = 1800
     _color: Optional[str]
-    enr: str
-
-    on: bool = False
-    cloud_fallback = False
 
     def __init__(self, dictionary: Dict[Any, Any]):
+        """Initialize the Bulb class.
+
+        :param dictionary: Dictionary containing the device parameters.
+        """
+        self.enr: str = ""
+        """Encryption string"""
+        self.on: bool = False
+        """Variable that stores the on/off state of the bulb"""
+        self.cloud_fallback: bool = False
+        """Variable that stores the cloud fallback state of the bulb"""
         super().__init__(dictionary)
 
         self.ip = self.device_params["ip"]
+        """IP address of the bulb"""
 
-        if (
-            self.type is DeviceTypes.MESH_LIGHT
-            or self.type is DeviceTypes.LIGHTSTRIP
-        ):
+        if self.type is DeviceTypes.MESH_LIGHT or self.type is DeviceTypes.LIGHTSTRIP:
             self._color = "000000"
 
     @property
     def brightness(self) -> int:
+        """Property that stores the brightness of the bulb
+        :return: Brightness of the bulb
+        """
         return self._brightness
 
     @brightness.setter
     def brightness(self, value: int) -> None:
+        """Setter for the brightness property
+        :param value: Brightness of the bulb
+        """
         assert value <= 100
         assert value >= 0
         self._brightness = value
 
     @property
     def color_temp(self) -> int:
+        """Property that stores the color temperature of the bulb
+        :return: Color temperature of the bulb
+        """
         return self._color_temp
 
     @color_temp.setter
     def color_temp(self, value: int) -> None:
+        """Setter for the color temperature property
+        :param value: Color temperature of the bulb
+        """
         self._color_temp = value
 
     @property
     def color(self) -> Optional[str]:
+        """Property that stores the color of the bulb
+        :return: Color of the bulb
+        """
         return self._color
 
     @color.setter
     def color(self, value) -> None:
+        """Setter for the color property
+        :param value: Color of the bulb
+        """
         assert re.match(r"^([A-Fa-f\d]{6}|[A-Fa-f\d]{3})$", value) is not None
         self._color = value
 
 
 class BulbService(BaseService):
+    """Bulb service for interacting with Wyze bulbs."""
+
     async def update(self, bulb: Bulb) -> Bulb:
+        """Update the bulb object with the latest device parameters.
+
+        :param bulb: Bulb object to update
+        :return: Updated bulb object
+        """
         # Get updated device_params
         async with BaseService._update_lock:
             bulb.device_params = await self.get_updated_params(bulb.mac)
@@ -81,10 +112,10 @@ class BulbService(BaseService):
                 bulb.on = value == "1"
             elif property_id == PropertyIDs.AVAILABLE:
                 bulb.available = value == "1"
-            elif (
-                property_id == PropertyIDs.COLOR
-                and bulb.type in [DeviceTypes.LIGHTSTRIP, DeviceTypes.MESH_LIGHT]
-            ):
+            elif property_id == PropertyIDs.COLOR and bulb.type in [
+                DeviceTypes.LIGHTSTRIP,
+                DeviceTypes.MESH_LIGHT,
+            ]:
                 bulb.color = value
             elif property_id == PropertyIDs.COLOR_MODE:
                 bulb.color_mode = value
@@ -98,23 +129,24 @@ class BulbService(BaseService):
         return bulb
 
     async def get_bulbs(self) -> List[Bulb]:
+        """Get a list of all bulbs.
+
+        :return: List of Bulb objects
+        """
         if self._devices is None:
             self._devices = await self.get_object_list()
 
         bulbs = [
             device
             for device in self._devices
-            if device.type in [DeviceTypes.LIGHT,
-                               DeviceTypes.MESH_LIGHT,
-                               DeviceTypes.LIGHTSTRIP]
+            if device.type
+            in [DeviceTypes.LIGHT, DeviceTypes.MESH_LIGHT, DeviceTypes.LIGHTSTRIP]
         ]
 
         return [Bulb(bulb.raw_dict) for bulb in bulbs]
 
     async def turn_on(self, bulb: Bulb, local_control, options=None):
-        plist = [
-            create_pid_pair(PropertyIDs.ON, "1")
-        ]
+        plist = [create_pid_pair(PropertyIDs.ON, "1")]
 
         if options is not None:
             plist.extend(options)
@@ -122,15 +154,15 @@ class BulbService(BaseService):
         if bulb.type is DeviceTypes.LIGHT:
             await self._set_property_list(bulb, plist)
 
-        elif (
-            bulb.type in [DeviceTypes.MESH_LIGHT, DeviceTypes.LIGHTSTRIP]
-        ):
+        elif bulb.type in [DeviceTypes.MESH_LIGHT, DeviceTypes.LIGHTSTRIP]:
             # Local Control
             if local_control and not bulb.cloud_fallback:
                 await self._local_bulb_command(bulb, plist)
 
             # Cloud Control
-            elif bulb.type is DeviceTypes.MESH_LIGHT:  # Sun match for mesh bulbs needs to be set on a different endpoint for some reason
+            elif (
+                bulb.type is DeviceTypes.MESH_LIGHT
+            ):  # Sun match for mesh bulbs needs to be set on a different endpoint for some reason
                 for item in plist:
                     if item["pid"] == PropertyIDs.SUN_MATCH.value:
                         await self._set_property_list(bulb, [item])
@@ -140,74 +172,46 @@ class BulbService(BaseService):
                 await self._run_action_list(bulb, plist)  # Lightstrips
 
     async def turn_off(self, bulb: Bulb, local_control):
-        plist = [
-            create_pid_pair(PropertyIDs.ON, "0")
-        ]
+        plist = [create_pid_pair(PropertyIDs.ON, "0")]
 
-        if bulb.type in [
-            DeviceTypes.LIGHT
-        ]:
+        if bulb.type in [DeviceTypes.LIGHT]:
             await self._set_property_list(bulb, plist)
-        elif (
-            bulb.type in [DeviceTypes.MESH_LIGHT, DeviceTypes.LIGHTSTRIP]
-        ):
+        elif bulb.type in [DeviceTypes.MESH_LIGHT, DeviceTypes.LIGHTSTRIP]:
             if local_control and not bulb.cloud_fallback:
                 await self._local_bulb_command(bulb, plist)
             else:
                 await self._run_action_list(bulb, plist)
 
     async def set_color_temp(self, bulb: Bulb, color_temp: int):
-        plist = [
-            create_pid_pair(PropertyIDs.COLOR_TEMP, str(color_temp))
-        ]
+        plist = [create_pid_pair(PropertyIDs.COLOR_TEMP, str(color_temp))]
 
-        if bulb.type in [
-            DeviceTypes.LIGHT
-        ]:
+        if bulb.type in [DeviceTypes.LIGHT]:
             await self._set_property_list(bulb, plist)
-        elif bulb.type in [
-            DeviceTypes.MESH_LIGHT
-        ]:
+        elif bulb.type in [DeviceTypes.MESH_LIGHT]:
             await self._local_bulb_command(bulb, plist)
 
     async def set_color(self, bulb: Bulb, color: str, local_control):
-        plist = [
-            create_pid_pair(PropertyIDs.COLOR, str(color))
-        ]
-        if bulb.type in [
-            DeviceTypes.MESH_LIGHT
-        ]:
+        plist = [create_pid_pair(PropertyIDs.COLOR, str(color))]
+        if bulb.type in [DeviceTypes.MESH_LIGHT]:
             if local_control and not bulb.cloud_fallback:
                 await self._local_bulb_command(bulb, plist)
             else:
                 await self._run_action_list(bulb, plist)
 
     async def set_brightness(self, bulb: Device, brightness: int):
-        plist = [
-            create_pid_pair(PropertyIDs.BRIGHTNESS, str(brightness))
-        ]
+        plist = [create_pid_pair(PropertyIDs.BRIGHTNESS, str(brightness))]
 
-        if bulb.type in [
-            DeviceTypes.LIGHT
-        ]:
+        if bulb.type in [DeviceTypes.LIGHT]:
             await self._set_property_list(bulb, plist)
-        if bulb.type in [
-            DeviceTypes.MESH_LIGHT
-        ]:
+        if bulb.type in [DeviceTypes.MESH_LIGHT]:
             await self._local_bulb_command(bulb, plist)
 
     async def music_mode_on(self, bulb: Device):
-        plist = [
-            create_pid_pair(PropertyIDs.LIGHTSTRIP_MUSIC_MODE, "1")
-        ]
+        plist = [create_pid_pair(PropertyIDs.LIGHTSTRIP_MUSIC_MODE, "1")]
 
         await self._run_action_list(bulb, plist)
 
     async def music_mode_off(self, bulb: Device):
-        plist = [
-            create_pid_pair(PropertyIDs.LIGHTSTRIP_MUSIC_MODE, "0")
-        ]
+        plist = [create_pid_pair(PropertyIDs.LIGHTSTRIP_MUSIC_MODE, "0")]
 
         await self._run_action_list(bulb, plist)
-
-

wyzeapy/services/camera_service.py

@@ -13,14 +13,17 @@ from aiohttp import ClientOSError, ContentTypeError
 
 from ..exceptions import UnknownApiError
 from .base_service import BaseService
-from .update_manager import DeviceUpdater
 from ..types import Device, DeviceTypes, Event, PropertyIDs, DeviceMgmtToggleProps
 from ..utils import return_event_for_device, create_pid_pair
 
 _LOGGER = logging.getLogger(__name__)
 
 # NOTE: Make sure to also define props in devicemgmt_create_capabilities_payload()
-DEVICEMGMT_API_MODELS = ["LD_CFP", "AN_RSCW", "GW_GC1"] # Floodlight pro, battery cam pro, and OG use a diffrent api (devicemgmt)
+DEVICEMGMT_API_MODELS = [
+    "LD_CFP",
+    "AN_RSCW",
+    "GW_GC1",
+]  # Floodlight pro, battery cam pro, and OG use a diffrent api (devicemgmt)
 
 
 class Camera(Device):
@@ -46,7 +49,7 @@ class CameraService(BaseService):
 
         # Get camera events
         response = await self._get_event_list(10)
-        raw_events = response['data']['event_list']
+        raw_events = response["data"]["event_list"]
         latest_events = [Event(raw_event) for raw_event in raw_events]
 
         if (event := return_event_for_device(camera, latest_events)) is not None:
@@ -54,22 +57,29 @@ class CameraService(BaseService):
             camera.last_event_ts = event.event_ts
 
         # Update camera state
-        if (camera.product_model in DEVICEMGMT_API_MODELS): # New api
+        if camera.product_model in DEVICEMGMT_API_MODELS:  # New api
             state_response: Dict[str, Any] = await self._get_iot_prop_devicemgmt(camera)
-            for propCategory in state_response['data']['capabilities']:
-                if propCategory['name'] == "camera":
-                    camera.motion = propCategory['properties']['motion-detect-recording']
-                if propCategory['name'] == "floodlight" or propCategory['name'] == "spotlight":
-                    camera.floodlight = propCategory['properties']['on']
-                if propCategory['name'] == "siren":
-                    camera.siren = propCategory['properties']['state']
-                if propCategory['name'] == "iot-device":
-                    camera.notify = propCategory['properties']['push-switch']
-                    camera.on = propCategory['properties']['iot-power']
-                    camera.available = propCategory['properties']['iot-state']
-
-        else: # All other cam types (old api?)
-            state_response: List[Tuple[PropertyIDs, Any]] = await self._get_property_list(camera)
+            for propCategory in state_response["data"]["capabilities"]:
+                if propCategory["name"] == "camera":
+                    camera.motion = propCategory["properties"][
+                        "motion-detect-recording"
+                    ]
+                if (
+                    propCategory["name"] == "floodlight"
+                    or propCategory["name"] == "spotlight"
+                ):
+                    camera.floodlight = propCategory["properties"]["on"]
+                if propCategory["name"] == "siren":
+                    camera.siren = propCategory["properties"]["state"]
+                if propCategory["name"] == "iot-device":
+                    camera.notify = propCategory["properties"]["push-switch"]
+                    camera.on = propCategory["properties"]["iot-power"]
+                    camera.available = propCategory["properties"]["iot-state"]
+
+        else:  # All other cam types (old api?)
+            state_response: List[
+                Tuple[PropertyIDs, Any]
+            ] = await self._get_property_list(camera)
             for property, value in state_response:
                 if property is PropertyIDs.AVAILABLE:
                     camera.available = value == "1"
@@ -80,7 +90,9 @@ class CameraService(BaseService):
                 if property is PropertyIDs.ACCESSORY:
                     camera.floodlight = value == "1"
                     if camera.device_params["dongle_product_model"] == "HL_CGDC":
-                        camera.garage = value == "1" # 1 = open, 2 = closed by automation or smart platform (Alexa, Google Home, Rules), 0 = closed by app
+                        camera.garage = (
+                            value == "1"
+                        )  # 1 = open, 2 = closed by automation or smart platform (Alexa, Google Home, Rules), 0 = closed by app
                 if property is PropertyIDs.NOTIFICATION:
                     camera.notify = value == "1"
                 if property is PropertyIDs.MOTION_DETECTION:
@@ -88,16 +100,28 @@ class CameraService(BaseService):
 
         return camera
 
-    async def register_for_updates(self, camera: Camera, callback: Callable[[Camera], None]):
+    async def register_for_updates(
+        self, camera: Camera, callback: Callable[[Camera], None]
+    ):
         loop = asyncio.get_event_loop()
         if not self._updater_thread:
-            self._updater_thread = Thread(target=self.update_worker, args=[loop, ], daemon=True)
+            self._updater_thread = Thread(
+                target=self.update_worker,
+                args=[
+                    loop,
+                ],
+                daemon=True,
+            )
             self._updater_thread.start()
 
         self._subscribers.append((camera, callback))
 
     async def deregister_for_updates(self, camera: Camera):
-        self._subscribers = [(cam, callback) for cam, callback in self._subscribers if cam.mac != camera.mac]
+        self._subscribers = [
+            (cam, callback)
+            for cam, callback in self._subscribers
+            if cam.mac != camera.mac
+        ]
 
     def update_worker(self, loop):
         while True:
@@ -106,9 +130,15 @@ class CameraService(BaseService):
             else:
                 for camera, callback in self._subscribers:
                     try:
-                        callback(asyncio.run_coroutine_threadsafe(self.update(camera), loop).result())
+                        callback(
+                            asyncio.run_coroutine_threadsafe(
+                                self.update(camera), loop
+                            ).result()
+                        )
                     except UnknownApiError as e:
-                        _LOGGER.warning(f"The update method detected an UnknownApiError: {e}")
+                        _LOGGER.warning(
+                            f"The update method detected an UnknownApiError: {e}"
+                        )
                     except ClientOSError as e:
                         _LOGGER.error(f"A network error was detected: {e}")
                     except ContentTypeError as e:
@@ -118,65 +148,121 @@ class CameraService(BaseService):
         if self._devices is None:
             self._devices = await self.get_object_list()
 
-        cameras = [device for device in self._devices if device.type is DeviceTypes.CAMERA]
+        cameras = [
+            device for device in self._devices if device.type is DeviceTypes.CAMERA
+        ]
 
         return [Camera(camera.raw_dict) for camera in cameras]
 
     async def turn_on(self, camera: Camera):
-        if (camera.product_model in DEVICEMGMT_API_MODELS): await self._run_action_devicemgmt(camera, "power", "wakeup") # Some camera models use a diffrent api
-        else: await self._run_action(camera, "power_on")
+        if camera.product_model in DEVICEMGMT_API_MODELS:
+            await self._run_action_devicemgmt(
+                camera, "power", "wakeup"
+            )  # Some camera models use a diffrent api
+        else:
+            await self._run_action(camera, "power_on")
 
     async def turn_off(self, camera: Camera):
-        if (camera.product_model in DEVICEMGMT_API_MODELS): await self._run_action_devicemgmt(camera, "power", "sleep") # Some camera models use a diffrent api
-        else: await self._run_action(camera, "power_off")
+        if camera.product_model in DEVICEMGMT_API_MODELS:
+            await self._run_action_devicemgmt(
+                camera, "power", "sleep"
+            )  # Some camera models use a diffrent api
+        else:
+            await self._run_action(camera, "power_off")
 
     async def siren_on(self, camera: Camera):
-        if (camera.product_model in DEVICEMGMT_API_MODELS): await self._run_action_devicemgmt(camera, "siren", "siren-on") # Some camera models use a diffrent api
-        else: await self._run_action(camera, "siren_on")
+        if camera.product_model in DEVICEMGMT_API_MODELS:
+            await self._run_action_devicemgmt(
+                camera, "siren", "siren-on"
+            )  # Some camera models use a diffrent api
+        else:
+            await self._run_action(camera, "siren_on")
 
     async def siren_off(self, camera: Camera):
-        if (camera.product_model in DEVICEMGMT_API_MODELS): await self._run_action_devicemgmt(camera, "siren", "siren-off") # Some camera models use a diffrent api
-        else: await self._run_action(camera, "siren_off")
+        if camera.product_model in DEVICEMGMT_API_MODELS:
+            await self._run_action_devicemgmt(
+                camera, "siren", "siren-off"
+            )  # Some camera models use a diffrent api
+        else:
+            await self._run_action(camera, "siren_off")
 
     # Also controls lamp socket and BCP spotlight
     async def floodlight_on(self, camera: Camera):
-        if (camera.product_model == "AN_RSCW"): await self._run_action_devicemgmt(camera, "spotlight", "1") # Battery cam pro integrated spotlight is controllable
-        elif (camera.product_model in DEVICEMGMT_API_MODELS): await self._run_action_devicemgmt(camera, "floodlight", "1") # Some camera models use a diffrent api
-        else: await self._set_property(camera, PropertyIDs.ACCESSORY.value, "1")
+        if camera.product_model == "AN_RSCW":
+            await self._run_action_devicemgmt(
+                camera, "spotlight", "1"
+            )  # Battery cam pro integrated spotlight is controllable
+        elif camera.product_model in DEVICEMGMT_API_MODELS:
+            await self._run_action_devicemgmt(
+                camera, "floodlight", "1"
+            )  # Some camera models use a diffrent api
+        else:
+            await self._set_property(camera, PropertyIDs.ACCESSORY.value, "1")
 
     # Also controls lamp socket and BCP spotlight
     async def floodlight_off(self, camera: Camera):
-        if (camera.product_model == "AN_RSCW"): await self._run_action_devicemgmt(camera, "spotlight", "0") # Battery cam pro integrated spotlight is controllable
-        elif (camera.product_model in DEVICEMGMT_API_MODELS): await self._run_action_devicemgmt(camera, "floodlight", "0") # Some camera models use a diffrent api
-        else: await self._set_property(camera, PropertyIDs.ACCESSORY.value, "2")
+        if camera.product_model == "AN_RSCW":
+            await self._run_action_devicemgmt(
+                camera, "spotlight", "0"
+            )  # Battery cam pro integrated spotlight is controllable
+        elif camera.product_model in DEVICEMGMT_API_MODELS:
+            await self._run_action_devicemgmt(
+                camera, "floodlight", "0"
+            )  # Some camera models use a diffrent api
+        else:
+            await self._set_property(camera, PropertyIDs.ACCESSORY.value, "2")
 
     # Garage door trigger uses run action on all models
     async def garage_door_open(self, camera: Camera):
         await self._run_action(camera, "garage_door_trigger")
-    
+
     async def garage_door_close(self, camera: Camera):
         await self._run_action(camera, "garage_door_trigger")
 
     async def turn_on_notifications(self, camera: Camera):
-        if (camera.product_model in DEVICEMGMT_API_MODELS): await self._set_toggle(camera, DeviceMgmtToggleProps.NOTIFICATION_TOGGLE.value, "1")
-        else: await self._set_property(camera, PropertyIDs.NOTIFICATION.value, "1")
+        if camera.product_model in DEVICEMGMT_API_MODELS:
+            await self._set_toggle(
+                camera, DeviceMgmtToggleProps.NOTIFICATION_TOGGLE.value, "1"
+            )
+        else:
+            await self._set_property(camera, PropertyIDs.NOTIFICATION.value, "1")
 
     async def turn_off_notifications(self, camera: Camera):
-        if (camera.product_model in DEVICEMGMT_API_MODELS): await self._set_toggle(camera, DeviceMgmtToggleProps.NOTIFICATION_TOGGLE.value, "0")
-        else: await self._set_property(camera, PropertyIDs.NOTIFICATION.value, "0")
+        if camera.product_model in DEVICEMGMT_API_MODELS:
+            await self._set_toggle(
+                camera, DeviceMgmtToggleProps.NOTIFICATION_TOGGLE.value, "0"
+            )
+        else:
+            await self._set_property(camera, PropertyIDs.NOTIFICATION.value, "0")
 
     # Both properties need to be set on newer cams, older cameras seem to only react
     # to the first property but it doesnt hurt to set both
     async def turn_on_motion_detection(self, camera: Camera):
-        if (camera.product_model in DEVICEMGMT_API_MODELS): await self._set_toggle(camera, DeviceMgmtToggleProps.EVENT_RECORDING_TOGGLE.value, "1")
-        elif (camera.product_model in ["WVOD1", "HL_WCO2"]): await self._set_property_list(camera, [create_pid_pair(PropertyIDs.WCO_MOTION_DETECTION, "1")])
+        if camera.product_model in DEVICEMGMT_API_MODELS:
+            await self._set_toggle(
+                camera, DeviceMgmtToggleProps.EVENT_RECORDING_TOGGLE.value, "1"
+            )
+        elif camera.product_model in ["WVOD1", "HL_WCO2"]:
+            await self._set_property_list(
+                camera, [create_pid_pair(PropertyIDs.WCO_MOTION_DETECTION, "1")]
+            )
         else:
             await self._set_property(camera, PropertyIDs.MOTION_DETECTION.value, "1")
-            await self._set_property(camera, PropertyIDs.MOTION_DETECTION_TOGGLE.value, "1")
+            await self._set_property(
+                camera, PropertyIDs.MOTION_DETECTION_TOGGLE.value, "1"
+            )
 
     async def turn_off_motion_detection(self, camera: Camera):
-        if (camera.product_model in DEVICEMGMT_API_MODELS): await self._set_toggle(camera, DeviceMgmtToggleProps.EVENT_RECORDING_TOGGLE.value, "0")
-        elif (camera.product_model in ["WVOD1", "HL_WCO2"]): await self._set_property_list(camera, [create_pid_pair(PropertyIDs.WCO_MOTION_DETECTION, "0")])
+        if camera.product_model in DEVICEMGMT_API_MODELS:
+            await self._set_toggle(
+                camera, DeviceMgmtToggleProps.EVENT_RECORDING_TOGGLE.value, "0"
+            )
+        elif camera.product_model in ["WVOD1", "HL_WCO2"]:
+            await self._set_property_list(
+                camera, [create_pid_pair(PropertyIDs.WCO_MOTION_DETECTION, "0")]
+            )
         else:
             await self._set_property(camera, PropertyIDs.MOTION_DETECTION.value, "0")
-            await self._set_property(camera, PropertyIDs.MOTION_DETECTION_TOGGLE.value, "0")
+            await self._set_property(
+                camera, PropertyIDs.MOTION_DETECTION_TOGGLE.value, "0"
+            )

wyzeapy/services/hms_service.py

@@ -11,16 +11,16 @@ from .base_service import BaseService
 
 
 class HMSMode(Enum):
-    CHANGING = 'changing'
-    DISARMED = 'disarm'
-    AWAY = 'away'
-    HOME = 'home'
+    CHANGING = "changing"
+    DISARMED = "disarm"
+    AWAY = "away"
+    HOME = "home"
 
 
 class HMSService(BaseService):
     async def update(self, hms_id: str):
         hms_mode = await self._monitoring_profile_state_status(hms_id)
-        return HMSMode(hms_mode['message'])
+        return HMSMode(hms_mode["message"])
 
     def __init__(self, auth_lib: WyzeAuthLib):
         super().__init__(auth_lib)
@@ -67,22 +67,13 @@ class HMSService(BaseService):
             return self._hms_id
 
         response = await self._get_plan_binding_list_by_user()
-        hms_subs = response['data']
+        hms_subs = response["data"]
 
         if len(hms_subs) >= 1:
             for sub in hms_subs:
-                if (devices := sub.get('deviceList')) is not None and len(devices) >= 1:
+                if (devices := sub.get("deviceList")) is not None and len(devices) >= 1:
                     for device in devices:
-                        self._hms_id = str(device['device_id'])
+                        self._hms_id = str(device["device_id"])
                         return self._hms_id
 
         return None
-
-
-
-
-
-
-
-
-