1732

pending completion

Build # 1732

Build Type

cron

travis-ci-com

Committed by

web-flow

Commit Message

Merge pull request #454 from stanford-oval/wip/fix-temp-unit

io.home-assistant: convert sensor values to the thingtalk units

Run Details

497 of 1548 branches covered (32.11%)

Branch coverage included in aggregate %.

6 of 35 new or added lines in 2 files covered. (17.14%)

24 existing lines in 2 files now uncovered.

1379 of 3171 relevant lines covered (43.49%)

28.25 hits per line

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

25.42

/main/io.home-assistant/sensor.js

// -*- mode: js; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of io.home-assistant
//
// Copyright 2019 Xiaomeng Jin <tracyjxm@stanford.edu>
//
// See LICENSE for details
"use strict";

const Units = require('thingtalk-units');

const HomeAssistantDevice = require('./base');

function adjustUnit(value, fromUnit) {
    switch (fromUnit) {

    // first the units were we use the same name
    case 'K':
    case 'ms':
    case 's':
    case 'min':
    case 'h':
    // XXX month and meter both use the same unit!
    case 'm':
    case 'mm':
    case 'cm':
    case 'km':
    case 'in':
    case 'ft':
    case 'mi':
    case 'gal':
    case 'g':
    case 'mg':
    case 'kg':
    case 'oz':
    case 'lb':
    case 'lx':
    case 'mph':
    case 'dB':
    case 'dBm':
    case 'KiB':
    case 'MiB':
    case 'GiB':
    case 'TiB':
        return Units.transformToBaseUnit(value, fromUnit);

    // units that we support with a different name
    case '°F':
        return Units.transformToBaseUnit(value, 'F');
    case 'd':
        return Units.transformToBaseUnit(value, 'day');
    case 'L':
    case 'mL':
        return Units.transformToBaseUnit(value, fromUnit.toLowerCase());
    case 'm³':
        return Units.transformToBaseUnit(value, 'm3');
    case 'ft³':
        return Units.transformToBaseUnit(value, 'ft3');
    case 'fl. oz.':
        return Units.transformToBaseUnit(value, 'floz');
    case 'm²':
        return Units.transformToBaseUnit(value, 'm2');
    case 'm/s':
        return Units.transformToBaseUnit(value, 'mps');
    case 'km/h':
        return Units.transformToBaseUnit(value, 'kmph');
    case 'B':
        return Units.transformToBaseUnit(value, 'byte');
    case 'kB':
        return Units.transformToBaseUnit(value, 'KB');

    // TODO move to thingtalk-units
    case 'μs':
        return value/1000;//base unit is ms
    case 'µg':
        return value/(1000 * 1000 * 1000); //base unit is kg
    case 'yd':
        return value*0.9144;//base unit is m
    case 'mm/d':
        return value/1000 / 86400;//base unit is mps
    case 'in/d':
        return Units.transformToBaseUnit(value/86400, 'in');//base unit is mps
    case 'in/h':
        return Units.transformToBaseUnit(value/3600, 'in');//base unit is mps
    case 'bit':
        return value/8;//base unit is byte
    case 'kbit':
        return value/8*1000;
    case 'Mbit':
        return value/8*1000000;
    case 'Gbit':
        return value/8*1000000000;
    case 'PB':
        return value*1e15;
    case 'EB':
        return value*1e18;
    case 'ZB':
        return value*1e21;
    case 'YB':
        return value*1e24;
    case 'PiB':
        return value*(1024**5);
    case 'EiB':
        return value*(1024**6);
    case 'ZiB':
        return value*(1024**7);
    case 'YiB':
        return value*(1024**8);

    case 'Hz':
    case 'GHz':
    case 'm³/h':
    case 'ft³/m':
    case 'µS/cm':
    case 'W/m²':
    case 'mm/h':
    case 'µg/m³':
    case 'mg/m³':
    case 'p/m³':
    case 'ppm':
    case 'ppb':
    case 'bit/s':
    case 'kbit/s':
    case 'Mbit/s':
    case 'Gbit/s':
    case 'B/s':
    case 'kB/s':
    case 'MB/s':
    case 'GB/s':
    case 'KiB/s':
    case 'MiB/s':
    case 'GiB/s':
        // TODO add these units

    default:
        return value;
    }
}

