rytilahti / python-miio / 718

pending completion

Build # 718

Build Type

push

travis-ci

Committed by

rytilahti

Commit Message

<a href="https://github.com/rytilahti/python-miio/commit/<a class=hub.com/rytilahti/python-miio/commit/42e60354ad1abdaf85ea759d78dbc319a5ca24c3">42e60354a<a href="https://github.com/rytilahti/python-miio/commit/42e60354ad1abdaf85ea759d78dbc319a5ca24c3">&quot;&gt;Merge of the Chuangmi Plug V1, V2, V3 and M1 (#270)

* Chuangmi Plug V1 and V3 merged.

* Chuangmi V1 and V3 merge completed.

* Whitespace removed

* DummyDevice used in both cases

* Chuangmi Plug M1 merged.

* Missing blank line added.
Comma removed.

* Model parameter moved to the sub class.

* Missed line removed.

* Default model added.

* Deprecation warning added

* Test the device class via the deprecation layer

* Revert &amp;quot;Test the device class via the deprecation layer&quot;

This reverts commit </a><a class="double-link" href="https://github.com/rytilahti/python-miio/commit/<a class="double-link" href="https://github.com/rytilahti/python-miio/commit/7eb1443a5aa5fbb39d43560ebc20c67d928b6cf6">7eb1443a5</a>">7eb1443a5</a><a href="https://github.com/rytilahti/python-miio/commit/42e60354ad1abdaf85ea759d78dbc319a5ca24c3">.

* Provide a model per mDNS prefix

* Refactoring

* Missing parameter added

* Default model added

* More compact imports

* Deprecated decorator used

* Update chuangmi_plug.py

remvoe unused warnings.

Run Details

231 of 231 new or added lines in 4 files covered. (100.0%)

2936 of 4265 relevant lines covered (68.84%)

1.38 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.31

/miio/chuangmi_plug.py

import logging
from typing import Dict, Any, Optional
from collections import defaultdict
from .device import Device
from .utils import deprecated

_LOGGER = logging.getLogger(__name__)

MODEL_CHUANGMI_PLUG_V3 = 'chuangmi.plug.v3'
MODEL_CHUANGMI_PLUG_V1 = 'chuangmi.plug.v1'
MODEL_CHUANGMI_PLUG_M1 = 'chuangmi.plug.m1'
MODEL_CHUANGMI_PLUG_V2 = 'chuangmi.plug.v2'

AVAILABLE_PROPERTIES = {
    MODEL_CHUANGMI_PLUG_V1: ['on', 'usb_on', 'temperature'],
    MODEL_CHUANGMI_PLUG_V3: ['on', 'usb_on', 'temperature', 'wifi_led'],
    MODEL_CHUANGMI_PLUG_M1: ['power', 'temperature'],
    MODEL_CHUANGMI_PLUG_V2: ['power', 'temperature'],
}


class ChuangmiPlugStatus:
    """Container for status reports from the plug."""

    def __init__(self, data: Dict[str, Any]) -> None:
        """
        Response of a Chuangmi Plug V1 (chuangmi.plug.v1)
        { 'power': True, 'usb_on': True, 'temperature': 32 }

        Response of a Chuangmi Plug V3 (chuangmi.plug.v3):
        { 'on': True, 'usb_on': True, 'temperature': 32, 'wifi_led': True }
        """
        self.data = data

    @property
    def power(self) -> bool:
        """Current power state."""
        if "on" in self.data:
            return self.data["on"]
        if "power" in self.data:
            return self.data["power"] == 'on'

    @property
    def is_on(self) -> bool:
        """True if device is on."""
        return self.power

    @property
    def temperature(self) -> int:
        return self.data["temperature"]

    @property
    def usb_power(self) -> Optional[bool]:
        """True if USB is on."""
        if "usb_on" in self.data and self.data["usb_on"] is not None:
            return self.data["usb_on"]
        return None

    @property
    def load_power(self) -> Optional[int]:
        """Current power load, if available."""
        if "load_power" in self.data and self.data["load_power"] is not None:
            return self.data["load_power"]
        return None

    @property
    def wifi_led(self) -> Optional[bool]:
        """True if the wifi led is turned on."""
        if "wifi_led" in self.data and self.data["wifi_led"] is not None:
            return self.data["wifi_led"] == "on"
        return None

    def __repr__(self) -> str:
        s = "<ChuangmiPlugStatus " \
            "power=%s, " \
            "usb_power=%s, " \
            "temperature=%s" \
            "load_power=%s, " \
            "wifi_led=%s>" % \
            (self.power,
             self.usb_power,
             self.temperature,
             self.load_power,
             self.wifi_led)
        return s


class ChuangmiPlug(Device):
    """Main class representing the Chuangmi Plug V1 and V3."""

    def __init__(self, ip: str = None, token: str = None, start_id: int = 0,
                 debug: int = 0, lazy_discover: bool = True,
                 model: str = MODEL_CHUANGMI_PLUG_M1) -> None:
        super().__init__(ip, token, start_id, debug, lazy_discover)

        if model in AVAILABLE_PROPERTIES:
            self.model = model
        else:
            self.model = MODEL_CHUANGMI_PLUG_M1

    def status(self) -> ChuangmiPlugStatus:
        """Retrieve properties."""
        properties = AVAILABLE_PROPERTIES[self.model]
        values = self.send(
            "get_prop",
            properties
        )

        properties_count = len(properties)
        values_count = len(values)
        if properties_count != values_count:
            _LOGGER.debug(
                "Count (%s) of requested properties does not match the "
                "count (%s) of received values.",
                properties_count, values_count)

        if self.model == MODEL_CHUANGMI_PLUG_V3:
            load_power = self.send("get_power", [])  # Response: [300]
            if len(load_power) == 1:
                properties.append('load_power')
                values.append(load_power[0])

        return ChuangmiPlugStatus(
            defaultdict(lambda: None, zip(properties, values)))

    def on(self):
        """Power on."""
        if self.model == MODEL_CHUANGMI_PLUG_V1:
            return self.send("set_on", [])

        return self.send("set_power", ["on"])

    def off(self):
        """Power off."""
        if self.model == MODEL_CHUANGMI_PLUG_V1:
            return self.send("set_off", [])

        return self.send("set_power", ["off"])

    def usb_on(self):
        """Power on."""
        return self.send("set_usb_on", [])

    def usb_off(self):
        """Power off."""
        return self.send("set_usb_off", [])

    def set_wifi_led(self, led: bool):
        """Set the wifi led on/off."""
        if led:
            return self.send("set_wifi_led", ["on"])
        else:
            return self.send("set_wifi_led", ["off"])


@deprecated("This device class is deprecated. Please use the ChuangmiPlug "
            "class in future and select a model by parameter 'model'.")
class Plug(ChuangmiPlug):
    def __init__(self, ip: str = None, token: str = None, start_id: int = 0,
                 debug: int = 0, lazy_discover: bool = True) -> None:
        super().__init__(ip, token, start_id, debug, lazy_discover,
                         model=MODEL_CHUANGMI_PLUG_M1)


@deprecated("This device class is deprecated. Please use the ChuangmiPlug "
            "class in future and select a model by parameter 'model'.")
class PlugV1(ChuangmiPlug):
    def __init__(self, ip: str = None, token: str = None, start_id: int = 0,
                 debug: int = 0, lazy_discover: bool = True) -> None:
        super().__init__(ip, token, start_id, debug, lazy_discover,
                         model=MODEL_CHUANGMI_PLUG_V1)


@deprecated("This device class is deprecated. Please use the ChuangmiPlug "
            "class in future and select a model by parameter 'model'.")
class PlugV3(ChuangmiPlug):
    def __init__(self, ip: str = None, token: str = None, start_id: int = 0,
                 debug: int = 0, lazy_discover: bool = True) -> None:
        super().__init__(ip, token, start_id, debug, lazy_discover,
                         model=MODEL_CHUANGMI_PLUG_V3)

1	import logging	2✔
2	from typing import Dict, Any, Optional	2✔
3	from collections import defaultdict	2✔
4	from .device import Device	2✔
5	from .utils import deprecated	2✔
6
7	_LOGGER = logging.getLogger(__name__)	2✔
8
9	MODEL_CHUANGMI_PLUG_V3 = 'chuangmi.plug.v3'	2✔
10	MODEL_CHUANGMI_PLUG_V1 = 'chuangmi.plug.v1'	2✔
11	MODEL_CHUANGMI_PLUG_M1 = 'chuangmi.plug.m1'	2✔
12	MODEL_CHUANGMI_PLUG_V2 = 'chuangmi.plug.v2'	2✔
13
14	AVAILABLE_PROPERTIES = {	2✔
15	MODEL_CHUANGMI_PLUG_V1: ['on', 'usb_on', 'temperature'],
16	MODEL_CHUANGMI_PLUG_V3: ['on', 'usb_on', 'temperature', 'wifi_led'],
17	MODEL_CHUANGMI_PLUG_M1: ['power', 'temperature'],
18	MODEL_CHUANGMI_PLUG_V2: ['power', 'temperature'],
19	}
20
21
22	class ChuangmiPlugStatus:	2✔
23	"""Container for status reports from the plug."""
24
25	def __init__(self, data: Dict[str, Any]) -> None:	2✔
26	"""
27	Response of a Chuangmi Plug V1 (chuangmi.plug.v1)
28	{ 'power': True, 'usb_on': True, 'temperature': 32 }
29
30	Response of a Chuangmi Plug V3 (chuangmi.plug.v3):
31	{ 'on': True, 'usb_on': True, 'temperature': 32, 'wifi_led': True }
32	"""
33	self.data = data	2✔
34
35	@property	2✔
36	def power(self) -> bool:	2✔
37	"""Current power state."""
38	if "on" in self.data:	2✔
39	return self.data["on"]	2✔
40	if "power" in self.data:	2✔
41	return self.data["power"] == 'on'	2✔
42
43	@property	2✔
44	def is_on(self) -> bool:	2✔
45	"""True if device is on."""
46	return self.power	2✔
47
48	@property	2✔
49	def temperature(self) -> int:	2✔
50	return self.data["temperature"]	2✔
51
52	@property	2✔
53	def usb_power(self) -> Optional[bool]:	2✔
54	"""True if USB is on."""
55	if "usb_on" in self.data and self.data["usb_on"] is not None:	2✔
56	return self.data["usb_on"]	2✔
57	return None	2✔
58
59	@property	2✔
60	def load_power(self) -> Optional[int]:	2✔
61	"""Current power load, if available."""
62	if "load_power" in self.data and self.data["load_power"] is not None:	2✔
63	return self.data["load_power"]	2✔
64	return None	2✔
65
66	@property	2✔
67	def wifi_led(self) -> Optional[bool]:	2✔
68	"""True if the wifi led is turned on."""
69	if "wifi_led" in self.data and self.data["wifi_led"] is not None:	2✔
70	return self.data["wifi_led"] == "on"	2✔
71	return None	2✔
72
73	def __repr__(self) -> str:	2✔
74	s = "<ChuangmiPlugStatus " \	2✔
75	"power=%s, " \
76	"usb_power=%s, " \
77	"temperature=%s" \
78	"load_power=%s, " \
79	"wifi_led=%s>" % \
80	(self.power,
81	self.usb_power,
82	self.temperature,
83	self.load_power,
84	self.wifi_led)
85	return s	2✔
86
87
88	class ChuangmiPlug(Device):	2✔
89	"""Main class representing the Chuangmi Plug V1 and V3."""
90
91	def __init__(self, ip: str = None, token: str = None, start_id: int = 0,	2✔
92	debug: int = 0, lazy_discover: bool = True,
93	model: str = MODEL_CHUANGMI_PLUG_M1) -> None:
94	super().__init__(ip, token, start_id, debug, lazy_discover)	×
95
96	if model in AVAILABLE_PROPERTIES:	×
97	self.model = model	×
98	else:
99	self.model = MODEL_CHUANGMI_PLUG_M1	×
100
101	def status(self) -> ChuangmiPlugStatus:	2✔
102	"""Retrieve properties."""
103	properties = AVAILABLE_PROPERTIES[self.model]	2✔
104	values = self.send(	2✔
105	"get_prop",
106	properties
107	)
108
109	properties_count = len(properties)	2✔
110	values_count = len(values)	2✔
111	if properties_count != values_count:	2✔
112	_LOGGER.debug(	2✔
113	"Count (%s) of requested properties does not match the "
114	"count (%s) of received values.",
115	properties_count, values_count)
116
117	if self.model == MODEL_CHUANGMI_PLUG_V3:	2✔
118	load_power = self.send("get_power", []) # Response: [300]	2✔
119	if len(load_power) == 1:	2✔
120	properties.append('load_power')	2✔
121	values.append(load_power[0])	2✔
122
123	return ChuangmiPlugStatus(	2✔
124	defaultdict(lambda: None, zip(properties, values)))
125
126	def on(self):	2✔
127	"""Power on."""
128	if self.model == MODEL_CHUANGMI_PLUG_V1:	2✔
129	return self.send("set_on", [])	2✔
130
131	return self.send("set_power", ["on"])	2✔
132
133	def off(self):	2✔
134	"""Power off."""
135	if self.model == MODEL_CHUANGMI_PLUG_V1:	2✔
136	return self.send("set_off", [])	2✔
137
138	return self.send("set_power", ["off"])	2✔
139
140	def usb_on(self):	2✔
141	"""Power on."""
142	return self.send("set_usb_on", [])	2✔
143
144	def usb_off(self):	2✔
145	"""Power off."""
146	return self.send("set_usb_off", [])	2✔
147
148	def set_wifi_led(self, led: bool):	2✔
149	"""Set the wifi led on/off."""
150	if led:	2✔
151	return self.send("set_wifi_led", ["on"])	2✔
152	else:
153	return self.send("set_wifi_led", ["off"])	2✔
154
155
156	@deprecated("This device class is deprecated. Please use the ChuangmiPlug "	2✔
157	"class in future and select a model by parameter 'model'.")
158	class Plug(ChuangmiPlug):	2✔
159	def __init__(self, ip: str = None, token: str = None, start_id: int = 0,	2✔
160	debug: int = 0, lazy_discover: bool = True) -> None:
161	super().__init__(ip, token, start_id, debug, lazy_discover,	×
162	model=MODEL_CHUANGMI_PLUG_M1)
163
164
165	@deprecated("This device class is deprecated. Please use the ChuangmiPlug "	2✔
166	"class in future and select a model by parameter 'model'.")
167	class PlugV1(ChuangmiPlug):	2✔
168	def __init__(self, ip: str = None, token: str = None, start_id: int = 0,	2✔
169	debug: int = 0, lazy_discover: bool = True) -> None:
170	super().__init__(ip, token, start_id, debug, lazy_discover,	×
171	model=MODEL_CHUANGMI_PLUG_V1)
172
173
174	@deprecated("This device class is deprecated. Please use the ChuangmiPlug "	2✔
175	"class in future and select a model by parameter 'model'.")
176	class PlugV3(ChuangmiPlug):	2✔
177	def __init__(self, ip: str = None, token: str = None, start_id: int = 0,	2✔
178	debug: int = 0, lazy_discover: bool = True) -> None:
179	super().__init__(ip, token, start_id, debug, lazy_discover,	×
180	model=MODEL_CHUANGMI_PLUG_V3)

rytilahti / python-miio / 718

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous