boneIO 0.5.0__tar.gz → 0.5.0dev2__tar.gz

{boneIO-0.5.0 → boneIO-0.5.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: boneIO
-Version: 0.5.0
+Version: 0.5.0dev2
 Summary: Python App for BoneIO
 License: GNU General Public License v3.0
 Author-email: Paweł Szafer <pszafer@gmail.com>

{boneIO-0.5.0 → boneIO-0.5.0.dev2}/boneio/bonecli.py

@@ -3,9 +3,6 @@ import argparse
 import asyncio
 import logging
 import sys
-import os
-
-os.environ["W1THERMSENSOR_NO_KERNEL_MODULE"] = "1"
 
 from colorlog import ColoredFormatter
 from yaml import MarkedYAMLError

{boneIO-0.5.0 → boneIO-0.5.0.dev2}/boneio/helper/filter.py

@@ -1,8 +1,5 @@
 """Filter class to adjust sensor values."""
 from __future__ import annotations
-import logging
-
-_LOGGER = logging.getLogger(__name__)
 
 
 FILTERS = {
@@ -22,8 +19,7 @@ class Filter:
         for filter in self._filters:
             for k, v in filter.items():
                 if k not in FILTERS:
-                    _LOGGER.warn("Filter %s doesn't exists. Fix it in config.", k)
-                    continue
+                    break
                 value = FILTERS[k](value, v)
                 if value is None:
                     return None

{boneIO-0.5.0 → boneIO-0.5.0.dev2}/boneio/helper/gpio.py

@@ -90,8 +90,9 @@ class GpioBaseClass:
     ) -> None:
         """Setup GPIO Input Button"""
         self._pin = pin
-        gpio_mode = kwargs.get(GPIO_MODE, GPIO_STR)
-        self._bounce_time = kwargs.get("bounce_time", TimePeriod(milliseconds=10))
+        gpio = kwargs.get("rest_pin", {GPIO_MODE: GPIO_STR})
+        gpio_mode = gpio.get(GPIO_MODE, GPIO_STR)
+        self._bounce_time = gpio.get("bounce_time", TimePeriod(milliseconds=10))
         self._loop = asyncio.get_running_loop()
         self._press_callback = press_callback
         setup_input(pin=self._pin, pull_mode=gpio_mode)

{boneIO-0.5.0 → boneIO-0.5.0.dev2}/boneio/helper/ha_discovery.py

@@ -109,9 +109,7 @@ def ha_binary_sensor_availabilty_message(id: str, name: str, topic: str = "boneI
     }
 
 
-def ha_sensor_temp_availabilty_message(
-    id: str, name: str, topic: str = "boneIO", **kwargs
-):
+def ha_sensor_temp_availabilty_message(id: str, name: str, topic: str = "boneIO"):
     """Create availability topic for HA."""
     return {
         "availability": [{"topic": f"{topic}/{STATE}"}],
@@ -127,8 +125,8 @@ def ha_sensor_temp_availabilty_message(
         "unique_id": f"{topic}{SENSOR}{id}",
         "device_class": "temperature",
         "state_class": "measurement",
+        "unit_of_measurement": "°C",
         "value_template": "{{ value_json.state }}",
-        **kwargs,
     }
 
 
@@ -154,7 +152,7 @@ def modbus_sensor_availabilty_message(
         },
         "name": sensor_id,
         "state_topic": f"{topic}/{device_type}/{id}/{state_topic_base}",
-        "unique_id": f"{topic}{sensor_id.replace('_', '').lower()}{name.lower()}",
+        "unique_id": f"{topic}{sensor_id.replace('_', '').lower()}",
         **kwargs,
     }
 

{boneIO-0.5.0 → boneIO-0.5.0.dev2}/boneio/helper/loader.py

@@ -125,7 +125,6 @@ def create_temp_sensor(
             name=name,
             i2c=i2cbusio,
             address=config[ADDRESS],
-            manager=manager,
             send_message=manager.send_message,
             topic_prefix=topic_prefix,
             update_interval=config.get(UPDATE_INTERVAL, TimePeriod(seconds=60)),
@@ -136,7 +135,6 @@ def create_temp_sensor(
             name=name,
             ha_type=SENSOR,
             availability_msg_func=ha_sensor_temp_availabilty_message,
-            unit_of_measurement=config.get("unit_of_measurement", "°C"),
         )
         return temp_sensor
     except I2CError as err:
@@ -406,6 +404,5 @@ def create_dallas_sensor(
             name=sensor.name,
             ha_type=SENSOR,
             availability_msg_func=ha_sensor_temp_availabilty_message,
-            unit_of_measurement=config.get("unit_of_measurement", "°C"),
         )
     return sensor

{boneIO-0.5.0 → boneIO-0.5.0.dev2}/boneio/helper/stats.py

@@ -4,8 +4,7 @@ from datetime import datetime
 import socket
 import time
 from math import floor
-from typing import Callable, List
-from functools import partial
+from typing import Callable
 
 import psutil
 
@@ -119,31 +118,21 @@ class HostSensor(AsyncUpdater):
     """Host sensor."""
 
     def __init__(
-        self,
-        update_function: Callable,
-        manager_callback: Callable,
-        static_data: dict,
-        id: str,
-        type: str,
-        **kwargs,
+        self, update_function: Callable, static_data: dict, id: str, **kwargs
     ) -> None:
         self._update_function = update_function
         self._static_data = static_data
         self._state = None
-        self._type = type
-        self._manager_callback = manager_callback
-        self._loop = asyncio.get_event_loop()
         self.id = id
         super().__init__(**kwargs)
 
     async def async_update(self, time: datetime) -> None:
         self._state = self._update_function()
-        self._loop.call_soon_threadsafe(partial(self._manager_callback, self._type))
 
     @property
     def state(self) -> dict:
         if self._static_data:
-            return {**self._static_data, self._type: self._state}
+            return {**self._static_data, **self._state}
         return self._state
 
 
@@ -158,7 +147,6 @@ class HostData:
         callback: Callable,
         temp_sensor: Callable[[LM75Sensor, MCP9808Sensor], None],
         manager: Manager,
-        enabled_screens: List[str],
     ) -> None:
         """Initialize HostData."""
         self._hostname = socket.gethostname()
@@ -175,15 +163,11 @@ class HostData:
             },
         }
         for k, _v in host_stats.items():
