1483

pending completion

Build # 1483

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/0352b52e14cf946c1090334b38df2779e44a86bc">0352b52e1<a href="https://github.com/rytilahti/python-miio/commit/0352b52e14cf946c1090334b38df2779e44a86bc">&quot;&gt;Revert &amp;quot;Extend viomi vacuum support&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/770baa43b2e0c2681ae4ded632a6ab7c4da2f4f0">770baa43b</a>">770baa43b</a><a href="https://github.com/rytilahti/python-miio/commit/0352b52e14cf946c1090334b38df2779e44a86bc">.

Run Details

519 of 880 branches covered (58.98%)

Branch coverage included in aggregate %.

12 of 12 new or added lines in 1 file covered. (100.0%)

3635 of 4750 relevant lines covered (76.53%)

1.53 hits per line

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

69.23

/miio/viomivacuum.py

import logging
import time
from collections import defaultdict
from datetime import timedelta
from enum import Enum

import click

from .click_common import EnumType, command, format_output
from .device import Device
from .utils import pretty_seconds
from .vacuumcontainers import DNDStatus

_LOGGER = logging.getLogger(__name__)


class ViomiVacuumSpeed(Enum):
    Silent = 0
    Standard = 1
    Medium = 2
    Turbo = 3


class ViomiVacuumState(Enum):
    IdleNotDocked = 0
    Idle = 1
    Idle2 = 2
    Cleaning = 3
    Returning = 4
    Docked = 5


class ViomiMopMode(Enum):
    Off = 0  # No Mop, Vacuum only
    Mixed = 1
    MopOnly = 2


class ViomiLanguage(Enum):
    CN = 1  # Chinese (default)
    EN = 2  # English


class ViomiLedState(Enum):
    Off = 0
    On = 1


class ViomiCarpetTurbo(Enum):
    Off = 0
    Medium = 1
    Turbo = 2


class ViomiMovementDirection(Enum):
    Forward = 1
    Left = 2  # Rotate
    Right = 3  # Rotate
    Backward = 4
    Stop = 5
    # 10 is unknown


class ViomiVacuumStatus:
    def __init__(self, data):
        # ["run_state","mode","err_state","battary_life","box_type","mop_type","s_time","s_area",
        # [ 5,          0,     2103,       85,            3,         1,         0,       0,
        # "suction_grade","water_grade","remember_map","has_map","is_mop","has_newmap"]'
        # 1,               11,           1,            1,         1,       0          ]
        self.data = data

    @property
    def state(self):
        """State of the vacuum."""
        return ViomiVacuumState(self.data["run_state"])

    @property
    def is_on(self) -> bool:
        """True if cleaning."""
        return self.state == ViomiVacuumState.Cleaning

    @property
    def mode(self):
        """Active mode.

        TODO: unknown values
        """
        return self.data["mode"]

    @property
    def error(self):
        """Error code.

        TODO: unknown values
        """
        return self.data["error_state"]

    @property
    def battery(self) -> int:
        """Battery in percentage."""
        return self.data["battary_life"]

    @property
    def box_type(self):
        """Box type.

        TODO: unknown values"""
        return self.data["box_type"]

    @property
    def mop_type(self):
        """Mop type.

        TODO: unknown values"""
        return self.data["mop_type"]

    @property
    def clean_time(self) -> timedelta:
        """Cleaning time."""
        return pretty_seconds(self.data["s_time"])

    @property
    def clean_area(self) -> float:
        """Cleaned area.

        TODO: unknown values
        """
        return self.data["s_area"]

    @property
    def fanspeed(self) -> ViomiVacuumSpeed:
        """Current fan speed."""
        return ViomiVacuumSpeed(self.data["suction_grade"])

    @property
    def water_level(self):
        """Tank's water level.

        TODO: unknown values, percentage?
        """
        return self.data["water_grade"]

    @property
    def remember_map(self) -> bool:
        """True to remember the map."""
        return bool(self.data["remember_map"])

    @property
    def has_map(self) -> bool:
        """True if device has map?"""
        return bool(self.data["has_map"])

    @property
    def has_new_map(self) -> bool:
        """TODO: unknown"""
        return bool(self.data["has_newmap"])

    @property
    def mop_mode(self) -> ViomiMopMode:
        """Whether mopping is enabled and if so which mode"""
        return ViomiMopMode(self.data["is_mop"])