module.exports = class HomeAssistantSensor extends HomeAssistantDevice {
    constructor(engine, state, master, entityId) {
        super(engine, state, master, entityId);
        const [domain, ] = entityId.split('.');
        this.domain = domain;
        this.device_class = this.state.attributes.device_class;
        if (['binary_sensor', 'cover'].includes(this.domain)) {
            let supportedDeviceClasses = {
                battery: {
                    on: 'low',
                    off: 'normal'
                },
                carbon_monoxide: {
                    on: 'detecting',
                    off: 'not_detecting'
                },
                carbon_dioxide: {
                    on: 'detecting',
                    off: 'not_detecting'
                },
                cold: {
                    on: 'cold',
                    off: 'normal'
                },
                connectivity: {
                    on: 'connected',
                    off: 'disconnected'
                },
                door: {
                    on: 'open',
                    off: 'closed'
                },
                flood: {
                    on: 'flooding',
                    off: 'not_flooding'
                },
                garage: {
                    on: 'open',
                    off: 'closed'
                },
                garage_door: {
                    on: 'open',
                    off: 'closed'
                },
                gas: {
                    on: 'detecting',
                    off: 'not_detecting'
                },
                heat: {
                    on: 'hot',
                    off: 'normal'
                },
                humidity: {
                    on: 'humid',
                    off: 'normal',
                },
                moisture: {
                    on: 'wet',
                    off: 'dry'
                },
                motion: {
                    on: 'detecting',
                    off: 'not_detecting'
                },
                occupancy: {
                    on: 'detecting',
                    off: 'not_detecting'
                },
                plug: {
                    on: 'plugged',
                    off: 'unplugged'
                },
                sound: {
                    on: 'detecting',
                    off: 'not_detecting'
                },
                smoke: {
                    on: 'detecting',
                    off: 'nothing'
                },
                window: {
                    on: 'open',
                    off: 'closed'
                }
            };
            this.deviceStateMapping = supportedDeviceClasses[this.device_class] || { on: 'on', off: 'off' };
        }
    }
    async get_state() {
        if (this.domain === 'sensor') {
            let value = adjustUnit(parseFloat(this.state.state), this.state.attributes.unit_of_measurement);
            return [{ state: undefined, value: value }];
        } else if (this.domain === 'binary_sensor') {
            let state = this.deviceStateMapping[this.state.state];
            if (['gas', 'CO', 'CO2', 'smoke'].includes(this.device_class))
                state = state === 'detecting' ? this.device_class : 'nothing';
            return [{ state: state, value: undefined }];
        } else {
            throw new Error(`Unexpected Home Assistant domain ${this.domain}`);
        }
    }
        // note: subscribe_ must NOT be async, or an ImplementationError will occur at runtime
    subscribe_state() {
        if (this.domain === 'sensor') {
            return this._subscribeState(() => {
                return { state: undefined, value: parseFloat(this.state.state) };
            });
        } else if (this.domain === 'binary_sensor') {
            return this._subscribeState(() => {
                let state = this.deviceStateMapping[this.state.state];
                if (['gas', 'CO', 'CO2', 'smoke'].includes(this.device_class))
                    state = state === 'detecting' ? this.device_class : 'nothing';
                return { state: state, value: undefined };
            });
        } else {
            throw new Error(`Unexpected Home Assistant domain ${this.domain}`);
        }
    }
        // Specific query methods for sensors that use a different Thingpedia function name
        // than the generic state
        // (in other gateways/APIs, a single device can implement multiple of these interfaces,
        // so we give them different names so they don't conflict)
    async get_motion() {
        return this.get_state();
    }
    subscribe_motion() {
        return this.subscribe_state();
    }
    async get_occupancy() {
        return this.get_state();
    }
    subscribe_occupancy() {
        return this.subscribe_state();
    }
    async get_sound() {
        return this.get_state();
    }
    subscribe_sound() {
        return this.subscribe_state();
    }
    async get_illuminance() {
        return this.get_state();
    }
    subscribe_illuminance() {
        return this.subscribe_state();
    }
    async get_uv() {
        return this.get_state();
    }
    subscribe_uv() {
        return this.subscribe_state();
    }
    async get_flood() {
        return this.get_state();
    }
    subscribe_flood() {
        return this.subscribe_state();
    }
    async get_temperature() {
        return this.get_state();
    }
    subscribe_temperature() {
        return this.subscribe_state();
    }
    async get_humidity() {
        return this.get_state();
    }
    subscribe_humidity() {
        return this.subscribe_state();
    }
};