-            if k not in enabled_screens:
-                continue
             self.data[k] = HostSensor(
                 update_function=_v["f"],
                 static_data=_v.get("static"),
                 manager=manager,
-                manager_callback=callback,
                 id=f"{k}_hoststats",
-                type=k,
                 update_interval=_v["update_interval"],
             )
         self._temp_sensor = temp_sensor

{boneIO-0.5.0 → boneIO-0.5.0.dev2}/boneio/helper/yaml_util.py

@@ -135,8 +135,6 @@ def load_config_from_string(config_yaml: str):
     schema = load_yaml_file(schema_file)
     v = CustomValidator(schema, purge_unknown=True)
     v.validate(config_yaml)
-    if v.errors:
-        _LOGGER.error("There are errors in your config %s", v.errors)
     doc = v.normalized(v.document, always_return_document=True)
     # validated = v.validated(document=doc, normalize=True, always_return_document=True)
     # doc = v.normalized(validated, always_return_document=True)
@@ -255,6 +253,7 @@ class CustomValidator(Validator):
 
     def _normalize_coerce_positive_time_period(self, value) -> TimePeriod:
         """Validate and transform time period with time unit and integer value."""
+
         if isinstance(value, int):
             raise ConfigurationException(
                 f"Don't know what '{value}' means as it has no time *unit*! Did you mean '{value}s'?"

{boneIO-0.5.0 → boneIO-0.5.0.dev2}/boneio/manager.py

@@ -2,6 +2,7 @@ import asyncio
 import logging
 from collections import deque
 from typing import Callable, Coroutine, List, Optional, Set, Union
+
 from board import SCL, SDA
 from busio import I2C
 
@@ -59,8 +60,6 @@ from boneio.helper.logger import configure_logger
 from boneio.helper.yaml_util import load_config_from_file
 from boneio.modbus import Modbus
 
-from w1thermsensor.errors import KernelModuleLoadError
-
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -205,11 +204,8 @@ class Manager:
         if oled.get("enabled", False):
             from boneio.oled import Oled
 
-            screens = oled.get("screens")
-
             self._host_data = HostData(
                 manager=self,
-                enabled_screens=screens,
                 output=self.grouped_outputs,
                 temp_sensor=self._temp_sensors[0] if self._temp_sensors else None,
                 callback=self._host_data_callback,
@@ -217,7 +213,6 @@ class Manager:
             try:
                 self._oled = Oled(
                     host_data=self._host_data,
-                    screen_order=screens,
                     output_groups=list(self.grouped_outputs),
                     sleep_timeout=oled.get("screensaver_timeout", 60),
                 )
@@ -254,7 +249,6 @@ class Manager:
             from boneio.helper.loader import (
                 configure_ds2482,
             )
-            from boneio.sensor import DallasSensorDS2482
 
             _ds_onewire_bus[_single_ds[ID]] = configure_ds2482(
                 i2cbusio=self._i2cbusio, address=_single_ds[ADDRESS]
@@ -270,35 +264,22 @@ class Manager:
             _LOGGER.debug("Preparing Dallas bus.")
             from boneio.helper.loader import configure_dallas
 
-            try:
-                from w1thermsensor.kernel import load_kernel_modules
-
-                load_kernel_modules()
-                from boneio.sensor.temp.dallas_w1 import DallasSensorW1
-
-                _one_wire_devices.update(
-                    find_onewire_devices(
-                        ow_bus=configure_dallas(),
-                        bus_id=dallas[ID],
-                        bus_type=DALLAS,
-                    )
+            _one_wire_devices.update(
+                find_onewire_devices(
+                    ow_bus=configure_dallas(),
+                    bus_id=dallas[ID],
+                    bus_type=DALLAS,
                 )
-            except KernelModuleLoadError as err:
-                _LOGGER.error("Can't configure Dallas W1 device %s", err)
-                pass
-
+            )
         for sensor in sensors:
             address = _one_wire_devices.get(sensor[ADDRESS])
             if not address:
                 continue
             ds2482_bus_id = sensor.get("bus_id")
             if ds2482_bus_id and ds2482_bus_id in _ds_onewire_bus:
-                kwargs = {
-                    "bus": _ds_onewire_bus[ds2482_bus_id],
-                    "cls": DallasSensorDS2482,
-                }
+                kwargs = {"bus": _ds_onewire_bus[ds2482_bus_id]}
             else:
-                kwargs = {"cls": DallasSensorW1}
+                kwargs = {}
             _LOGGER.debug("Configuring sensor %s for boneIO", address)
             self._temp_sensors.append(
                 create_dallas_sensor(

{boneIO-0.5.0 → boneIO-0.5.0.dev2}/boneio/modbus.py

@@ -77,7 +77,7 @@ class Modbus:
         """Call sync. pymodbus."""
         async with self._lock:
             if not self._pymodbus_connect():
-                _LOGGER.error("Can't connect to Modbus address %s.", address)
+                _LOGGER.error("Can't connect to Modbus.")
                 return None
             kwargs = {"unit": unit, "count": count} if unit else {}
             try:

{boneIO-0.5.0 → boneIO-0.5.0.dev2}/boneio/oled.py

@@ -28,7 +28,7 @@ fontSmall = make_font("DejaVuSans.ttf", 9)
 fontExtraSmall = make_font("DejaVuSans.ttf", 7)
 danube = make_font("danube__.ttf", 15, local=True)
 
-# screen_order = [UPTIME, NETWORK, CPU, DISK, MEMORY, SWAP]
+screen_order = [UPTIME, NETWORK, CPU, DISK, MEMORY, SWAP]
 
 STANDARD_ROWS = [17, 32, 47]
 UPTIME_ROWS = list(range(22, 60, 10))
@@ -40,32 +40,19 @@ class Oled:
     """Oled display class."""
 
     def __init__(
-        self,
-        host_data: HostData,
-        output_groups: List[str],
-        sleep_timeout: TimePeriod,
-        screen_order: List[str],
+        self, host_data: HostData, output_groups: List[str], sleep_timeout: TimePeriod
     ) -> None:
         """Initialize OLED screen."""
         self._loop = asyncio.get_running_loop()
-        self._output_groups = None
-        try:
-            _ind_screen = screen_order.index("outputs")
-            if not output_groups:
-                _LOGGER.debug("No outputs configured. Omitting in screen.")
-                screen_order.pop(_ind_screen)
-            screen_order[_ind_screen:_ind_screen] = output_groups
-            self._output_groups = output_groups
-        except ValueError:
-            pass
-        self._screen_order = cycle(screen_order)
+        self._screen_order = cycle(screen_order + output_groups)
+        self._output_groups = output_groups
         self._current_screen = next(self._screen_order)
         self._host_data = host_data
         self._sleep = False
         self._sleep_handle = None
         self._sleep_timeout = sleep_timeout
         setup_input(pin=OLED_PIN, pull_mode="gpio_pu")
-        edge_detect(pin=OLED_PIN, callback=self._handle_press, bounce=240)
+        edge_detect(pin=OLED_PIN, callback=self._handle_press, bounce=120)
         try:
             serial = i2c(port=2, address=0x3C)
             self._device = sh1106(serial)
@@ -125,7 +112,7 @@ class Oled:
         data = self._host_data.get(self._current_screen)
         if data:
             with canvas(self._device) as draw:
-                if self._output_groups and self._current_screen in self._output_groups:
+                if self._current_screen in self._output_groups:
                     self._draw_output(data, draw)
                 elif self._current_screen == UPTIME:
                     self._draw_uptime(data, draw)

{boneIO-0.5.0 → boneIO-0.5.0.dev2}/boneio/schema/schema.yaml

@@ -75,18 +75,6 @@ oled:
       default: False
       meta:
         label: Disable builtin screen.
-    screens:
-      type: list
-      required: True
-      allowed: ["uptime", "network", "cpu", "disk", "memory", "swap", "outputs"]
-      default:
-        - uptime
-        - network
-        - cpu
-        - disk
-        - memory
-        - swap
-        - outputs
     screensaver_timeout:
       type:
         - string
@@ -123,9 +111,7 @@ modbus_sensors:
         meta:
           label: Id of Modbus sensor
       address:
-        type:
-          - string
-          - integer
+        type: string
         required: True
         meta:
           label: Address of Modbus sensor to use.
@@ -147,50 +133,41 @@ modbus_sensors:
         meta:
           label: Update interval.
 lm75:
-  type: list
+  type: dict
   required: False
-  meta:
-    label: LM75 Sensor list.
   schema:
-    type: dict
-    required: False
-    schema:
-      id: !include id.yaml
-      address:
-        type:
-          - string
-          - integer
-        required: True
-        default: 0x48
-        meta:
-          label: Address of I2C
-      update_interval: !include update_interval.yaml
-      filters: !include filters.yaml
-      unit_of_measurement: !include temp_unit.yaml
+    id:
+      type: string
+      required: False
+      meta:
+        label: Id of I2C to use in pin config
+    address:
+      type: string
+      required: True
+      default: 0x48
+      meta:
+        label: Address of I2C
+    update_interval: !include update_interval.yaml
+    filters: !include filters.yaml
 
 
 mcp9808:
-  type: list
+  type: dict
   required: False
-  meta:
-    label: MCP9808 Sensor list.
   schema:
-    type: dict
-    required: False
-    schema:
-      id: !include id.yaml
-      address:
-        type:
-          - string
-          - integer
-        required: True
-        default: 0x18
-        meta:
-          label: Address of I2C device
-      update_interval: !include update_interval.yaml
-      filters: !include filters.yaml
-      unit_of_measurement: !include temp_unit.yaml
-      
+    id:
+      type: string
+      required: False
+      meta:
+        label: Id of I2C to use in pin config
+    address:
+      type: string
+      required: True
+      default: 0x18
+      meta:
+        label: Address of I2C device
+    update_interval: !include update_interval.yaml
+    filters: !include filters.yaml
 
 mcp23017:
   type: list
@@ -200,7 +177,11 @@ mcp23017:
   schema:
     type: dict
     schema:
-      id: !include id.yaml
+      id:
+        type: string
+        required: True
+        meta:
+          label: Id of I2C to use in pin config
       address:
         type: integer
         required: True
@@ -333,12 +314,6 @@ input:
         required: True
         meta:
           label: Either switch or sensor. If sensor then no clicks are detected, just simple on/off on gpio.
-      inverted:
-        type: boolean
-        default: False
-        required: True
-        meta:
-          label: Check if sensor type is inverted. Only aplicable for sensor kind.
       actions:
         required: False
         type: dict
@@ -445,7 +420,11 @@ ds2482:
     type: dict
     required: False
     schema:
-      id: !include id.yaml
+      id:
+        type: string
+        required: True
+        meta:
+          label: Id of I2C to use in pin config
       address:
         type: string
         required: True
@@ -501,4 +480,3 @@ sensor:
           label: If you want you can disable discovering this input in HA.
       filters: !include filters.yaml
       update_interval: !include update_interval.yaml
-      unit_of_measurement: !include temp_unit.yaml

{boneIO-0.5.0 → boneIO-0.5.0.dev2}/boneio/sensor/gpio.py

@@ -14,11 +14,6 @@ class GpioInputSensor(GpioBaseClass):
     def __init__(self, **kwargs) -> None:
         """Setup GPIO Input Button"""
         super().__init__(**kwargs)
-        self._click_type = (
-            (PRESSED, RELEASED)
-            if kwargs.get("inverted", False)
-            else (PRESSED, RELEASED)
-        )
         edge_detect(
             self._pin,
             callback=self._handle_press,
@@ -30,8 +25,13 @@ class GpioInputSensor(GpioBaseClass):
     def _handle_press(self, pin: str) -> None:
         """Handle the button press callback"""
         # Ignore if we are in a long press
-        click_type = self._click_type[0] if self.is_pressed else self._click_type[1]
-        _LOGGER.debug("%s event on pin %s", click_type, self._pin)
-        self._loop.call_soon_threadsafe(
-            partial(self._press_callback, click_type, self._pin)
-        )
+        if self.is_pressed:
+            _LOGGER.debug("Pressed event on pin %s", self._pin)
+            self._loop.call_soon_threadsafe(
+                partial(self._press_callback, PRESSED, self._pin)
+            )
+        else:
+            _LOGGER.debug("Released event on pin %s", self._pin)
+            self._loop.call_soon_threadsafe(
+                partial(self._press_callback, RELEASED, self._pin)
+            )

{boneIO-0.5.0 → boneIO-0.5.0.dev2}/boneio/sensor/modbus/__init__.py

@@ -123,9 +123,7 @@ class ModbusSensor(BasicMqtt, AsyncUpdater):
         self, id: str, sdm_name: str, sensor_id: str, **kwargs
     ) -> None:
         """Send HA autodiscovery information for each Modbus sensor."""
-        _LOGGER.debug(
-            "Sending HA discovery for modbus sensor %s %s.", sdm_name, sensor_id
-        )
+        _LOGGER.debug("Sending HA discovery for sensor %s %s.", sdm_name, sensor_id)
         topic = (
             f"{self._config_helper.ha_discovery_prefix}/{SENSOR}/{self._config_helper.topic_prefix}{id}"
             f"/{id}{sensor_id.replace('_', '').replace(' ', '').lower()}/config"
@@ -143,28 +141,30 @@ class ModbusSensor(BasicMqtt, AsyncUpdater):
 
     def _send_discovery_for_all_registers(self, register: int = 0) -> bool:
         """Send discovery message to HA for each register."""
-        for data in self._db[REGISTERS_BASE]:
-            for register in data[REGISTERS]:
-                value_template = (
-                    f'{{{{ value_json.{register.get("name").replace(" ", "")} | '
-                    f'{register.get("ha_filter", "round(2)")} }}}}'
-                )
-                kwargs = {
-                    "unit_of_measurement": register.get("unit_of_measurement"),
-                    "state_class": register.get("state_class"),
-                    "value_template": value_template,
-                    "sensor_id": register.get("name"),
-                }
-                device_class = register.get("device_class")
-                if device_class:
-                    kwargs["device_class"] = device_class
-                self._send_ha_autodiscovery(
-                    id=self._id,
-                    sdm_name=self._name,
-                    state_topic_base=data[BASE],
-                    **kwargs,
-                )
-        return datetime.now()
+        if register > 0:
+            for data in self._db[REGISTERS_BASE]:
+                for register in data[REGISTERS]:
+                    value_template = (
+                        f'{{{{ value_json.{register.get("name").replace(" ", "")} | '
+                        f'{register.get("ha_filter", "round(2)")} }}}}'
+                    )
+                    kwargs = {
+                        "unit_of_measurement": register.get("unit_of_measurement"),
+                        "state_class": register.get("state_class"),
+                        "value_template": value_template,
+                        "sensor_id": register.get("name"),
+                    }
+                    device_class = register.get("device_class")
+                    if device_class:
+                        kwargs["device_class"] = device_class
+                    self._send_ha_autodiscovery(
+                        id=self._id,
+                        sdm_name=self._name,
+                        state_topic_base=data[BASE],
+                        **kwargs,
+                    )
+            return datetime.now()
+        return False
 
     async def check_availability(self) -> None:
         """Get first register and check if it's available."""
@@ -182,15 +182,12 @@ class ModbusSensor(BasicMqtt, AsyncUpdater):
                     address=first_register_base[REGISTERS][0][ADDRESS],
                     method=register_method,
                 )
-                if register is not None:
+                if register:
                     self._discovery_sent = self._send_discovery_for_all_registers(
                         register
                     )
                     await asyncio.sleep(2)
                     break
-            _LOGGER.error(
-                "Discovery for %s not sent. First register not available.", self._id
-            )
 
     async def async_update(self, time: datetime) -> None:
         """Fetch state periodically and send to MQTT."""
@@ -222,8 +219,7 @@ class ModbusSensor(BasicMqtt, AsyncUpdater):
                         payload=self._payload_online,
                     )
                 _LOGGER.warn(
-                    "Can't fetch data from modbus device %s. Will sleep for %s seconds",
-                    self.id,
+                    "Can't fetch data from modbus device. Will sleep for %s seconds",
                     update_interval,
                 )
                 self._discovery_sent = False

{boneIO-0.5.0 → boneIO-0.5.0.dev2}/boneio/sensor/temp/__init__.py

@@ -1,7 +1,6 @@
 """Manage BoneIO onboard temp sensors."""
 
 import asyncio
-import logging
 from datetime import datetime
 
 from boneio.const import SENSOR, STATE, TEMPERATURE
@@ -9,8 +8,6 @@ from boneio.helper import BasicMqtt, AsyncUpdater
 from boneio.helper.exceptions import I2CError
 from boneio.helper.filter import Filter
 
-_LOGGER = logging.getLogger(__name__)
-
 
 class TempSensor(BasicMqtt, AsyncUpdater, Filter):
     """Represent Temp sensor in BoneIO."""
@@ -44,10 +41,8 @@ class TempSensor(BasicMqtt, AsyncUpdater, Filter):
 
     def update(self, time: datetime) -> None:
         """Fetch temperature periodically and send to MQTT."""
-        _temp = self._pct.temperature
-        _LOGGER.debug("Fetched temperature %s. Applying filters.", _temp)
         _temp = self._apply_filters(value=self._pct.temperature)
-        if _temp is None:
+        if not _temp:
             return
         self._state = _temp
         self._send_message(

{boneIO-0.5.0 → boneIO-0.5.0.dev2}/boneio/sensor/temp/dallas.py

@@ -3,6 +3,7 @@
 import asyncio
 import logging
 from datetime import datetime
+from ast import literal_eval
 
 from adafruit_ds18x20 import DS18X20
 from w1thermsensor import SensorNotReadyError
@@ -65,7 +66,7 @@ class DallasSensorW1(TempSensor, AsyncUpdater):
             _temp = await self._pct.get_temperature()
             _LOGGER.debug("Fetched temperature %s. Applying filters.", _temp)
             _temp = self._apply_filters(value=_temp)
-            if _temp is None:
+            if not _temp:
                 return
             self._state = _temp
             self._send_message(

boneIO-0.5.0.dev2/boneio/version.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+__version__ = "0.5.0dev2"

{boneIO-0.5.0 → boneIO-0.5.0.dev2}/pyproject.toml

@@ -27,7 +27,7 @@ dependencies = [
     "w1thermsensor[async]>=2.0.0",
 ]
 requires-python = ">=3.7"
-version = "0.5.0"
+version = "0.5.0dev2"
 
 [project.license]
 text = "GNU General Public License v3.0"

boneIO-0.5.0/boneio/schema/id.yaml

@@ -1,4 +0,0 @@
-type: string
-required: False
-meta:
-  label: Id of I2C to use in pin config

boneIO-0.5.0/boneio/schema/temp_unit.yaml

@@ -1,4 +0,0 @@
-type: string
-required: True
-default: °C
-allowed: ["°C", "°F"]

boneIO-0.5.0/boneio/sensor/modbus/pt100.json

@@ -1,21 +0,0 @@
-{
-    "model": "PT100",
-    "registers_base": [
-        {
-            "base": 1,
-            "length": 1,
-            "register_type": "holding",
-            "registers": [
-                {
-                    "name": "Temperature1 PT100",
-                    "address": 1,
-                    "unit_of_measurement": "°C",
-                    "state_class": "measurement",
-                    "device_class": "temperature",
-                    "return_type": "multiply0_1"
-                }
-            ]
-
-        }
-    ]
-}

boneIO-0.5.0/boneio/version.py

@@ -1,2 +0,0 @@
-# flake8: noqa
-__version__ = "0.5.0"