class ViomiVacuum(Device):
    """Interface for Viomi vacuums (viomi.vacuum.v7)."""

    @command(
        default_output=format_output(
            "",
            "State: {result.state}\n"
            "Mode: {result.mode}\n"
            "Error: {result.error}\n"
            "Battery: {result.battery}\n"
            "Fan speed: {result.fanspeed}\n"
            "Box type: {result.box_type}\n"
            "Mop type: {result.mop_type}\n"
            "Clean time: {result.clean_time}\n"
            "Clean area: {result.clean_area}\n"
            "Water level: {result.water_level}\n"
            "Remember map: {result.remember_map}\n"
            "Has map: {result.has_map}\n"
            "Has new map: {result.has_new_map}\n"
            "Mop mode: {result.mop_mode}\n",
        )
    )
    def status(self) -> ViomiVacuumStatus:
        """Retrieve properties."""
        properties = [
            "run_state",
            "mode",
            "err_state",
            "battary_life",
            "box_type",
            "mop_type",
            "s_time",
            "s_area",
            "suction_grade",
            "water_grade",
            "remember_map",
            "has_map",
            "is_mop",
            "has_newmap",
        ]

        values = self.send("get_prop", properties)

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

    @command()
    def start(self):
        """Start cleaning."""
        # TODO figure out the parameters
        self.send("set_mode_withroom", [0, 1, 0])

    @command()
    def stop(self):
        """Stop cleaning."""
        self.send("set_mode", [0])

    @command()
    def pause(self):
        """Pause cleaning."""
        self.send("set_mode_withroom", [0, 2, 0])

    @command(click.argument("speed", type=EnumType(ViomiVacuumSpeed, False)))
    def set_fan_speed(self, speed: ViomiVacuumSpeed):
        """Set fanspeed [silent, standard, medium, turbo]."""
        self.send("set_suction", [speed.value])

    @command()
    def home(self):
        """Return to home."""
        self.send("set_charge", [1])

    @command(
        click.argument("direction", type=EnumType(ViomiMovementDirection, False)),
        click.option(
            "--duration",
            type=float,
            default=0.5,
            help="number of seconds to perform this movement",
        ),
    )
    def move(self, direction, duration=0.5):
        """Manual movement."""
        start = time.time()
        while time.time() - start < duration:
            self.send("set_direction", [direction.value])
            time.sleep(0.1)
        self.send("set_direction", [ViomiMovementDirection.Stop.value])

    @command(click.argument("mode", type=EnumType(ViomiMopMode, False)))
    def mop_mode(self, mode):
        """Set mopping mode."""
        self.send("set_mop", [mode.value])

    @command()
    def dnd_status(self):
        """Returns do-not-disturb status."""
        status = self.send("get_notdisturb")
        return DNDStatus(
            dict(
                enabled=status[0],
                start_hour=status[1],
                start_minute=status[2],
                end_hour=status[3],
                end_minute=status[4],
            )
        )

    @command(
        click.option("--disable", is_flag=True),
        click.argument("start_hr", type=int),
        click.argument("start_min", type=int),
        click.argument("end_hr", type=int),
        click.argument("end_min", type=int),
    )
    def set_dnd(
        self, disable: bool, start_hr: int, start_min: int, end_hr: int, end_min: int
    ):
        """Set do-not-disturb.

        :param int start_hr: Start hour
        :param int start_min: Start minute
        :param int end_hr: End hour
        :param int end_min: End minute"""
        return self.send(
            "set_notdisturb",
            [0 if disable else 1, start_hr, start_min, end_hr, end_min],
        )

    @command(click.argument("language", type=EnumType(ViomiLanguage, False)))
    def set_language(self, language: ViomiLanguage):
        """Set the device's audio language."""
        return self.send("set_language", [language.value])

    @command(click.argument("state", type=EnumType(ViomiLedState, False)))
    def led(self, state: ViomiLedState):
        """Switch the button leds on or off."""
        return self.send("set_light", [state.value])

    @command(click.argument("mode", type=EnumType(ViomiCarpetTurbo)))
    def carpet_mode(self, mode: ViomiCarpetTurbo):
        """Set the carpet mode."""
        return self.send("set_carpetturbo", [mode.value])