1	// -- mode: js; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of io.home-assistant
4	//
5	// Copyright 2019 Xiaomeng Jin <tracyjxm@stanford.edu>
6	//
7	// See LICENSE for details
8	"use strict";
9
10	const Units = require('thingtalk-units');	2✔
11
12	const HomeAssistantDevice = require('./base');	2✔
13
14	function adjustUnit(value, fromUnit) {
15	switch (fromUnit) {	31!
16
17	// first the units were we use the same name
18	case 'K':
19	case 'ms':
20	case 's':
21	case 'min':
22	case 'h':
23	// XXX month and meter both use the same unit!
24	case 'm':
25	case 'mm':
26	case 'cm':
27	case 'km':
28	case 'in':
29	case 'ft':
30	case 'mi':
31	case 'gal':
32	case 'g':
33	case 'mg':
34	case 'kg':
35	case 'oz':
36	case 'lb':
37	case 'lx':
38	case 'mph':
39	case 'dB':
40	case 'dBm':
41	case 'KiB':
42	case 'MiB':
43	case 'GiB':
44	case 'TiB':
45	return Units.transformToBaseUnit(value, fromUnit);	6✔
46
47	// units that we support with a different name
48	case '°F':
49	return Units.transformToBaseUnit(value, 'F');	6✔
50	case 'd':
NEW 51	return Units.transformToBaseUnit(value, 'day');	×
52	case 'L':
53	case 'mL':
NEW 54	return Units.transformToBaseUnit(value, fromUnit.toLowerCase());	×
55	case 'm³':
NEW 56	return Units.transformToBaseUnit(value, 'm3');	×
57	case 'ft³':
NEW 58	return Units.transformToBaseUnit(value, 'ft3');	×
59	case 'fl. oz.':
NEW 60	return Units.transformToBaseUnit(value, 'floz');	×
61	case 'm²':
NEW 62	return Units.transformToBaseUnit(value, 'm2');	×
63	case 'm/s':
NEW 64	return Units.transformToBaseUnit(value, 'mps');	×
65	case 'km/h':
NEW 66	return Units.transformToBaseUnit(value, 'kmph');	×
67	case 'B':
NEW 68	return Units.transformToBaseUnit(value, 'byte');	×
69	case 'kB':
NEW 70	return Units.transformToBaseUnit(value, 'KB');	×
71
72	// TODO move to thingtalk-units
73	case 'μs':
NEW 74	return value/1000;//base unit is ms	×
75	case 'µg':
NEW 76	return value/(1000 * 1000 * 1000); //base unit is kg	×
77	case 'yd':
NEW 78	return value*0.9144;//base unit is m	×
79	case 'mm/d':
NEW 80	return value/1000 / 86400;//base unit is mps	×
81	case 'in/d':
NEW 82	return Units.transformToBaseUnit(value/86400, 'in');//base unit is mps	×
83	case 'in/h':
NEW 84	return Units.transformToBaseUnit(value/3600, 'in');//base unit is mps	×
85	case 'bit':
NEW 86	return value/8;//base unit is byte	×
87	case 'kbit':
NEW 88	return value/8*1000;	×
89	case 'Mbit':
NEW 90	return value/8*1000000;	×
91	case 'Gbit':
NEW 92	return value/8*1000000000;	×
93	case 'PB':
NEW 94	return value*1e15;	×
95	case 'EB':
NEW 96	return value*1e18;	×
97	case 'ZB':
NEW 98	return value*1e21;	×
99	case 'YB':
NEW 100	return value*1e24;	×
101	case 'PiB':
NEW 102	return value(1024*5);	×
103	case 'EiB':
NEW 104	return value(1024*6);	×
105	case 'ZiB':
NEW 106	return value(1024*7);	×
107	case 'YiB':
NEW 108	return value(1024*8);	×
109
110	case 'Hz':
111	case 'GHz':
112	case 'm³/h':
113	case 'ft³/m':
114	case 'µS/cm':
115	case 'W/m²':
116	case 'mm/h':
117	case 'µg/m³':
118	case 'mg/m³':
119	case 'p/m³':
120	case 'ppm':
121	case 'ppb':
122	case 'bit/s':
123	case 'kbit/s':
124	case 'Mbit/s':
125	case 'Gbit/s':
126	case 'B/s':
127	case 'kB/s':
128	case 'MB/s':
129	case 'GB/s':
130	case 'KiB/s':
131	case 'MiB/s':
132	case 'GiB/s':
133	// TODO add these units
134
135	default:
136	return value;	19✔
137	}
138	}
139
140	module.exports = class HomeAssistantSensor extends HomeAssistantDevice {	2✔
141	constructor(engine, state, master, entityId) {
142	super(engine, state, master, entityId);	64✔
143	const [domain, ] = entityId.split('.');	64✔
144	this.domain = domain;	64✔
145	this.device_class = this.state.attributes.device_class;	64✔
146	if (['binary_sensor', 'cover'].includes(this.domain)) {	64✔
147	let supportedDeviceClasses = {	32✔
148	battery: {
149	on: 'low',
150	off: 'normal'
151	},
152	carbon_monoxide: {
153	on: 'detecting',
154	off: 'not_detecting'
155	},
156	carbon_dioxide: {
157	on: 'detecting',
158	off: 'not_detecting'
159	},
160	cold: {
161	on: 'cold',
162	off: 'normal'
163	},
164	connectivity: {
165	on: 'connected',
166	off: 'disconnected'
167	},
168	door: {
169	on: 'open',
170	off: 'closed'
171	},
172	flood: {
173	on: 'flooding',
174	off: 'not_flooding'
175	},
176	garage: {
177	on: 'open',
178	off: 'closed'
179	},
180	garage_door: {
181	on: 'open',
182	off: 'closed'
183	},
184	gas: {
185	on: 'detecting',
186	off: 'not_detecting'
187	},
188	heat: {
189	on: 'hot',
190	off: 'normal'
191	},
192	humidity: {
193	on: 'humid',
194	off: 'normal',
195	},
196	moisture: {
197	on: 'wet',
198	off: 'dry'
199	},
200	motion: {
201	on: 'detecting',
202	off: 'not_detecting'
203	},
204	occupancy: {
205	on: 'detecting',
206	off: 'not_detecting'
207	},
208	plug: {
209	on: 'plugged',
210	off: 'unplugged'
211	},
212	sound: {
213	on: 'detecting',
214	off: 'not_detecting'
215	},
216	smoke: {
217	on: 'detecting',
218	off: 'nothing'
219	},
220	window: {
221	on: 'open',
222	off: 'closed'
223	}
224	};
225	this.deviceStateMapping = supportedDeviceClasses[this.device_class] \|\| { on: 'on', off: 'off' };	32✔
226	}
227	}
228	async get_state() {
229	if (this.domain === 'sensor') {	54✔
230	let value = adjustUnit(parseFloat(this.state.state), this.state.attributes.unit_of_measurement);	31✔
231	return [{ state: undefined, value: value }];	31✔
232	} else if (this.domain === 'binary_sensor') {	23!
233	let state = this.deviceStateMapping[this.state.state];	23✔
234	if (['gas', 'CO', 'CO2', 'smoke'].includes(this.device_class))	23!
UNCOV 235	state = state === 'detecting' ? this.device_class : 'nothing';	×
236	return [{ state: state, value: undefined }];	23✔
237	} else {
UNCOV 238	throw new Error(`Unexpected Home Assistant domain ${this.domain}`);	×
239	}
240	}
241	// note: subscribe_ must NOT be async, or an ImplementationError will occur at runtime
242	subscribe_state() {
UNCOV 243	if (this.domain === 'sensor') {	×
UNCOV 244	return this._subscribeState(() => {	×
UNCOV 245	return { state: undefined, value: parseFloat(this.state.state) };	×
246	});
UNCOV 247	} else if (this.domain === 'binary_sensor') {	×
UNCOV 248	return this._subscribeState(() => {	×
UNCOV 249	let state = this.deviceStateMapping[this.state.state];	×
UNCOV 250	if (['gas', 'CO', 'CO2', 'smoke'].includes(this.device_class))	×
UNCOV 251	state = state === 'detecting' ? this.device_class : 'nothing';	×
UNCOV 252	return { state: state, value: undefined };	×
253	});
254	} else {
UNCOV 255	throw new Error(`Unexpected Home Assistant domain ${this.domain}`);	×
256	}
257	}
258	// Specific query methods for sensors that use a different Thingpedia function name
259	// than the generic state
260	// (in other gateways/APIs, a single device can implement multiple of these interfaces,
261	// so we give them different names so they don't conflict)
262	async get_motion() {
263	return this.get_state();	6✔
264	}
265	subscribe_motion() {
UNCOV 266	return this.subscribe_state();	×
267	}
268	async get_occupancy() {
UNCOV 269	return this.get_state();	×
270	}
271	subscribe_occupancy() {
UNCOV 272	return this.subscribe_state();	×
273	}
274	async get_sound() {
UNCOV 275	return this.get_state();	×
276	}
277	subscribe_sound() {
UNCOV 278	return this.subscribe_state();	×
279	}
280	async get_illuminance() {
281	return this.get_state();	6✔
282	}
283	subscribe_illuminance() {
UNCOV 284	return this.subscribe_state();	×
285	}
286	async get_uv() {
287	return this.get_state();	5✔
288	}
289	subscribe_uv() {
UNCOV 290	return this.subscribe_state();	×
291	}
292	async get_flood() {
293	return this.get_state();	8✔
294	}
295	subscribe_flood() {
UNCOV 296	return this.subscribe_state();	×
297	}
298	async get_temperature() {
299	return this.get_state();	6✔
300	}
301	subscribe_temperature() {
UNCOV 302	return this.subscribe_state();	×
303	}
304	async get_humidity() {
305	return this.get_state();	6✔
306	}
307	subscribe_humidity() {
UNCOV 308	return this.subscribe_state();	×
309	}
310	};

stanford-oval / thingpedia-common-devices / 1732

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