boneIO 0.9.0.dev9__tar.gz → 0.9.0.dev12__tar.gz

{boneio-0.9.0.dev9 → boneio-0.9.0.dev12}/PKG-INFO

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

boneio-0.9.0.dev12/boneio/helper/schema_converter.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, Dict, List, Union
+
+import yaml
+from yaml import SafeLoader, load
+
+
+class BoneIOLoader(SafeLoader):
+    """Custom YAML loader with !include constructor."""
+    
+    def __init__(self, stream):
+        self._root = os.path.split(stream.name)[0]
+        super().__init__(stream)
+    
+    def include(self, node):
+        """Include file referenced at node."""
+        filename = os.path.join(self._root, self.construct_scalar(node))
+        with open(filename, 'r') as f:
+            return load(f, BoneIOLoader)
+
+# Register the !include constructor
+BoneIOLoader.add_constructor('!include', BoneIOLoader.include)
+
+def convert_type(cerberus_type: Union[str, List[str]]) -> Union[str, List[str]]:
+    """Convert Cerberus type to JSON Schema type."""
+    
+        
+    type_map = {
+        'string': 'string',
+        'integer': 'integer',
+        'float': 'number',
+        'boolean': 'boolean',
+        'dict': 'object',
+        'list': 'array'
+    }
+    if isinstance(cerberus_type, list):
+        return [type_map.get(type, 'string') for type in cerberus_type]
+    return type_map.get(cerberus_type, 'string')
+
+def create_boolean_schema() -> Dict[str, Any]:
+    """Create a schema that accepts both boolean and boolean-like string values."""
+    return {
+        "oneOf": [
+            {"type": "boolean"},
+            {
+                "type": "string",
+                "enum": ["yes", "no", "true", "false", "on", "off"],
+                "x-yaml-boolean": True
+            }
+        ]
+    }
+
+def convert_cerberus_to_json_schema(cerberus_schema: Dict[str, Any]) -> Dict[str, Any]:
+    """Convert a Cerberus schema to JSON Schema format."""
+    json_schema = {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "type": "object",
+        "properties": {},
+        "required": []
+    }
+
+    for field, schema in cerberus_schema.items():
+        if not isinstance(schema, dict):
+            continue
+
+        field_schema = {}
+
+        # Handle type conversion, nullable and !include
+        if "type" in schema:
+            if schema["type"] == "boolean":
+                field_schema.update(create_boolean_schema())
+            else:
+                base_type = convert_type(schema["type"])
+                types = ["string"]  # Always allow string for !include
+                if isinstance(base_type, list):
+                    types.extend(base_type)
+                else:
+                    types.append(base_type)
+                if schema.get("nullable", False):
+                    types.append("null")
+                field_schema["type"] = types
+
+        # Handle required fields - only if required and no default
+        if schema.get("required", False) and "default" not in schema:
+            json_schema["required"].append(field)
+
+        # Handle default values
+        if "default" in schema:
+            field_schema["default"] = schema["default"]
+
+        # Handle nested dictionaries and arrays
+        if "schema" in schema and isinstance(schema["schema"], dict):
+            if schema.get("type") == "dict":
+                types = ["string", "object"]  # Allow both string for !include and object
+                if schema.get("nullable", False):
+                    types.append("null")
+                field_schema["type"] = types
+                field_schema["properties"] = {}
+                nested_required = []
+                
+                for nested_field, nested_schema in schema["schema"].items():
+                    field_schema["properties"][nested_field] = convert_cerberus_to_json_schema(
+                        {nested_field: nested_schema}
+                    )["properties"][nested_field]
+                    # Only add to required if the field is required and has no default
+                    if nested_schema.get("required", False) and "default" not in nested_schema:
+                        nested_required.append(nested_field)
+                
+                if nested_required:
+                    field_schema["required"] = nested_required
+                    
+            elif schema.get("type") == "list":
+                types = ["string", "array"]  # Allow both string for !include and array
+                if schema.get("nullable", False):
+                    types.append("null")
+                field_schema["type"] = types
+                if isinstance(schema["schema"], dict):
+                    field_schema["items"] = convert_cerberus_to_json_schema(
+                        {"item": schema["schema"]}
+                    )["properties"]["item"]
+
+        # Handle allowed values (enum)
+        if "allowed" in schema:
+            if schema.get("type") == "list":
+                if "items" not in field_schema:
+                    field_schema["items"] = {}
+                field_schema["items"]["enum"] = schema["allowed"]
+                # Add examples for better IDE support
+                field_schema["items"]["examples"] = [schema["allowed"][0]] if schema["allowed"] else []
+            else:
+                field_schema["enum"] = schema["allowed"]
+                # Add examples for better IDE support
+                field_schema["examples"] = [schema["allowed"][0]] if schema["allowed"] else []
+
+        # Handle descriptions from meta
+        if "meta" in schema and isinstance(schema["meta"], dict):
+            if "label" in schema["meta"]:
+                field_schema["description"] = schema["meta"]["label"]
+                # Add title for better IDE support
+                field_schema["title"] = field.replace("_", " ").capitalize()
+
+        json_schema["properties"][field] = field_schema
+
+    # Remove required array if empty
+    if not json_schema["required"]:
+        del json_schema["required"]
+
+    return json_schema
+
+def generate_section_schema(section_name: str, section_schema: Dict[str, Any]) -> Dict[str, Any]:
+    """Generate a schema for a specific section."""
+    if section_schema.get("type") == "array":
+        # For array types, use the items schema directly
+        return {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            **convert_cerberus_to_json_schema({section_name: section_schema})["properties"][section_name]
+        }
+    else:
+        # For object types, wrap in an object schema
+        return {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "properties": {
+                section_name: convert_cerberus_to_json_schema({section_name: section_schema})["properties"][section_name]
+            }
+        }
+
+def main():
+    """Main function to convert schema."""
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    schema_file = os.path.join(script_dir, "..", "schema", "schema.yaml")
+    output_dir = os.path.join(script_dir, "..", "..", "frontend", "public")
+    
+    # Create output directory if it doesn't exist
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Load the schema
+    with open(schema_file, "r") as f:
+        schema = yaml.load(f, Loader=BoneIOLoader)
+    
+    # Convert and save the main schema
+    json_schema = convert_cerberus_to_json_schema(schema)
+    main_schema_file = os.path.join(output_dir, "config.schema.json")
+    with open(main_schema_file, "w") as f:
+        json.dump(json_schema, f, indent=2)
+    print(f"Schema written to {main_schema_file}")
+    
+    # Generate and save section-specific schemas
+    for section_name, section_schema in schema.items():
+        section_json_schema = generate_section_schema(section_name, section_schema)
+        section_schema_file = os.path.join(output_dir, f"{section_name}.schema.json")
+        with open(section_schema_file, "w") as f:
+            json.dump(section_json_schema, f, indent=2)
+        print(f"Section schema for {section_name} written to {section_schema_file}")
+
+if __name__ == "__main__":
+    main()