1	import logging	2✔
2	import time	2✔
3	from collections import defaultdict	2✔
4	from datetime import timedelta	2✔
5	from enum import Enum	2✔
6
7	import click	2✔
8
9	from .click_common import EnumType, command, format_output	2✔
10	from .device import Device	2✔
11	from .utils import pretty_seconds	2✔
12	from .vacuumcontainers import DNDStatus	2✔
13
14	_LOGGER = logging.getLogger(__name__)	2✔
15
16
17	class ViomiVacuumSpeed(Enum):	2✔
18	Silent = 0	2✔
19	Standard = 1	2✔
20	Medium = 2	2✔
21	Turbo = 3	2✔
22
23
24	class ViomiVacuumState(Enum):	2✔
25	IdleNotDocked = 0	2✔
26	Idle = 1	2✔
27	Idle2 = 2	2✔
28	Cleaning = 3	2✔
29	Returning = 4	2✔
30	Docked = 5	2✔
31
32
33	class ViomiMopMode(Enum):	2✔
34	Off = 0 # No Mop, Vacuum only	2✔
35	Mixed = 1	2✔
36	MopOnly = 2	2✔
37
38
39	class ViomiLanguage(Enum):	2✔
40	CN = 1 # Chinese (default)	2✔
41	EN = 2 # English	2✔
42
43
44	class ViomiLedState(Enum):	2✔
45	Off = 0	2✔
46	On = 1	2✔
47
48
49	class ViomiCarpetTurbo(Enum):	2✔
50	Off = 0	2✔
51	Medium = 1	2✔
52	Turbo = 2	2✔
53
54
55	class ViomiMovementDirection(Enum):	2✔
56	Forward = 1	2✔
57	Left = 2 # Rotate	2✔
58	Right = 3 # Rotate	2✔
59	Backward = 4	2✔
60	Stop = 5	2✔
61	# 10 is unknown
62
63
64	class ViomiVacuumStatus:	2✔
65	def __init__(self, data):	2✔
66	# ["run_state","mode","err_state","battary_life","box_type","mop_type","s_time","s_area",
67	# [ 5, 0, 2103, 85, 3, 1, 0, 0,
68	# "suction_grade","water_grade","remember_map","has_map","is_mop","has_newmap"]'
69	# 1, 11, 1, 1, 1, 0 ]
70	self.data = data	×
71
72	@property	2✔
73	def state(self):
74	"""State of the vacuum."""
75	return ViomiVacuumState(self.data["run_state"])	×
76
77	@property	2✔
78	def is_on(self) -> bool:	2✔
79	"""True if cleaning."""
80	return self.state == ViomiVacuumState.Cleaning	×
81
82	@property	2✔
83	def mode(self):
84	"""Active mode.
85
86	TODO: unknown values
87	"""
88	return self.data["mode"]	×
89
90	@property	2✔
91	def error(self):
92	"""Error code.
93
94	TODO: unknown values
95	"""
96	return self.data["error_state"]	×
97
98	@property	2✔
99	def battery(self) -> int:	2✔
100	"""Battery in percentage."""
101	return self.data["battary_life"]	×
102
103	@property	2✔
104	def box_type(self):
105	"""Box type.
106
107	TODO: unknown values"""
108	return self.data["box_type"]	×
109
110	@property	2✔
111	def mop_type(self):
112	"""Mop type.
113
114	TODO: unknown values"""
115	return self.data["mop_type"]	×
116
117	@property	2✔
118	def clean_time(self) -> timedelta:	2✔
119	"""Cleaning time."""
120	return pretty_seconds(self.data["s_time"])	×
121
122	@property	2✔
123	def clean_area(self) -> float:	2✔
124	"""Cleaned area.
125
126	TODO: unknown values
127	"""
128	return self.data["s_area"]	×
129
130	@property	2✔
131	def fanspeed(self) -> ViomiVacuumSpeed:	2✔
132	"""Current fan speed."""
133	return ViomiVacuumSpeed(self.data["suction_grade"])	×
134
135	@property	2✔
136	def water_level(self):
137	"""Tank's water level.
138
139	TODO: unknown values, percentage?
140	"""
141	return self.data["water_grade"]	×
142
143	@property	2✔
144	def remember_map(self) -> bool:	2✔
145	"""True to remember the map."""
146	return bool(self.data["remember_map"])	×
147
148	@property	2✔
149	def has_map(self) -> bool:	2✔
150	"""True if device has map?"""
151	return bool(self.data["has_map"])	×
152
153	@property	2✔
154	def has_new_map(self) -> bool:	2✔
155	"""TODO: unknown"""
156	return bool(self.data["has_newmap"])	×
157
158	@property	2✔
159	def mop_mode(self) -> ViomiMopMode:	2✔
160	"""Whether mopping is enabled and if so which mode"""
161	return ViomiMopMode(self.data["is_mop"])	×
162
163
164	class ViomiVacuum(Device):	2✔
165	"""Interface for Viomi vacuums (viomi.vacuum.v7)."""
166
167	@command(	2✔
168	default_output=format_output(
169	"",
170	"State: {result.state}\n"
171	"Mode: {result.mode}\n"
172	"Error: {result.error}\n"
173	"Battery: {result.battery}\n"
174	"Fan speed: {result.fanspeed}\n"
175	"Box type: {result.box_type}\n"
176	"Mop type: {result.mop_type}\n"
177	"Clean time: {result.clean_time}\n"
178	"Clean area: {result.clean_area}\n"
179	"Water level: {result.water_level}\n"
180	"Remember map: {result.remember_map}\n"
181	"Has map: {result.has_map}\n"
182	"Has new map: {result.has_new_map}\n"
183	"Mop mode: {result.mop_mode}\n",
184	)
185	)
186	def status(self) -> ViomiVacuumStatus:	2✔
187	"""Retrieve properties."""
188	properties = [	×
189	"run_state",
190	"mode",
191	"err_state",
192	"battary_life",
193	"box_type",
194	"mop_type",
195	"s_time",
196	"s_area",
197	"suction_grade",
198	"water_grade",
199	"remember_map",
200	"has_map",
201	"is_mop",
202	"has_newmap",
203	]
204
205	values = self.send("get_prop", properties)	×
206
207	return ViomiVacuumStatus(defaultdict(lambda: None, zip(properties, values)))	×
208
209	@command()	2✔
210	def start(self):
211	"""Start cleaning."""
212	# TODO figure out the parameters
213	self.send("set_mode_withroom", [0, 1, 0])	×
214
215	@command()	2✔
216	def stop(self):
217	"""Stop cleaning."""
218	self.send("set_mode", [0])	×
219
220	@command()	2✔
221	def pause(self):
222	"""Pause cleaning."""
223	self.send("set_mode_withroom", [0, 2, 0])	×
224
225	@command(click.argument("speed", type=EnumType(ViomiVacuumSpeed, False)))	2✔
226	def set_fan_speed(self, speed: ViomiVacuumSpeed):	2✔
227	"""Set fanspeed [silent, standard, medium, turbo]."""
228	self.send("set_suction", [speed.value])	×
229
230	@command()	2✔
231	def home(self):
232	"""Return to home."""
233	self.send("set_charge", [1])	×
234
235	@command(	2✔
236	click.argument("direction", type=EnumType(ViomiMovementDirection, False)),
237	click.option(
238	"--duration",
239	type=float,
240	default=0.5,
241	help="number of seconds to perform this movement",
242	),
243	)
244	def move(self, direction, duration=0.5):	2✔
245	"""Manual movement."""
246	start = time.time()	×
247	while time.time() - start < duration:	×
248	self.send("set_direction", [direction.value])	×
249	time.sleep(0.1)	×
250	self.send("set_direction", [ViomiMovementDirection.Stop.value])	×
251
252	@command(click.argument("mode", type=EnumType(ViomiMopMode, False)))	2✔
253	def mop_mode(self, mode):
254	"""Set mopping mode."""
255	self.send("set_mop", [mode.value])	×
256
257	@command()	2✔
258	def dnd_status(self):
259	"""Returns do-not-disturb status."""
260	status = self.send("get_notdisturb")	×
261	return DNDStatus(	×
262	dict(
263	enabled=status[0],
264	start_hour=status[1],
265	start_minute=status[2],
266	end_hour=status[3],
267	end_minute=status[4],
268	)
269	)
270
271	@command(	2✔
272	click.option("--disable", is_flag=True),
273	click.argument("start_hr", type=int),
274	click.argument("start_min", type=int),
275	click.argument("end_hr", type=int),
276	click.argument("end_min", type=int),
277	)
278	def set_dnd(	2✔
279	self, disable: bool, start_hr: int, start_min: int, end_hr: int, end_min: int
280	):
281	"""Set do-not-disturb.
282
283	:param int start_hr: Start hour
284	:param int start_min: Start minute
285	:param int end_hr: End hour
286	:param int end_min: End minute"""
287	return self.send(	×
288	"set_notdisturb",
289	[0 if disable else 1, start_hr, start_min, end_hr, end_min],
290	)
291
292	@command(click.argument("language", type=EnumType(ViomiLanguage, False)))	2✔
293	def set_language(self, language: ViomiLanguage):	2✔
294	"""Set the device's audio language."""
295	return self.send("set_language", [language.value])	×
296
297	@command(click.argument("state", type=EnumType(ViomiLedState, False)))	2✔
298	def led(self, state: ViomiLedState):	2✔
299	"""Switch the button leds on or off."""
300	return self.send("set_light", [state.value])	×
301
302	@command(click.argument("mode", type=EnumType(ViomiCarpetTurbo)))	2✔
303	def carpet_mode(self, mode: ViomiCarpetTurbo):	2✔
304	"""Set the carpet mode."""
305	return self.send("set_carpetturbo", [mode.value])	×

rytilahti / python-miio / 1483

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