ets-to-homeassistant 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7bf61e1b960298191c6f9465cf0817b1343b5f8732a97db30b0abaacde94ccef
+  data.tar.gz: 8ef2e06491f0b08a9fd7511b677aa545af145c2a35ef7ad1e95d8691b93c25fc
+SHA512:
+  metadata.gz: b97e9426c6f44520e9e709bb748d7ddbd092d249c8b8611a9d71cbe9fe80739683e736721ae8cab4a8bc918cae1b5f272bd4dcc2c0c379454a58f7da22d0353b
+  data.tar.gz: efb10210a466e020a8bc59172e0affa36efe19695adab19430545d83f832d6459e3cfe2c54dbb74cf02ac758dc947ed8ac3cf4beb5a14ce526ef33acc3925fc7

checksums.yaml.gz.sig

@@ -0,0 +1,4 @@
+iS�w�����J�B<��r8����g�>q��t�۾o0��|=����LƹG���\�D;�����+c4,�
+�<��.F�E�t�,P�<��f���_�朳���Æ?6Lbp$;��p�Zg�V·�����@Ʊ�ꆵ��J��_|��'�q6^:�yo닌�w��,,i7�گN@�2�i��
+I�0��c���_�.�
+���TaJ~��$��Ҳ��{��LQ\8*�D>A����$��VI���ݵ��;��8��8�dX

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changes (Release notes)
+
+* 0.1
+
+  * New Features:
+    * initial version number
+    * option `--sort-by-name` to sort by object names in domains
+  * Issues Fixed:
+    * n/a
+  * Breaking Changes:
+    * Changed format for custom code and how data is passed back (`:custom` -> `:ha`, etc...)
+    * Custom function now access data through methods instead of hash

data/README.md

@@ -0,0 +1,258 @@
+# ETS project file to Home Assistant configuration
+
+A Ruby tool to convert an ETS5 project file (`*.knxproj`) into:
+
+* a YAML configuration file suitable for **Home Assistant** (requires to define building, functions and group data points in ETS)
+* an XML file for `linknx` (the object list only)
+
+[https://www.home-assistant.io/integrations/knx/](https://www.home-assistant.io/integrations/knx/)
+
+## Glossary
+
+* **KNX Group Address**: a group address is a 1, 2 or 3-level address in the KNX system, e.g. `1/2/3`.
+* **KNX Data Point Type**: a data point type is a type of data that can be sent on a group address, e.g. **1.001**, **5.001**.
+* **ETS Building Information**: In ETS, a building is a container for rooms and **ETS Function**.
+* **ETS Function** : In ETS, represents an object that has several **KNX Group Address** associated to it.
+* **HA Device** : In Home Assistant, a device has a type (e.g.`light`) and has **HA Config Variable**.
+* **HA Config Variable** : In Home Assistant, it's a property of a device, e.g.`name`,`address`,`state_address`.
+
+## Important note
+
+In order for the tool to generate result properly read the following.
+
+An actionable entity in KNX is a **KNX Group Address**: commands are exchanged in a group address on the KNX Bus.
+For example a dimmable light has at least one group address for On/Off and another for the dimming value.
+
+An actionable entity in **Home Assistant** is an **HA Device**.
+For example, a dimmable light is a device and has properties, one of them is the group address for On/Off and another is the group address for the dimming value.
+
+So, for this tool to work, the following pieces of information must be found:
+
+* **KNX Group Address**
+* The purpose for each **KNX Group Address** (typically, a **KNX Data Point Type**)
+* Grouping of group addresses into devices : e.g. **ETS Function** in ETS mapped to **HA Device** in Home Assistant
+
+By default, and in fact in a lot of ETS projects, only group addresses are defined as this is sufficient for an installation.
+I.e. no **ETS Function** is defined, and **KNX Data Point Type**s are not defined for group addresses.
+This is why this tool will not work out of the box most of the times: missing information.
+The next 2 sections explain how to fix this.
+
+### Group address: Type
+
+**KNX Group Address**es are defined in the ETS project file naturally, as it is the base for the system to work.
+But we need the types of them (e.g. **on/off** versus **dim value**) in order to create the HA configuration.
+
+The best, easiest and most reliable way for the tool to find the type of **KNX Group Address** is to specify the **KNX Data Point Type** in the **KNX Group Address** itself in ETS.
+This requires editing the KNX project.
+Refer to [Structure in ETS](#structure-in-ets).
+
+Another possibility is to create a custom script.
+Refer to [Custom method](#custom-method)
+
+### Group address: Grouping into devices
+
+The second part is to regroup **KNX Group Address**es into **HA Device**.
+This is best done by creating **ETS Function** in ETS.
+Refer to [Structure in ETS](#structure-in-ets).
+
+Another possibility is to create a custom script.
+Refer to [Custom method](#custom-method)
+
+## Installation
+
+1. [Install Ruby for your platform](https://www.ruby-lang.org/fr/downloads/):
+
+    * Windows: [Ruby Installer](https://rubyinstaller.org/)
+    * macOS: builtin, or [RVM](https://rvm.io/), or [brew](https://brew.sh/), or [rbenv](https://github.com/rbenv/rbenv)
+    * Linux: builtin (yum, apt), or [RVM](https://rvm.io/), or [rbenv](https://github.com/rbenv/rbenv)
+
+2. Install this gem
+
+    ```bash
+    gem install ets-to-homeassistant
+    ```
+
+3. Test it works:
+  
+      ```bash
+      ets_to_hass --help
+      ```
+
+## Usage
+
+General invocation syntax:
+
+```bash
+Usage: .ets_to_hass [options] <ets project file>.knxproj
+
+    -h, --help
+      show help
+
+    --ha-knx
+      include level knx in output file
+
+    --sort-by-name
+      sort arrays by name
+
+    --full-name
+      add room name in object name
+
+    --format [format]
+      one of homeass|linknx
+
+    --fix [ruby file]
+      file with specific code to fix objects
+
+    --addr [addr]
+      one of Free, TwoLevel, ThreeLevel
+
+    --trace [trace]
+      one of debug, info, warn, error
+
+    --output [file]
+      add room name in object name```
+
+For example to generate the home assistant KNX configuration from the exported ETS project: `myexport.knxproj`
+
+```bash
+ets_to_hass --full-name --format homeass --output config_knx.yaml myexport.knxproj
+```
+
+Option `--ha-knx` adds the dictionary key `knx` in the generated Home Assistant configuration so that it can be copy/paste in `configuration.yaml`.
+Else, typically, include the generated entities in a separate file like this:
+
+```yaml
+knx: !include config_knx.yaml
+```
+
+If option `--fix` with a path to a non-existing file, then the tool will create a template file with the default code.
+It will generate basic Objects/Functions for group addresses not part of a function.
+
+Logs are sent to STDERR.
+
+## Internal logic
+
+The tool takes the exported file from ETS with extension: `knxproj`.
+The project file is a zip with several XML files in it.
+Make sure that the project file is not password protected.
+
+* The tool parses the first project file found.
+* It extracts **ETS Building Information** and **KNX Group Address**es.
+* A Ruby object of type: `EtsToHass` is created, with the following fields:
+
+  `@groups_addresses` contains all **KNX Group Address**es, `_gaid_` is the internal identifier of the **KNX Group Address** in ETS
+
+  `@objects` contains all **ETS Function**, `_obid_` is the internal identifier of the **ETS Function** in ETS
+
+```ruby
+@groups_addresses = {
+  _gaid_ => {
+   name:             "from ETS",
+   description:      "from ETS",
+   address:          group address as string. e.g. "x/y/z" depending on project style,
+   datapoint:        datapoint type as string "x.abc", e.g. 1.001,
+   ha:               {address_type: '...' } # set by specific code, HA parameter for address
+  },...
+}
+@objects = {
+  _obid_ => {
+   name:   "from ETS, either function name or full name with room if option --full-name is used",
+   type:   "ETS function type, see below",
+   floor:  "from ETS",
+   room:   "from ETS",
+   ha:     {domain: '...', ha parameters... } # set by specific code, HA parameters
+  },...
+ }
+@associations = [[_gaid_,_obid_],...]
+```
+
+* a default mapping is proposed in methods:
+  
+  * `map_ets_datapoint_to_ha_address_type` : default value for `@group_addresses[x][:ha][:address_type]`
+  * `map_ets_function_to_ha_object_category` : default value for `@objects[x][:ha][:domain]`
+
+* the custom specific code is called giving an opportunity to modify this structure.
+
+* Eventually, the HA configuration is generated
+
+## Structure in ETS
+
+The **KNX Data Point Type** of **KNX Group Address** is used to find out the associated **HA Config Variable**.
+In ETS, for each **KNX Group Address**, make sure to define the **KNX Data Point Type** as in the following screenshot:
+
+![datapoint in group address](images/ets5_datapoint.png)
+
+**ETS Building Information** and **ETS Function** are used to generate HA devices.
+If the ETS project has no **ETS Building Information**, then the tool will create one **HA Device** per **KNX Group Address**.
+
+In the following screenshot, note that both **KNX Group Address** and **ETS Function** are created.
+
+![ETS 5 with building functions](images/ets5.png)
+
+Moreover, if **ETS Function** are located properly in **ETS Building Information** levels and rooms, the tool will read this information.
+
+When **ETS Function** are found, the tool will populate the `@objects` `Hash`.
+
+The type of **ETS Function** is identified by a name (in ETS project file it is `FT-[n]`):
+
+* `:custom`
+* `:switchable_light`
+* `:dimmable_light`
+* `:sun_protection`
+* `:heating_radiator`
+* `:heating_floor`
+* `:heating_switching_variable`
+* `:heating_continuous_variable`
+
+## Custom method
+
+If the **KNX Data Point Type** of a **KNX Group Address** is not defined in the ETS project, then the tool cannot guess which group address is e.g. for On/Off, or for dimming value.
+
+If no **ETS Building Information** with **ETS Function** was created in the project, then the tool cannot guess which set of **KNX Group Address** refer to the same **HA Device**.
+
+It is possible to add this information using option `--fix` (custom script) which can add missing information, based, for example, on the name of the **KNX Group Address**.
+
+For example, I used to use a naming convention like: `<room>:<object>:<type>` before using ETS features, and the custom script could guess the missing data type from `<type>`, and then group addresses into devices based on `<room>` and `<object>`.
+
+But if the convention is to place `ON/OFF` in `1/x/x` then you can use the first address identifier to guess the type of **KNX Group Address**.
+
+The specific code can modify the analyzed structure:
+
+* It can delete objects, or create objects.
+* It can add fields in the `:ha` properties:
+
+  * in `@group_addresses`:
+    * `address_type` : define the use for the group address, e.g. `address`, `state_address`, etc...
+  * in `@objects`:
+    * `domain` : set the entity type in HA (`switch`, `light`, etc), this key is then removed from the `Hash`
+    * **Other fields** : initialize the HA object with these values, e.g. `name`
+
+The function can use any information such as fields of the object, or description or name of group address for that.
+
+Typically, the name of group addresses can be used if a specific naming convention was used.
+Or, if group addresses were defined using a specific convention: for example in a/b/c a is the type of action, b is the identifier of device...
+
+The specific code shall be like this:
+
+```ruby
+def fix_objects(generator)
+  # use methods of generator to modify the structure
+end
+```
+
+## Linknx
+
+`linknx` does not have an object concept, and needs only group addresses.
+
+## XKNX
+
+Support is dropped for the moment, until needed, but it is close enough to HA.
+
+## Reporting issues
+
+Include the version of ETS used and logs.
+
+## TODO
+
+One possibility would be to add extra information in the description of the group address and/or function in ETS, and then parse it in the tool.
+For example, as YAML format.

data/bin/ets_to_hass

@@ -0,0 +1,111 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# add in case we are in dev
+$LOAD_PATH.unshift(File.join(File.dirname(__dir__), 'lib'))
+
+begin
+  require 'ets_to_hass/string_colors'
+  require 'ets_to_hass/generator'
+  require 'getoptlong'
+rescue LoadError => e
+  puts(e.backtrace.join("\n"))
+  puts("Missing gems (#{e}): read the manual: execute:")
+  puts("gem install bundler\nbundle install".blink)
+  exit(1)
+end
+
+# prefix of generation methods
+GENE_PREFIX = 'generate_'
+# get list of generation methods
+gene_formats = (EtsToHass::Generator.instance_methods - EtsToHass::Generator.superclass.instance_methods)
+               .select { |m| m.to_s.start_with?(GENE_PREFIX) }
+               .map { |m| m[GENE_PREFIX.length..-1] }
+
+opts = GetoptLong.new(
+  ['--help', '-h', GetoptLong::NO_ARGUMENT],
+  ['--ha-knx', '-k', GetoptLong::NO_ARGUMENT],
+  ['--sort-by-name', '-r', GetoptLong::NO_ARGUMENT],
+  ['--full-name', '-n', GetoptLong::NO_ARGUMENT],
+  ['--format', '-f', GetoptLong::REQUIRED_ARGUMENT],
+  ['--fix', '-s', GetoptLong::REQUIRED_ARGUMENT],
+  ['--addr', '-a', GetoptLong::REQUIRED_ARGUMENT],
+  ['--trace', '-t', GetoptLong::REQUIRED_ARGUMENT],
+  ['--output', '-o', GetoptLong::REQUIRED_ARGUMENT]
+)
+
+options = {}
+output_format = 'homeass'
+opts.each do |opt, arg|
+  case opt
+  when '--help'
+    puts <<~END_OF_MANUAL
+      Usage: #{$PROGRAM_NAME} [options] <ets project file>.knxproj
+
+          -h, --help
+            show help
+
+          --ha-knx
+            include level knx in output file
+
+          --sort-by-name
+            sort arrays by name
+
+          --full-name
+            add room name in object name
+
+          --format [format]
+            one of #{gene_formats.join('|')}
+
+          --fix [ruby file]
+            file with specific code to fix objects
+
+          --addr [addr]
+            one of #{EtsToHass::Generator::GROUP_ADDRESS_PARSERS.keys.map(&:to_s).join(', ')}
+
+          --trace [trace]
+            one of debug, info, warn, error
+
+          --output [file]
+            add room name in object name
+    END_OF_MANUAL
+    Process.exit(1)
+  when '--fix'
+    options[:specific] = arg
+  when '--format'
+    output_format = arg
+    raise "Error: no such output format: #{output_format}" unless gene_formats.include?(output_format)
+  when '--ha-knx'
+    options[:ha_knx] = true
+  when '--sort-by-name'
+    options[:sort_by_name] = true
+  when '--full-name'
+    options[:full_name] = true
+  when '--trace'
+    options[:trace] = arg
+  when '--addr'
+    options[:addr] = arg
+  when '--output'
+    options[:output] = arg
+  else
+    raise "Unknown option #{opt}"
+  end
+end
+
+if ARGV.length != 1
+  puts 'Missing project file argument (try --help)'
+  Process.exit(1)
+end
+
+output_file =
+  if options[:output]
+    File.open(options[:output], 'w')
+  else
+    $stdout
+  end
+project_file_path = ARGV.shift
+
+# read and parse ETS file
+generator = EtsToHass::Generator.new(project_file_path, options)
+# generate result (e.g. call generate_homeass)
+output_file.write(generator.send(:"#{GENE_PREFIX}#{output_format}"))

data/lib/ets_to_hass/generator.rb

@@ -0,0 +1,364 @@
+# frozen_string_literal: true
+
+require 'zip'
+require 'xmlsimple'
+require 'yaml'
+require 'json'
+require 'logger'
+require 'fileutils'
+require 'ets_to_hass/string_colors'
+require 'ets_to_hass/info'
+
+module EtsToHass
+  # Import ETS project file and generate configuration for Home Assistant and KNXWeb
+  class Generator
+    # extension of ETS project file
+    ETS_EXT = '.knxproj'
+    # converters of group address integer address into representation
+    GROUP_ADDRESS_PARSERS = {
+      Free:       ->(a) { a.to_s },
+      TwoLevel:   ->(a) { [(a >> 11) & 31, a & 2047].join('/') },
+      ThreeLevel: ->(a) { [(a >> 11) & 31, (a >> 8) & 7, a & 255].join('/') }
+    }.freeze
+    # KNX functions described in knx_master.xml in project file, in <FunctionTypes>
+    # map index parsed from "FT-x" to recognizable identifier
+    ETS_FUNCTIONS_INDEX_TO_NAME =
+      %i[custom switchable_light dimmable_light sun_protection heating_radiator heating_floor
+         dimmable_light sun_protection heating_switching_variable heating_continuous_variable].freeze
+    private_constant :ETS_EXT, :ETS_FUNCTIONS_INDEX_TO_NAME
+
+    # class methods
+    class << self
+      # helper function to dig through keys, knowing that we used ForceArray
+      def dig_xml(entry_point, path)
+        raise "ERROR: wrong entry point: #{entry_point.class}, expect Hash" unless entry_point.is_a?(Hash)
+
+        path.each do |n|
+          raise "ERROR: cannot find level #{n} in xml, have #{entry_point.keys.join(',')}" unless entry_point.key?(n)
+
+          entry_point = entry_point[n]
+          # because we use ForceArray
+          entry_point = entry_point.first
+          raise "ERROR: expect array with one element in #{n}" if entry_point.nil?
+        end
+        entry_point
+      end
+
+      def function_type_to_name(ft_type)
+        m = ft_type.match(/^FT-([0-9])$/)
+        raise "ERROR: Unknown function type: #{ft_type}" if m.nil?
+
+        ETS_FUNCTIONS_INDEX_TO_NAME[m[1].to_i]
+      end
+
+      def specific_defined?
+        defined?(fix_objects).eql?('method')
+      end
+    end
+
+    def initialize(file, options = {})
+      # command line options
+      @opts = options
+      # parsed data: ob: objects (ETS functions), ga: group addresses
+      @objects = {}
+      @group_addresses = {}
+      @associations = []
+      # log to stderr, so that redirecting stdout captures only generated data
+      @logger = Logger.new($stderr)
+      @logger.level = @opts.key?(:trace) ? @opts[:trace] : Logger::INFO
+      @logger.debug("options: #{@opts}")
+      # read .knxproj file xml into project variable
+      project = read_file(file)
+      # find out address style
+      proj_info = self.class.dig_xml(project[:info], %w[Project ProjectInformation])
+      @group_addr_style = (@opts[:addr] || proj_info['GroupAddressStyle']).to_sym
+      raise "Error: no such style #{@group_addr_style} in #{GROUP_ADDRESS_PARSERS.keys}" if GROUP_ADDRESS_PARSERS[@group_addr_style].nil?
+
+      @logger.info("Using project #{proj_info['Name']}, address style: #{@group_addr_style}")
+      # locate main node in xml
+      installation = self.class.dig_xml(project[:data], %w[Project Installations Installation])
+      # process group ranges: fill @group_addresses
+      process_group_ranges(self.class.dig_xml(installation, %w[GroupAddresses GroupRanges]))
+      # process group ranges: fill @objects (for 2 versions of ETS which have different tags?)
+      process_space(self.class.dig_xml(installation, ['Locations']), 'Space') if installation.key?('Locations')
+      process_space(self.class.dig_xml(installation, ['Buildings']), 'BuildingPart') if installation.key?('Buildings')
+      @logger.warn('No building information found.') if @objects.keys.empty?
+      return unless @opts[:specific]
+      unless File.exist?(@opts[:specific])
+        @logger.warn("Specific code file #{@opts[:specific]} not found, creating generic one.")
+        FileUtils.cp(File.join(File.dirname(__FILE__), 'specific', 'generic.rb'), @opts[:specific])
+      end
+      # load specific code
+      load(@opts[:specific])
+      raise "no method found in #{@opts[:specific]}" unless self.class.specific_defined?
+    end
+
+    def warning(entity, name, message)
+      @logger.warn("#{entity.red} #{name.green} #{message}")
+    end
+
+    # format the integer group address to string in desired style (e.g. 1/2/3)
+    def parse_group_address(group_address)
+      GROUP_ADDRESS_PARSERS[@group_addr_style].call(group_address.to_i).freeze
+    end
+
+    # Read both project.xml and 0.xml
+    # @return Hash {info: xml data, data: xml data}
+    def read_file(file)
+      raise "ETS file must end with #{ETS_EXT}" unless file.end_with?(ETS_EXT)
+
+      project = {}
+      # read ETS5 file and get project file
+      Zip::File.open(file) do |zip_file|
+        zip_file.each do |entry|
+          case entry.name
+          when %r{P-[^/]+/project\.xml$}
+            project[:info] = XmlSimple.xml_in(entry.get_input_stream.read, { 'ForceArray' => true })
+          when %r{P-[^/]+/0\.xml$}
+            project[:data] = XmlSimple.xml_in(entry.get_input_stream.read, { 'ForceArray' => true })
+          end
+        end
+      end
+      raise "Did not find project information or data (#{project.keys})" unless project.keys.sort.eql?(%i[data info])
+
+      project
+    end
+
+    # process group range recursively and find addresses
+    def process_group_ranges(group)
+      group['GroupRange'].each { |sgr| process_group_ranges(sgr) } if group.key?('GroupRange')
+      group['GroupAddress'].each { |group_address| process_ga(group_address) } if group.key?('GroupAddress')
+    end
+
+    # process a group address
+    def process_ga(group_address)
+      # build object for each group address
+      group = {
+        name:        group_address['Name'].freeze, # ETS: name field
+        description: group_address['Description'].freeze, # ETS: description field
+        address:     parse_group_address(group_address['Address']), # group address as string. e.g. "x/y/z" depending on project style
+        datapoint:   nil, # datapoint type as string "x.00y"
+        ha:          { address_type: nil } # prepared to be potentially modified by specific code
+      }
+      if group_address['DatapointType'].nil?
+        warning(group[:address], group[:name], 'no datapoint type for address group, to be defined in ETS, skipping')
+        return
+      end
+      # parse datapoint for easier use
+      if (m = group_address['DatapointType'].match(/^DPST-([0-9]+)-([0-9]+)$/))
+        # datapoint type as string x.00y
+        group[:datapoint] = format('%d.%03d', m[1].to_i, m[2].to_i) # no freeze
+      else
+        warning(group[:address], group[:name],
+                "Cannot parse data point type: #{group_address['DatapointType']} (DPST-x-x), skipping")
+        return
+      end
+      # Index is the internal Id in xml file
+      @group_addresses[group_address['Id'].freeze] = group.freeze
+      @logger.debug("group: #{group}")
+    end
+
+    # process locations recursively, and find functions
+    # @param space the current space
+    # @param space_type the type of space: Space or BuildingPart
+    # @param info current location information: floor, room
+    def process_space(space, space_type, info = nil)
+      info = info.nil? ? {} : info.dup
+      @logger.debug("space: #{space['Type']}: #{space['Name']} (#{info})")
+      # process building sub spaces
+      if space.key?(space_type)
+        # get floor when we have it
+        info[:floor] = space['Name'] if space['Type'].eql?('Floor')
+        # recursively process sub-spaces
+        space[space_type].each { |s| process_space(s, space_type, info) }
+      end
+      # Functions are objects
+      return unless space.key?('Function')
+
+      # we assume the object is directly in the room
+      info[:room] = space['Name']
+      # loop on group addresses
+      space['Function'].each do |ets_function|
+        # @logger.debug("function #{ets_function}")
+        # ignore functions without group address
+        next unless ets_function.key?('GroupAddressRef')
+
+        # the ETS object, created from ETS function
+        ets_object = {
+          name: ets_function['Name'].freeze,
+          type: self.class.function_type_to_name(ets_function['Type']),
+          ha:   { domain: nil } # hone assistant values
+        }.merge(info)
+        add_object(ets_function['Id'], ets_object)
+        ets_function['GroupAddressRef'].map { |g| g['RefId'].freeze }.each do |group_address_id|
+          associate(ga_id: group_address_id, object_id: ets_function['Id'])
+        end
+        @logger.debug("function: #{ets_object}")
+      end
+    end
+
+    # map ETS function to home assistant object type
+    # see https://www.home-assistant.io/integrations/knx/
+    def map_ets_function_to_ha_object_category(ets_func)
+      # map FT-x type to home assistant type
+      case ets_func[:type]
+      when :switchable_light, :dimmable_light then 'light'
+      when :sun_protection then 'cover'
+      when :custom, :heating_continuous_variable, :heating_floor, :heating_radiator, :heating_switching_variable
+        @logger.warn("#{ets_func[:room].red} #{ets_func[:name].green} function type #{ets_func[:type].to_s.blue} not implemented")
+        nil
+      else @logger.error("#{ets_func[:room].red} #{ets_func[:name].green} function type #{ets_func[:type].to_s.blue} not supported, please report")
+           nil
+      end
+    end
+
+    # map datapoint to home assistant type
+    # see https://www.home-assistant.io/integrations/knx/
+    def map_ets_datapoint_to_ha_address_type(group_address, ha_object_domain)
+      case group_address[:datapoint]
+      when '1.001' then 'address' # switch on/off or state
+      when '1.008' then 'move_long_address' # up/down
+      when '1.010' then 'stop_address' # stop
+      when '1.011' then 'state_address' # switch state
+      when '3.007'
+        @logger.debug("#{group_address[:address]}(#{ha_object_domain}:#{group_address[:datapoint]}:#{group_address[:name]}): ignoring datapoint")
+        nil # dimming control: used by buttons
+      when '5.001' # percentage 0-100
+        # user-provided code tells what is state
+        case ha_object_domain
+        when 'light' then 'brightness_address'
+        when 'cover' then 'position_address'
+        else
+          warning(group_address[:address], group_address[:name], "#{group_address[:datapoint]} expects: light or cover, not #{ha_object_domain.magenta}")
+          nil
+        end
+      else
+        warning(group_address[:address], group_address[:name], "un-managed datapoint #{group_address[:datapoint].blue} (#{ha_object_domain.magenta})")
+        nil
+      end
+    end
+
+    # @param ga_id group address id
+    # @returns array of objects for this group id
+    def ga_object_ids(ga_id)
+      @associations.select { |a| a[:ga_id].eql?(ga_id) }.map { |a| a[:object_id] }
+    end
+
+    def all_object_ids
+      @objects.keys
+    end
+
+    # @param object_id object id
+    # @returns array of group addresses for this object
+    def object_ga_ids(object_id)
+      @associations.select { |a| a[:object_id].eql?(object_id) }.map { |a| a[:ga_id] }
+    end
+
+    def all_ga_ids
+      @group_addresses.keys
+    end
+
+    def associate(ga_id:, object_id:)
+      @associations.push({ ga_id: ga_id, object_id: object_id })
+    end
+
+    def delete_object(object_id)
+      @objects.delete(object_id)
+      @associations.delete_if { |a| a[:object_id].eql?(object_id) }
+    end
+
+    def add_object(object_id, object)
+      # objects will not be modified, this shall be what comes from ETS only, use field `ha` for specific code
+      @objects[object_id] = object.freeze
+    end
+
+    def object(object_id)
+      @objects[object_id]
+    end
+
+    def group_address_data(ga_id)
+      @group_addresses[ga_id]
+    end
+
+    # This creates the Home Assistant configuration in variable ha_config
+    # based on data coming from ETS
+    # and optionally modified by specific code in apply_specific
+    def generate_homeass
+      # First, apply user-provided specific code
+      if self.class.specific_defined?
+        @logger.info("Applying fix code from #{@opts[:specific]}")
+        fix_objects(self)
+      end
+      # This will be the YAML for HA
+      ha_config = {}
+      # warn of group addresses that will not be used (you can fix in specific code)
+      all_ga_ids.each do |ga_id|
+        next unless ga_object_ids(ga_id).empty?
+        ga_data = group_address_data(ga_id)
+        warning(ga_data[:address], ga_data[:name], 'Group not in object: use ETS to create functions or use specific code')
+      end
+      # Generate devices from either functions in ETS, or from specific code
+      all_object_ids.each do |object_id|
+        ets_object = object(object_id)
+        # compute object domain, this is the section in HA configuration (switch, light, etc...)
+        ha_object_domain = ets_object[:ha].delete(:domain) || map_ets_function_to_ha_object_category(ets_object)
+        if ha_object_domain.nil?
+          warning(ets_object[:name], ets_object[:room], "#{ets_object[:type].to_s.blue}: function type not detected, skipping")
+          next
+        end
+        # add domain to config, if necessary
+        ha_config[ha_object_domain] ||= []
+        # HA configuration object, either empty or initialized in specific code
+        ha_device = ets_object[:ha]
+        # default name
+        ha_device['name'] ||= @opts[:full_name] ? "#{ets_object[:name]} #{ets_object[:room]}" : ets_object[:name]
+        # check name is not duplicated, as name is used to identify the object
+        if ha_config[ha_object_domain].any? { |v| v['name'].casecmp?(ha_device['name']) }
+          @logger.warn("#{ha_device['name'].red} object name is duplicated (check ETS objects and rooms)")
+        end
+        # add object to configuration
+        ha_config[ha_object_domain].push(ha_device)
+        # process all group addresses in ETS function (object)
+        object_ga_ids(object_id).each do |group_address_id|
+          # get this group information
+          ga_data = group_address_data(group_address_id)
+          if ga_data.nil?
+            @logger.error("#{ets_object[:name].red} #{ets_object[:room].green} (#{ets_object[:type].to_s.magenta}): #{group_address_id}: group address not found, skipping")
+            next
+          end
+          # find HA property name based on datapoint
+          ha_address_type = ga_data[:ha][:address_type] || map_ets_datapoint_to_ha_address_type(ga_data, ha_object_domain)
+          next if ha_address_type.eql?(:ignore)
+          if ha_address_type.nil?
+            warning(ga_data[:address], ga_data[:name],
+                    "#{ga_data[:datapoint].blue} / #{ha_object_domain.magenta}: address type not detected, skipping")
+            next
+          end
+          if ha_device.key?(ha_address_type)
+            @logger.error("#{ga_data[:address].red} #{ga_data[:name].green} (#{ha_object_domain.magenta}:#{ga_data[:datapoint]}) #{ha_address_type} already set with #{ha_device[ha_address_type]}, skipping")
+            # TODO: support passive addresses ?
+            next
+          end
+          # ok, we have the property name and group address
+          ha_device[ha_address_type] = ga_data[:address]
+        end
+      end
+      if @opts[:sort_by_name]
+        @logger.info('Sorting by name')
+        ha_config.each_value { |v| v.sort_by! { |o| o['name'] } }
+      end
+      # add knx level, if user asks for it
+      ha_config = { 'knx' => ha_config } if @opts[:ha_knx]
+      ha_config.to_yaml
+    end
+
+    # https://sourceforge.net/p/linknx/wiki/Object_Definition_section/
+    def generate_linknx
+      @group_addresses.values.sort { |a, b| a[:address] <=> b[:address] }.map do |ga_data|
+        linknx_name = ga_data[:name]
+        linknx_id = "id_#{ga_data[:address].gsub('/', '_')}"
+        %Q(        <object type="#{ga_data[:datapoint]}" id="#{linknx_id}" gad="#{ga_data[:address]}" init="request">#{linknx_name}</object>)
+      end.join("\n")
+    end
+  end
+end

data/lib/ets_to_hass/info.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module EtsToHass
+  NAME = 'ets-to-homeassistant'
+  VERSION = '0.1'
+  SRC_URL = 'https://github.com/laurent-martin/ets-to-homeassistant'
+  GEM_URL = 'https://github.com/laurent-martin/ets-to-homeassistant'
+  DOC_URL = 'https://github.com/laurent-martin/ets-to-homeassistant'
+end

data/lib/ets_to_hass/specific/generic.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# This example of custom method creates one object per group address.
+# It's not right, but it's simple.
+
+def fix_objects(generator)
+  # generate new objects sequentially
+  new_object_id = 0
+  # loop on group addresses
+  generator.all_ga_ids.each do |ga_id|
+    # skip if group address already assigned to an object
+    next unless generator.ga_object_ids(ga_id).empty?
+    ga_data = generator.group_address_data(ga_id)
+    # generate a dummy object with a single group address
+    generator.add_object(
+      new_object_id, {
+        name:  ga_data[:name],
+        type:  :custom, # unknown type of object, switch ?
+        floor: 'unknown floor',
+        room:  'unknown room',
+        ha:    { domain: 'switch' }
+      }
+    )
+    generator.associate(ga_id: ga_id, object_id: new_object_id)
+    # prepare next object identifier
+    new_object_id += 1
+  end
+end

data/lib/ets_to_hass/specific/laurent.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# I can detect HA object address type based on group address
+GROUP_TO_ADDR_TYPE = {
+  '/1/' => 'state_address',
+  '/4/' => 'brightness_state_address'
+}.freeze
+DATAPOINT_TO_ADDR_TYPE = {
+  '3.007' => :ignore # action "up" / "down"
+}.freeze
+
+# Laurent's specific code for KNX configuration
+def fix_objects(generator)
+  # loop on objects to find blinds
+  # I have two types of blinds: normal and special
+  # "normal" blinds have a single GA for up/down
+  # "special" blinds have 2 GA: one for up, one for down, and are managed like a switch, so I declare 2 objects for them
+  generator.all_object_ids.each do |obj_id|
+    object = generator.object(obj_id)
+    # customs are switches
+    object[:ha][:domain] ||= 'switch' if object[:type].eql?(:custom)
+    # need only to manage covers/blinds
+    next unless object[:type].eql?(:sun_protection)
+    group_ids = object_ga_ids(obj_id)
+    # manage in special manner my blinds, identified by "pulse" in address group name
+    if group_address_data(group_ids.first)[:name].end_with?(':Pulse')
+      # delete current object: will be split into 2
+      generator.delete_object(obj_id)
+      # loop on GA for this object (one for up and one for down)
+      group_ids.each do |ga_id|
+        ga_data = group_address_data(ga_id)
+        # get direction of GA based on name
+        direction =
+          case ga_data[:name]
+          when /Montee/ then 'Montee'
+          when /Descente/ then 'Descente'
+          else raise "error: #{ga_data[:name]}"
+          end
+        # fix datapoint for GA (I have set up/down in ETS)
+        ga_data[:datapoint].replace('1.001')
+        new_object_id = "#{obj_id}_#{direction}"
+        # create new object
+        generator.add_object(
+          new_object_id,
+          {
+            name:  "#{object[:name]} #{direction}",
+            type:  :custom, # simple switch
+            floor: object[:floor],
+            room:  object[:room],
+            ha:    { domain: 'switch' }
+          }
+        )
+        generator.associate(ga_id: ga_id, object_id: new_object_id)
+      end
+    else
+      # set my specific times
+      object[:ha].merge!(
+        { 'travelling_time_down' => 59,
+          'travelling_time_up'   => 59 }
+      )
+    end
+  end
+  # lights: I use x/1/x for state and x/4/x for brightness state
+  generator.all_ga_ids.each do |ga_id|
+    ga_data = generator.group_address_data(ga_id)
+    GROUP_TO_ADDR_TYPE.each do |pattern, addr_type|
+      ga_data[:ha][:address_type] = addr_type if ga_data[:address].include?(pattern)
+    end
+    DATAPOINT_TO_ADDR_TYPE.each do |pattern, addr_type|
+      ga_data[:ha][:address_type] = addr_type if ga_data[:datapoint].eql?(pattern)
+    end
+  end
+end

data/lib/ets_to_hass/specific/specific2.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# This example of custom method uses group address description to figure out devices
+PREFIX = {
+  'ECL_On/Off '      => { address_type: 'address', domain: 'light' },
+  # 'ECL_VAL ' => {address_type: 'todo1',domain: 'light'},
+  # 'État_ECL_VAL ' => {address_type: 'todo2',domain: 'light'},
+  'État_ECL_On/Off ' => { address_type: 'state_address', domain: 'light' },
+  'ECL_VAR '         => { address_type: 'brightness_address', domain: 'light' },
+  'Pos._VR_% '       => { address_type: 'position_address', domain: 'cover' },
+  'M/D_VR '          => { address_type: 'move_long_address', domain: 'cover' }
+  # 'État_Pos._VR_% ' => {address_type: 'todo',domain: 'cover'},
+  # 'T°_Amb.  ' => {address_type: 'type4',domain: 'light'},
+  # 'Dét._Prés. ' => {address_type: 'type4',domain: 'light'},
+}.freeze
+
+# generate
+def fix_objects(generator)
+  # loop on group addresses
+  generator.all_ga_ids.each do |ga_id|
+    # ignore if the group address is already in an object
+    next unless generator.ga_object_ids(ga_id).empty?
+    ga_data = generator.group_address_data(ga_id)
+    obj_name = nil
+    object_domain = nil
+    # try to guess an object name from group address name
+    PREFIX.each do |prefix, info|
+      next unless ga_data[:name].start_with?(prefix)
+      obj_name = ga_data[:name][prefix.length..]
+      ga_data[:ha][:address_type] = info[:address_type]
+      object_domain = info[:domain]
+      break
+    end
+    if obj_name.nil?
+      warn("unknown:#{ga_data}")
+      next
+    end
+
+    # use name as id, so that we can easily group GAs
+    obj_id = obj_name
+
+    if generator.object(obj_id).nil?
+      generator.add_object(
+        obj_id, {
+          name:  obj_name,
+          type:  :custom, # unknown, so assume just switch
+          floor: 'unknown floor',
+          room:  'unknown room',
+          ha:    { domain: object_domain }
+        }
+      )
+    end
+    generator.associate(ga_id: ga_id, object_id: obj_id)
+  end
+end

data/lib/ets_to_hass/string_colors.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# Add colors
+class String
+  class << self
+    private
+
+    def vt_cmd(code)
+      "\e[#{code}m"
+    end
+  end
+  # see https://en.wikipedia.org/wiki/ANSI_escape_code
+  # symbol is the method name added to String
+  # it adds control chars to set color (and reset at the end).
+  VT_STYLES = {
+    bold:          1,
+    dim:           2,
+    italic:        3,
+    underline:     4,
+    blink:         5,
+    reverse_color: 7,
+    invisible:     8,
+    black:         30,
+    red:           31,
+    green:         32,
+    brown:         33,
+    blue:          34,
+    magenta:       35,
+    cyan:          36,
+    gray:          37,
+    bg_black:      40,
+    bg_red:        41,
+    bg_green:      42,
+    bg_brown:      43,
+    bg_blue:       44,
+    bg_magenta:    45,
+    bg_cyan:       46,
+    bg_gray:       47
+  }.freeze
+  private_constant :VT_STYLES
+  # defines methods to String, one per entry in VT_STYLES
+  VT_STYLES.each do |name, code|
+    if $stderr.tty?
+      begin_seq = vt_cmd(code)
+      end_code = 0 # by default reset all
+      if code <= 7 then code + 20
+      elsif code <= 37 then 39
+      elsif code <= 47 then 49
+      end
+      end_seq = vt_cmd(end_code)
+      define_method(name) { "#{begin_seq}#{self}#{end_seq}" }
+    else
+      define_method(name) { self }
+    end
+  end
+end

metadata

@@ -0,0 +1,253 @@
+--- !ruby/object:Gem::Specification
+name: ets-to-homeassistant
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Laurent Martin
+autorequire:
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDkjCCAnqgAwIBAgIBATANBgkqhkiG9w0BAQsFADBHMRkwFwYDVQQDDBBsYXVy
+  ZW50Lm1hcnRpbi5sMRUwEwYKCZImiZPyLGQBGRYFZ21haWwxEzARBgoJkiaJk/Is
+  ZAEZFgNjb20wHhcNMjMxMjMxMTc1NjA2WhcNMjcwMTA0MTc1NjA2WjBHMRkwFwYD
+  VQQDDBBsYXVyZW50Lm1hcnRpbi5sMRUwEwYKCZImiZPyLGQBGRYFZ21haWwxEzAR
+  BgoJkiaJk/IsZAEZFgNjb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB
+  AQDEkaJ9DiTfuwZ00qWDbyb7jwZvYsuMCQ96gkoKj+97fUUq8PtZBQd88KAdCHYA
+  FAYQ2oeUz6viAylMkg5RUqd4CxnFU7Udozmnw3qyQksUsxLjbBnhg8Ye5icsumT8
+  T0O9jlKJ0xKW24INLghVrmyrh8qzH4EcwAUceuHB0BziMP2ZfuaiDvmEVruEmWvE
+  FS2B3m+JJYEfhLjHN80f/G2P3kvN44r1to/R5wBjgxvtvaHWv2amwBGZbOB1c3Sg
+  qdi7laIZMccF02+KfGBXbuc28b75NItFUK+62eLgSCi9/GJwZ4HC5lGpF7ac+S66
+  upj5v4RdZMx9sTIWfoNugI5TAgMBAAGjgYgwgYUwCQYDVR0TBAIwADALBgNVHQ8E
+  BAMCBLAwHQYDVR0OBBYEFGq+yaiaa5fcNGtNzPk64oVEJYUcMCUGA1UdEQQeMByB
+  GmxhdXJlbnQubWFydGluLmxAZ21haWwuY29tMCUGA1UdEgQeMByBGmxhdXJlbnQu
+  bWFydGluLmxAZ21haWwuY29tMA0GCSqGSIb3DQEBCwUAA4IBAQBZf2H7OVPcLrvM
+  Xy9CEJ72vs4fxjedp23jbUI+qLMUYPLCAdxe1Mbsbtp3/UcnwZWzcu8YZl+fA+29
+  f/s8LV6MccR3YiPgdnJhYUnNTQR/PuqsaAtyMbznW/+fv0/5IBsBd7Y0AJmO0JQl
+  1yAvw+U0E+nMfQ2Ifbwo0P0N1qmQhMDS8c7TBi8/ODaPfX/US+Ypt5VTgghL5f12
+  j64llzG5eLduyc+OnBevqJ8aYtbgrV3vFEQYL2n+buCV8TvXIEjqGNrUAMnbITCD
+  eT4yyJQaHXUl49wQcaNxTyWN9uqhAiv5EJqm19jJeYoQD/qPKP5jEyQdIFx5R/5A
+  ty9+j+pZ
+  -----END CERTIFICATE-----
+date: 2024-01-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: xml-simple
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: reek
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.1.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop-ast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rubocop-shopify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: solargraph
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.44'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.44'
+description: Generate Home Assistant configuration from ETS project
+email:
+- laurent.martin.l@gmail.com
+executables:
+- ets_to_hass
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- bin/ets_to_hass
+- lib/ets_to_hass/generator.rb
+- lib/ets_to_hass/info.rb
+- lib/ets_to_hass/specific/generic.rb
+- lib/ets_to_hass/specific/laurent.rb
+- lib/ets_to_hass/specific/specific2.rb
+- lib/ets_to_hass/string_colors.rb
+homepage: https://github.com/laurent-martin/ets-to-homeassistant
+licenses:
+- Apache-2.0
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/laurent-martin/ets-to-homeassistant
+  source_code_uri: https://github.com/laurent-martin/ets-to-homeassistant
+  changelog_uri: https://github.com/laurent-martin/ets-to-homeassistant
+  rubygems_uri: https://github.com/laurent-martin/ets-to-homeassistant
+  documentation_uri: https://github.com/laurent-martin/ets-to-homeassistant
+  bug_tracker_uri: https://github.com/laurent-martin/ets-to-homeassistant
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- Read the manual for any requirement
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Tool to generate Home Assistant configuration from ETS project
+test_files: []

metadata.gz.sig

@@ -0,0 +1,2 @@
+�=�����~QH���!I
+�?W�v�n�ӎ
�xss[Օx��곡zΐn.	�3�f�l���ԍ�NS�$LUO��ׁQ��I�_�����(7LZ')~�N���삵7��D�Yk���6�JHV�=�)�m��i��c�%�%Z�)(Y���o�\]݌��xY-XY�6?Q�����O@�!�Ӎ���YнiU��K�{��%CK������ZA��A���,�fx�w:�飆xb\B�^e�j��1