{boneio-0.9.0.dev9 → boneio-0.9.0.dev12}/boneio/oled.py

@@ -293,13 +293,15 @@ class Oled:
         display_image = Image.new("1", (128, 64), 0)  # Mode 1, size 128x64, black background
         draw = ImageDraw.Draw(display_image)
         
-        # Add title text
-        title = "WebUI"
-        draw.text((2, 2), title, font=fonts["small"], fill=WHITE)
+        # Add title text on the left side
+        # text_width = fonts["small"].getsize(title)[0]
+        draw.text((2, 2), "Scan to", font=fonts["small"], fill=WHITE)
+        draw.text((2, 12), "access", font=fonts["small"], fill=WHITE)
+        draw.text((2, 22), "webui", font=fonts["small"], fill=WHITE)
         
-        # Calculate position to center the QR code, accounting for title
-        x = (128 - qr_image.size[0]) // 2
-        y = ((64 - qr_image.size[1]) // 2) + 5  # Add 5 pixels to move QR code down a bit
+        # Calculate position to align QR code to right and center vertically
+        x = 128 - qr_image.size[0] - 2  # Align to right with 2 pixels padding
+        y = ((64 - qr_image.size[1]) // 2)  # Center vertically
         
         # Paste QR code onto center of display image
         display_image.paste(qr_image, (x, y))

{boneio-0.9.0.dev9 → boneio-0.9.0.dev12}/boneio/runner.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import asyncio
 import logging
 import os
+import signal
 import warnings
 from typing import Any, Set
 
@@ -76,6 +77,17 @@ async def async_run(
     web_server = None
     tasks: Set[asyncio.Task] = set()
     event_bus = EventBus(loop=asyncio.get_event_loop())
+    shutdown_event = asyncio.Event()
+    loop = asyncio.get_event_loop()
+
+    def signal_handler():
+        """Handle shutdown signals."""
+        _LOGGER.info("Received shutdown signal, initiating graceful shutdown...")
+        shutdown_event.set()
+        
+    # Register signal handlers
+    for sig in (signal.SIGTERM, signal.SIGINT):
+        loop.add_signal_handler(sig, signal_handler)
 
     event_bus_task = asyncio.create_task(event_bus.start())
     tasks.add(event_bus_task)
@@ -134,14 +146,13 @@ async def async_run(
 
     tasks.update(manager.get_tasks())
 
-    
     message_bus_type = "MQTT" if isinstance(message_bus, MQTTClient) else "Local"
     _LOGGER.info("Starting message bus %s.", message_bus_type)
     message_bus_task = asyncio.create_task(message_bus.start_client())
     tasks.add(message_bus_task)
     message_bus_task.add_done_callback(tasks.discard)
     
-        # Start web server if configured
+    # Start web server if configured
     if "web" in config:
         web_config = config.get("web") or {}
         _LOGGER.info("Starting Web server.")
@@ -159,15 +170,51 @@ async def async_run(
         web_server_task.add_done_callback(tasks.discard)
     else:
         _LOGGER.info("Web server not configured.")
+
     try:
-        await asyncio.gather(*tasks)
+        # Convert tasks set to list for main gather
+        task_list = list(tasks)
+        main_gather = asyncio.gather(*task_list)
+        
+        # Wait for either shutdown signal or main task completion
+        await asyncio.wait([
+            main_gather,
+            asyncio.create_task(shutdown_event.wait())
+        ], return_when=asyncio.FIRST_COMPLETED)
+
+        if shutdown_event.is_set():
+            _LOGGER.info("Starting graceful shutdown...")
+            main_gather.cancel()
+            try:
+                await main_gather
+            except asyncio.CancelledError:
+                pass
+
         return 0
     except asyncio.CancelledError:
-        pass
+        _LOGGER.info("Main task cancelled")
     except (RestartRequestException, GracefulExit):
-        pass
+        _LOGGER.info("Restart or graceful exit requested")
     except Exception as e:
         _LOGGER.error(f"Unexpected error: {type(e).__name__} - {e}")
     finally:
+        _LOGGER.info("Cleaning up resources...")
+        # Stop the event bus
         event_bus.request_stop()
+        
+        # Create a copy of tasks set to avoid modification during iteration
+        remaining_tasks = list(tasks)
+        if remaining_tasks:
+            # Cancel and wait for all remaining tasks
+            for task in remaining_tasks:
+                if not task.done():
+                    task.cancel()
+            
+            # Wait for all tasks to complete
+            try:
+                await asyncio.gather(*remaining_tasks, return_exceptions=True)
+            except Exception as e:
+                _LOGGER.error(f"Error during cleanup: {type(e).__name__} - {e}")
+        
+        _LOGGER.info("Shutdown complete")
         return 0

{boneio-0.9.0.dev9 → boneio-0.9.0.dev12}/boneio/schema/filters.yaml

@@ -1,5 +1,7 @@
 type: list
 required: False
+meta:
+  label: "https://boneio.eu/docs/black/configuration/filters \n List of filters to apply. Allowed filters visible in allowed section."
 schema:
   type: dict
   keysrules:

{boneio-0.9.0.dev9 → boneio-0.9.0.dev12}/boneio/schema/schema.yaml

@@ -2,7 +2,7 @@ mqtt:
   type: dict
   required: True
   meta:
-    label: Mqtt section
+    label: "https://boneio.eu/docs/black/configuration/mqtt \n Mqtt section of boneIO Black configuration file. It handled connecting to mqtt broker, which then is connected to Home Assistant or other smart home system."
   schema:
     host:
       required: True
@@ -30,7 +30,7 @@ mqtt:
       default: boneIO
       required: True
       meta:
-        label: Prefix topic for boneIO to use. First overriden by 
+        label: Prefix topic for boneIO to use. If not set, then it will be set to name of the device from boneio section, otherwise set to boneIO.
     ha_discovery:
       type: dict
       meta:
@@ -53,7 +53,7 @@ web:
   required: False
   nullable: True
   meta:
-    label: Web section
+    label: "https://boneio.eu/docs/black/0.9.x-dev/configuration/web \n Web section of boneIO Black. It enables web interface. Default on port 8090."
   schema:
     port:
       required: False
@@ -83,6 +83,8 @@ web:
 logger:
   type: dict
   required: False
+  meta:
+    label: "https://boneio.eu/docs/black/configuration/logger \n Logger section of boneIO Black. It enables logging level. If run as systemd service, then it will log to journal. If not, then it will log to /tmp/boneio.log"
   schema:
     default:
       type: string
@@ -98,12 +100,14 @@ logger:
         coerce: lower  # Convert to lowercase for all values
         allowed: ['critical', 'error', 'warning', 'info', 'debug', 'CRITICAL', 'ERROR', 'WARNING', 'INFO', 'DEBUG']
       meta:
-        label: List of dict module\:level.
+        label: "Each line suppose to have one python module name and logging level eg pymodbus.client: INFO."
 
 oled:
   type: dict
   default: {}
   required: True
+  meta:
+    label: "https://boneio.eu/docs/black/configuration/oled \n Oled section of boneIO Black. It enables oled screen. You'd need enabled: true to make it work."
   schema:
     enabled:
       type: boolean
@@ -176,6 +180,8 @@ oled:
 modbus:
   type: dict
   required: False
+  meta:
+    label: "https://boneio.eu/docs/black/configuration/modbus \n Modbus section of boneIO Black. It enables modbus support. You define on which uart it modbus defined. For new boneIO it is uart4. For old boneIO it is uart1."
   schema:
     uart:
       type: string
@@ -202,7 +208,7 @@ modbus_sensors:
   type: list
   required: False
   meta:
-    label: Modbus sensors
+    label: "https://boneio.eu/docs/black/configuration/modbus-sensors \n List of modbus sensors. You can use predefined modbus sensors. It would fetch data from them and publish to mqtt."
   schema:
     type: dict
     schema:
@@ -226,14 +232,19 @@ modbus_sensors:
           - lower
         allowed:
           [
-            'sdm630',
+            'cwt',
+            'dts1964_3f',
+            'liquid-sensor',
+            'orno-or-we-517',
+            'pt100',
+            'r4dcb08',
             'sdm120',
-            'sofar',
+            'sdm630',
+            'sht20',
+            'sht30',
             'socomec_e03',
             'socomec_e23',
-            'cwt',
-            'orno-or-we-517',
-            'r4cb08'
+            'sofar',
           ]
         meta:
           label: Model to load from database.
@@ -260,16 +271,14 @@ lm75:
   type: list
   required: False
   meta:
-    label: LM75 Sensor list.
+    label: "https://boneio.eu/docs/black/configuration/lm75 \n LM75 Sensor list. All boneIO Black has one LM75 on board."
   schema:
     type: dict
     required: False
     schema:
       id: !include id.yaml
       address:
-        type:
-          - string
-          - integer
+        type: integer
         required: True
         default: 0x48
         meta:
@@ -282,7 +291,7 @@ ina219:
   type: list
   required: False
   meta:
-    label: INA219 Sensor list.
+    label: "https://boneio.eu/docs/black/configuration/ina219 \n INA219 Sensor list. All boneIO Black has one INA219 on board, which measures current, voltage and power of boneIO board."
   schema:
     type: dict
     required: False
@@ -321,7 +330,7 @@ mcp9808:
   type: list
   required: False
   meta:
-    label: MCP9808 Sensor list.
+    label: "https://boneio.eu/docs/black/configuration/mcp9808 \n MCP9808 Sensor list. Older boneIO Black had one MCP9808 instead of LM75on board, which measures temperature."
   schema:
     type: dict
     required: False
@@ -343,7 +352,7 @@ mcp23017:
   type: list
   required: False
   meta:
-    label: mcp23017 Pin config
+    label: "https://boneio.eu/docs/black/configuration/mcp23017 \n MCP23017 Pin config. All boneIO Black 32X10/Cover/Cover Mix/24x16 has two MCP23017 on board. If you use new boneio: section, then you don't need to define this."
   schema:
     type: dict
     schema:
@@ -369,7 +378,7 @@ pcf8575:
   type: list
   required: False
   meta:
-    label: pcf8575 Pin config
+    label: "https://boneio.eu/docs/black/configuration/pcf8575 \n PCF8575 Pin config. UNSTABLE."
   schema:
     type: dict
     schema:
@@ -395,7 +404,7 @@ pca9685:
   type: list
   required: False
   meta:
-    label: pca9685 Pin config
+    label: "https://boneio.eu/docs/black/configuration/pca9685 \n PCA9685 Pin config."
   schema:
     type: dict
     schema:
@@ -420,7 +429,7 @@ pca9685:
 output:
   type: list
   meta:
-    label: List of output relays
+    label: "https://boneio.eu/docs/black/configuration/output \n List of outputs to define."
   check_with: output_id_uniqueness
   schema:
     type: dict
@@ -505,7 +514,7 @@ output:
 output_group:
   type: list
   meta:
-    label: List of groupes outputs
+    label: "https://boneio.eu/docs/black/configuration/output_group \n List of groupes outputs to define. Output has to be defined first in output section!"
   check_with: output_id_uniqueness
   schema:
     type: dict
@@ -539,7 +548,7 @@ output_group:
 binary_sensor:
   type: list
   meta:
-    label: GPIO inputs section
+    label: "https://boneio.eu/docs/black/configuration/binary \n GPIO binary section of boneIO Black. It enables binary sensors in HA. It detects press and release states. It can run action based on states. It always send message to MQTT broker of invoked state."
   schema:
     type: dict
     schema:
@@ -651,7 +660,7 @@ binary_sensor:
 event:
   type: list
   meta:
-    label: GPIO inputs section
+    label: "https://boneio.eu/docs/black/configuration/event \n GPIO event entity section of boneIO Black. It enables event entities in HA. It detects single, double and long click. It can run action based on states. It always send message to MQTT broker of invoked state."
   schema:
     type: dict
     schema:
@@ -729,7 +738,7 @@ event:
 adc:
   type: list
   meta:
-    label: GPIO ADC section
+    label: "https://boneio.eu/docs/black/configuration/adc \n GPIO ADC section of boneIO Black. It enables ADC sensors in HA. Don't let them hang without use."
   schema:
     type: dict
     schema:
@@ -756,7 +765,7 @@ cover:
   type: list
   required: False
   meta:
-    label: Cover section
+    label: "https://boneio.eu/docs/black/configuration/cover \n Cover section of boneIO Black. It enables cover entities in HA. You'd need output config to use it first."
   schema:
     type: dict
     schema:
@@ -830,7 +839,7 @@ ds2482:
   type: list
   required: False
   meta:
-    label: DS2482 list
+    label: "https://boneio.eu/docs/black/configuration/ds2482 \n DS2482 section of boneIO Black. It enables DS2482 1 wire extenders, which you can use in sensor: config."
   schema:
     type: dict
     required: False
@@ -846,6 +855,8 @@ ds2482:
 dallas:
   type: dict
   required: False
+  meta:
+    label: "https://boneio.eu/docs/black/configuration/dallas \n Dallas section of boneIO Black. It enables Dallas bus in boneIO Black Kernel."
   schema:
     id:
       type: string
@@ -857,7 +868,7 @@ sensor:
   type: list
   required: False
   meta:
-    label: Sensor list. Currently only Dallas DS18B20 support.
+    label: Sensor list. Currently only Dallas DS18B20 and DS2482 support. Check DS18B20 or DS2482 section for more info.
   schema:
     type: dict
     schema:
@@ -897,7 +908,7 @@ boneio:
   type: dict
   required: False
   meta:
-    label: BoneIO configuration section
+    label: "https://boneio.eu/docs/black/0.9.x-dev/configuration/boneio \n BoneIO configuration section. It's new section for boneIO Black. It enables you to use predefined device types. For now only 0.7 and 0.8 devices are supported."
   schema:
     name:
       type: string
@@ -905,7 +916,9 @@ boneio:
       meta:
         label: Name of boneio. Default is Black.
     version:
-      type: string
+      type:
+        - float
+        - string
       coerce:
         - str
       required: False

{boneio-0.9.0.dev9 → boneio-0.9.0.dev12}/boneio/schema/update_interval.yaml

@@ -7,4 +7,4 @@ coerce:
 required: True
 default: 60s
 meta:
-  label: Update interval.
+  label: Update interval. How often to fetch data from sensor. Default to 60s.

{boneio-0.9.0.dev9 → boneio-0.9.0.dev12}/boneio/sensor/gpio_new.py

@@ -1,9 +1,10 @@
 """GpioInputBinarySensorNew to receive signals."""
 
 import logging
-from boneio.const import PRESSED, RELEASED, BOTH
-from boneio.helper import GpioBaseClass
 import time
+
+from boneio.const import BOTH, PRESSED, RELEASED
+from boneio.helper import GpioBaseClass
 from boneio.helper.gpio import add_event_callback, add_event_detect
 
 _LOGGER = logging.getLogger(__name__)

boneio-0.9.0.dev12/boneio/version.py

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