├── .gitignore
├── LICENSE
├── MANIFEST.in
├── README.rst
├── osc2mqtt.ini
├── osc2mqtt
    ├── __init__.py
    ├── __main__.py
    ├── converter.py
    ├── lru_cache.py
    └── util.py
├── parse_requirements.py
├── requirements.txt
├── setup.cfg
├── setup.py
└── start.sh


/.gitignore:
--------------------------------------------------------------------------------
1 | build/
2 | dist/
3 | misc/
4 | __pycache__/
5 | *.egg-info/
6 | *.py[cod]
7 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 Christopher Arndt
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/MANIFEST.in:
--------------------------------------------------------------------------------
 1 | include AUTHORS.rst
 2 | include CONTRIBUTING.rst
 3 | include HISTORY.rst
 4 | include LICENSE
 5 | include README.rst
 6 | include osc2mqtt.ini
 7 | include parse_requirements.py
 8 | include requirements.txt
 9 | include start.sh
10 | 
11 | recursive-include tests *
12 | recursive-exclude * __pycache__
13 | recursive-exclude * *.py[co]
14 | 
15 | recursive-include docs *.rst conf.py Makefile make.bat


--------------------------------------------------------------------------------
/README.rst:
--------------------------------------------------------------------------------
 1 | osc2mqtt
 2 | ########
 3 | 
 4 | An OSC_ to MQTT_ bridge based on pyliblo_ and `paho-mqtt`_.
 5 | 
 6 | Quick Start
 7 | -----------
 8 | 
 9 | 1. ``pip install cython osc2mqtt``
10 | 2. Get osc2mqtt.ini_ and edit the ``options`` section and set your MQTT broker
11 |    host and port and, optionally, an OSC host and port as a reveiver.
12 | 3. Run ``osc2mqtt -v`` and start publishing MQTT messages or sending OSC
13 |    messages to ``udp://localhost:9001/``.
14 | 4. Watch debugging output for the MQTT topics, OSC addresses and the kind of
15 |    MQTT message payload and OSC arguments the messages have.
16 | 5. Add conversion rules to ``osc2mqtt.ini`` as needed. The `DEFAULT` section
17 |    has helpful comments. Also change the ``subscriptions`` option to only
18 |    receive the MQTT messages you're interested in.
19 | 6. Quit ``osc2mqtt`` with Control-C and restart it to try out your new
20 |    configuration. Repeat from step 4, if necessary.
21 | 
22 | .. _osc: http://opensoundcontrol.org/
23 | .. _mqtt: http://mqtt.org/
24 | .. _paho-mqtt: https://www.eclipse.org/paho/clients/python/
25 | .. _pyliblo: http://das.nasophon.de/pyliblo/
26 | .. _osc2mqtt.ini: https://github.com/SpotlightKid/osc2mqtt/blob/master/osc2mqtt.ini
27 | 


--------------------------------------------------------------------------------
/osc2mqtt.ini:
--------------------------------------------------------------------------------
  1 | [options]
  2 | ; Comma-separated list of MQTT topic filters to subscribe to, e.g.
  3 | # subscriptions = licht/+/+, schalter/+/+, +/xy/+
  4 | subscriptions = #
  5 | osc_port = 9001
  6 | ; OSC reveiver host[:port], supports UDP multicast too
  7 | osc_receiver =
  8 | ; MQTT broker host[:port]
  9 | mqtt_broker = localhost:1883
 10 | verbose = false
 11 | 
 12 | ; Defaults for conversion rules sections below
 13 | [DEFAULT]
 14 | ; Plain string or regular expression matching MQTT topic or OSC address.
 15 | ; If a regular expression, may contain named or unnamed substring groups.
 16 | ; See the comments for the 'address_groups' and 'topic_groups' settings below.
 17 | ; In the example here, everything after the optional slash prefix is group 1
 18 | match = ^/?(.*)
 19 | 
 20 | ; OSC address, a plain string, optionally with string formatting placeholders.
 21 | ; Placeholders may reference groups from the regular expression set with
 22 | ; 'match' above and will be replaced with what the respective group matched to.
 23 | ; Matches by unnamed regular expression groups are passed as positional
 24 | ; arguments to the formatting function and named groups as keyword arguments.
 25 | ; Additionally, values decoded from the MQTT payload are passed as a tuple via
 26 | ; the '_values' keyword argument and thus can be inserted in to the OSC address
 27 | ; with e.g. '{_values[0]}'.
 28 | ; See the conversion rules below for a usage example.
 29 | ; The default value here in combination with 'match' regular expression above
 30 | ; adds a slash prefix to the MQTT topic, if there wasn't one already.
 31 | address = /{0}
 32 | 
 33 | ; MQTT topic, a plain string, optionally with string formatting placeholders.
 34 | ; Placeholders may reference groups from the regular expression set with
 35 | ; 'match' above and will be replaced the what the respective group matched to.
 36 | ; Matches by unnamed regular expression groups are passed as positional
 37 | ; arguments to the formatting function and named groups as keyword arguments.
 38 | ; Additionally, values from the OSC message are passed as a tuple via the
 39 | ; '_values' keyword argument and thus can be inserted in to the MQTT topic with
 40 | ; e.g. '{_values[0]}'.
 41 | ; See the conversion rules below for a usage example.
 42 | ; The default value here in combination with 'match' regular expression above
 43 | ; removes the slash prefix from the OSC address.
 44 | topic = {0}
 45 | 
 46 | ; Comma-separated list of group names (unnamed groups are not supported).
 47 | ; Values in the OSC message's address string matched by the named regex
 48 | ; groups listed here will be appended to the OSC values of the message
 49 | ; before encoding the values to the MQTT message payload.
 50 | ; Only the values matched by the groups listed here will be appended
 51 | ; and in the order given here. The value for groups with no matches will
 52 | ; be None.
 53 | address_groups =
 54 | 
 55 | ; Comma-separated list of group names (unnamed groups are not supported).
 56 | ; Values in the MQTT message's topic string matched by the named regex
 57 | ; groups listed here will be appended to the values decoded from the
 58 | ; the MQTT message payload before converting them to OSC values;
 59 | ; Only the values matched by the groups listed here will be appended
 60 | ; and in the order given here. The value for groups with no matches will
 61 | ; be None.
 62 | topic_groups =
 63 | 
 64 | ; MQTT payload encoding type.
 65 | ; One of: array, json, string, struct
 66 | type = struct
 67 | 
 68 | ; MQTT payload encoding format.
 69 | ;
 70 | ; When type = struct, must be a struct.unpack() format string, e.g.:
 71 | # format = B ; one unsigned byte
 72 | # format = <ffhh ; two floats and two shorts (two-bytes), little-endian
 73 | ;
 74 | ; When type = array, must be an array element type char, e.g.
 75 | # format = d ; double
 76 | ;
 77 | ; When type = json or string, must be the string encoding (default: utf-8)
 78 | # format = ascii
 79 | format = B
 80 | 
 81 | ; Comma-separated list of conversion functions to apply to values decoded
 82 | ; from the MQTT message payload or extracted from the MQTT topic via named
 83 | ; regex groups. The values matched by the regex groups are appended to the
 84 | ; values decoded from the MQTT payload in the order they are listed by the
 85 | ; 'topic_groups' setting.
 86 | ; Available functions (you can also use the short form in parentheses):
 87 | ;     int (i), float (f), bool (b), str (s)
 88 | ; Any other function name or an empty string will leave the value as is.
 89 | ; Leaving this option empty also applies no conversion to any values.
 90 | ; Example:
 91 | # from_mqtt = int, float, , i
 92 | from_mqtt =
 93 | 
 94 | ; Comma-separated list of conversion functions to apply to arguments decoded
 95 | ; from the OSC message or extracted from the OSC address via named regex
 96 | ; groups. The values matched by the regex groups are appended to the
 97 | ; OSC values in the order they are listed by the 'adress_groups' setting.
 98 | ; Same format as the from_mqtt option.
 99 | from_osc =
100 | 
101 | ; List of OSC type tags as a string with no separator
102 | ; This is only necessary if the internal Python type representation
103 | ; of the values can not be converted into OSC types automatically.
104 | ; See the conversion table in the pyliblo documentation for details.
105 | osctags =
106 | 
107 | ; Conversion rules sections
108 | ; Section names MUST start with a colon (":").
109 | ; Conversion rules are matched in the order defined here, so put likely
110 | ; matches first for better performance.
111 | [:light]
112 | match = ^/?(licht/.*)
113 | from_mqtt = float
114 | from_osc = int
115 | 
116 | [:schalter]
117 | match = ^/?(schalter/.*)
118 | osctags = T
119 | 
120 | [:xypad]
121 | match = ^/?(?P<page>\w+)/xy(?P<pad>/?\d+)?
122 | topic = {page}/xy{pad}
123 | address = /{page}/xy{pad}
124 | format = >ff
125 | 
126 | [:button]
127 | ; An example for extracting values for the MQTT payload from the OSC address
128 | ; and setting the OSC address based on values from the MQTT payload:
129 | ;
130 | ; OSC address:/page1/button1/1 values:[]
131 | ;   --> MQTT topicpage1/button payload:'\x01'
132 | ; OSC address:/page1/button1/2 values:[]
133 | ;   --> MQTT topic:page1/button payload:'\x02'
134 | ; etc.
135 | match = ^/?(?P<page>\w+)/(?P<button>\w+)(/(?P<value>\d+))?
136 | address = /{page}/{button}/{_values[0]}
137 | topic = {page}/{button}
138 | ; Extract the value from the OSC address.
139 | address_groups = value
140 | ; Convert the match for the 'value' group to an int forthe MQTT payload.
141 | from_osc = int
142 | ; Setting this to a comma will yield an empty list and drop all values decoded
143 | ; from the MQTT payload, since we will encode the single value we expect in the
144 | ; OSC address.
145 | from_mqtt = ,
146 | 


--------------------------------------------------------------------------------
/osc2mqtt/__init__.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | # -*- coding: utf-8 -*-
  3 | """Bridge between OSC and MQTT."""
  4 | 
  5 | from __future__ import absolute_import, unicode_literals
  6 | 
  7 | import argparse
  8 | import logging
  9 | import shlex
 10 | import sys
 11 | import time
 12 | 
 13 | from collections import OrderedDict
 14 | 
 15 | try:
 16 |     import configparser
 17 | except ImportError:
 18 |     import ConfigParser as configparser
 19 | 
 20 | import liblo
 21 | import paho.mqtt.client as mqtt
 22 | 
 23 | from .converter import Osc2MqttConverter, ConversionRule
 24 | from .util import as_bool, parse_hostport, parse_list
 25 | 
 26 | 
 27 | log = logging.getLogger('osc2mqtt')
 28 | 
 29 | 
 30 | def read_config(filename, options="options"):
 31 |     config = {'rules': OrderedDict()}
 32 |     defaults = dict(
 33 |         match = '^/?(.*)',
 34 |         address = r'/\1',
 35 |         topic = r'\1',
 36 |         address_groups = None,
 37 |         topic_groups = None,
 38 |         type = 'struct',
 39 |         format = 'B',
 40 |         from_mqtt = None,
 41 |         from_osc = None,
 42 |         osctags = None
 43 |     )
 44 | 
 45 |     if filename:
 46 |         parser = configparser.RawConfigParser(defaults)
 47 |         parser.read(filename)
 48 |         if parser.has_section(options):
 49 |             default_options = parser.items('DEFAULT')
 50 |             config.update(
 51 |                 (setting, value) for setting, value in parser.items(options)
 52 |                 if setting not in default_options)
 53 | 
 54 |         for section in parser.sections():
 55 |             if section.startswith(':'):
 56 |                 name = section[1:]
 57 |                 config['rules'][name] = dict(parser.items(section))
 58 | 
 59 |     subscriptions = parse_list(config.get('subscriptions', '#'))
 60 |     config['subscriptions'] = []
 61 |     encode = ((lambda s: s.encode('utf-8'))
 62 |               if isinstance(b'', str) else (lambda s: s))
 63 |     for sub in subscriptions:
 64 |         config['subscriptions'].append((encode(sub), 0))
 65 | 
 66 |     return config
 67 | 
 68 | 
 69 | class Osc2MqttBridge(object):
 70 |     def __init__(self, config, converter):
 71 |         """Setup OSC and MQTT servers.
 72 | 
 73 |         @param config: configuration directory
 74 |         @param converter: Osc2MqttConverter instance
 75 | 
 76 |         """
 77 |         self.converter = converter
 78 |         self.config = config
 79 |         self.mqtt_host, self.mqtt_port = parse_hostport(
 80 |             config.get("mqtt_broker", "localhost"), 1883)
 81 |         self.osc_port = int(config.get("osc_port", 9001))
 82 |         self.osc_receiver = config.get("osc_receiver")
 83 |         self.subscriptions = config.get("subscriptions", ['#'])
 84 | 
 85 |         if self.osc_receiver:
 86 |             host, port = parse_hostport(self.osc_receiver, 9000)
 87 |             self.osc_receiver = liblo.Address(host, port, liblo.UDP)
 88 | 
 89 |         self.mqttclient = mqtt.Client(config.get("client_id", "osc2mqtt"))
 90 |         self.mqttclient.on_connect = self.mqtt_connect
 91 |         self.mqttclient.on_disconnect = self.mqtt_disconnect
 92 |         self.mqttclient.on_message = self.handle_mqtt
 93 | 
 94 |         self.oscserver = liblo.ServerThread(self.osc_port)
 95 |         self.oscserver.add_method(None, None, self.handle_osc)
 96 | 
 97 |     def start(self):
 98 |         """Start MQTT client and OSC listener."""
 99 |         log.info("Connecting to MQTT broker %s:%s ...",
100 |             self.mqtt_host, self.mqtt_port)
101 |         self.mqttclient.connect(self.mqtt_host, self.mqtt_port)
102 | 
103 |         log.debug("Starting MQTT thread...")
104 |         self.mqttclient.loop_start()
105 | 
106 |         log.info("Starting OSC server listening on port %s ...", self.osc_port)
107 |         self.oscserver.start()
108 | 
109 |     def stop(self):
110 |         """Method docstring."""
111 |         log.info("Stopping OSC server ...")
112 |         self.oscserver.stop()
113 |         log.debug("Stopping MQTT thread ...")
114 |         self.mqttclient.loop_stop()
115 |         log.info("Disconnecting from MQTT broker ...")
116 |         self.mqttclient.disconnect()
117 | 
118 |     def mqtt_connect(self, client, userdata, flags, rc):
119 |         log.debug("MQTT connect: %s", mqtt.connack_string(rc))
120 |         if rc == 0 and self.subscriptions:
121 |             client.subscribe(self.subscriptions)
122 | 
123 |     def mqtt_disconnect(self, client, userdata, rc):
124 |         log.debug("MQTT disconnect: %s", mqtt.error_string(rc))
125 | 
126 |     def handle_mqtt(self, client, userdata, msg):
127 |         log.debug("MQTT recv: %s %r", msg.topic, msg.payload)
128 |         res = self.converter.from_mqtt(msg.topic, msg.payload)
129 |         if res:
130 |             if self.osc_receiver:
131 |                 log.debug("OSC send: %s %r", *res)
132 |                 self.oscserver.send(self.osc_receiver, res[0], *res[1])
133 |         else:
134 |             log.debug("No rule match for MQTT topic '%s'.", msg.topic)
135 | 
136 |     def handle_osc(self, oscaddr, values, tags, clientaddr, userdata):
137 |         log.debug("OSC recv: %s %r", oscaddr, values)
138 |         res = self.converter.from_osc(oscaddr, values, tags)
139 |         if res:
140 |             log.debug("MQTT publish: %s %r", *res)
141 |             self.mqttclient.publish(*res)
142 |         else:
143 |             log.debug("No rule match for OSC address '%s'.", oscaddr)
144 | 
145 | 
146 | def main(args=None):
147 |     ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
148 |     ap.add_argument(
149 |         '-c', '--config',
150 |         metavar='FILENAME',
151 |         default='osc2mqtt.ini',
152 |         help="Read configuration from given filename")
153 |     ap.add_argument(
154 |         '-p', '--osc-port',
155 |         type=int,
156 |         metavar='PORT',
157 |         default=9001,
158 |         help="Local OSC server (UDP) port (default: %(default)s)")
159 |     ap.add_argument(
160 |         '-m', '--mqtt-broker',
161 |         metavar='ADDR[:PORT]',
162 |         default='localhost:1883',
163 |         help="MQTT broker addr[:port] (default: %(default)s)")
164 |     ap.add_argument(
165 |         '-o', '--osc-receiver',
166 |         metavar='ADDR[:PORT]',
167 |         help='Also bridge MQTT to OSC receiver addr[:port] via UDP '
168 |              '(default: one-way)')
169 |     ap.add_argument(
170 |         '-v', '--verbose',
171 |         action="store_true",
172 |         help='Enable verbose logging')
173 | 
174 |     args = ap.parse_args(args if args is not None else sys.argv[1:])
175 | 
176 |     cfg = read_config(args.config)
177 | 
178 |     for opt in ('mqtt_broker', 'osc_port', 'osc_receiver', 'verbose'):
179 |         argval = getattr(args, opt)
180 |         if opt not in cfg or argval != ap.get_default(opt):
181 |             cfg[opt] = argval
182 | 
183 |     logging.basicConfig(level=logging.DEBUG
184 |         if as_bool(cfg["verbose"]) else logging.INFO,
185 |         format="%(levelname)s:%(message)s")
186 | 
187 |     converter = Osc2MqttConverter(cfg["rules"])
188 |     osc2mqtt = Osc2MqttBridge(cfg, converter)
189 |     osc2mqtt.start()
190 | 
191 |     try:
192 |         while True:
193 |             time.sleep(1)
194 |     except KeyboardInterrupt:
195 |         log.info("Interrupted.")
196 |     finally:
197 |         osc2mqtt.stop()
198 |         log.info("Done.")
199 | 
200 | 
201 | if __name__ == '__main__':
202 |     sys.exit(main(sys.argv[1:]) or 0)
203 | 


--------------------------------------------------------------------------------
/osc2mqtt/__main__.py:
--------------------------------------------------------------------------------
1 | from osc2mqtt import main
2 | 
3 | if __name__ == '__main__':
4 |     import sys
5 |     sys.exit(main(sys.argv[1:]) or 0)
6 | 


--------------------------------------------------------------------------------
/osc2mqtt/converter.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | """Convert between MQTT message payload data and OSC arguments types."""
  3 | 
  4 | from __future__ import absolute_import, unicode_literals
  5 | 
  6 | import array
  7 | import json
  8 | import re
  9 | import struct
 10 | import logging
 11 | 
 12 | from collections import namedtuple
 13 | 
 14 | from .util import as_bool, parse_list
 15 | 
 16 | try:
 17 |     # Python 3.2+
 18 |     from functools import lru_cache
 19 | except ImportError:
 20 |     try:
 21 |         # try backport available on PyPI
 22 |         from backports.functools_lru_cache import lru_cache
 23 |     except ImportError:
 24 |         # finally, backport included with package
 25 |         from .lru_cache import lru_cache
 26 | 
 27 | 
 28 | log = logging.getLogger(__name__)
 29 | 
 30 | 
 31 | class ConfigError(Exception):
 32 |     """Raised when configuration file can not be parsed correctly."""
 33 |     pass
 34 | 
 35 | 
 36 | ConversionRule = namedtuple(
 37 |     'ConversionRule',
 38 |     [
 39 |         'match',
 40 |         'address',
 41 |         'topic',
 42 |         'address_groups',
 43 |         'topic_groups',
 44 |         'type',
 45 |         'format',
 46 |         'from_mqtt',
 47 |         'from_osc',
 48 |         'osctags'
 49 |     ])
 50 | 
 51 | 
 52 | class Osc2MqttConverter(object):
 53 |     """Convert MQTT topic and payload to OSC address and values and vice-versa.
 54 |     """
 55 | 
 56 |     _converters = {
 57 |         'f': float,
 58 |         'float': float,
 59 |         'i': int,
 60 |         'int': int,
 61 |         's': str,
 62 |         'str': str,
 63 |         'b': as_bool,
 64 |         'bool': as_bool
 65 |     }
 66 | 
 67 |     def __init__(self, rules):
 68 |         """Initialize converter with a set of conversion rules.
 69 | 
 70 |         @param rules: a dict of ConversionRules instances, keyed by name
 71 | 
 72 |         """
 73 |         self.rules = {}
 74 | 
 75 |         for name, rule in rules.items():
 76 |             try:
 77 |                 if rule["from_mqtt"] is not None:
 78 |                     rule["from_mqtt"] = [self._converters.get(f)
 79 |                         for f in parse_list(rule["from_mqtt"])]
 80 | 
 81 |                 if rule["from_osc"] is not None:
 82 |                     rule["from_osc"] = [self._converters.get(f)
 83 |                         for f in parse_list(rule["from_osc"])]
 84 | 
 85 |                 if rule["address_groups"] is not None:
 86 |                     rule["address_groups"] = parse_list(rule["address_groups"])
 87 | 
 88 |                 if rule["topic_groups"] is not None:
 89 |                     rule["topic_groups"] = parse_list(rule["topic_groups"])
 90 | 
 91 |                 self.rules[name] = ConversionRule(**rule)
 92 |             except Exception as exc:
 93 |                 raise ConfigError("Malformed conversion rule: %s" % exc)
 94 | 
 95 |     @lru_cache()
 96 |     def match_rule(self, topicoraddr):
 97 |         """Match MQTT topic or OSC address against a rule regex.
 98 | 
 99 |         @param topicoraddr: MQTT topic or OSC address pattern string
100 |         @return ConversionRule: the conversion rule instance, which matched
101 |             topicoraddr, or None, if no match was found
102 | 
103 |         """
104 |         for name, rule in self.rules.items():
105 |             match = re.search(rule.match, topicoraddr)
106 |             if match:
107 |                 log.debug("Rule '%s' match on: %s", name, topicoraddr)
108 |                 return rule, match
109 | 
110 |     def from_mqtt(self, topic, payload):
111 |         """Convert MQTT message to OSC.
112 | 
113 |         The MQTT message payload (an opaque byte string) can be encoded in
114 |         several forms, for example:
115 | 
116 |         1. A JSON, msgpack, etc. string.
117 |         2. An ASCII string representation of an integer or float
118 |         3. An integer directly encoded as the byte value
119 |            a. signed or
120 |            b. unsigned
121 |         4. A multi-byte value, like a word, long, float, double, etc. in signed,
122 |            unsigned, big and little endian varieties
123 |         5. An array (i.e. sequence) of values encoded as 3) or 4)
124 | 
125 |         1) and 2) can be decoded with JSON.loads(), 3a) can be passed to ord() and
126 |         3a/b) and 4) can be decoded with struct.unpack(), where one needs to know
127 |         the type, the endianess and signedness. 5) can be decoded, for example,
128 |         with the array module or bytearray(), if the type of the values is uint8.
129 | 
130 |         """
131 |         result = self.match_rule(topic)
132 | 
133 |         if result:
134 |             rule, match = result
135 | 
136 |             # add matches extracted from MQTTtopic to values
137 |             if rule.topic_groups:
138 |                 extra_values = match.group(*rule.topic_groups)
139 | 
140 |                 if len(rule.topic_groups) == 1:
141 |                     extra_values = [extra_values]
142 |                 else:
143 |                     extra_values = list(extra_values)
144 | 
145 |                 values = values + extra_values
146 | 
147 |             values = self.decode_values(payload, rule)
148 |             addr_kwargs = match.groupdict('')
149 |             addr_kwargs['_values'] = values
150 | 
151 |             if rule.from_mqtt not in (None, ''):
152 |                 values = self.convert_mqtt_values(rule.from_mqtt, values)
153 | 
154 |             if rule.osctags:
155 |                 values = tuple(zip(rule.osctags, values))
156 | 
157 |             addr = rule.address.format(*match.groups(''), **addr_kwargs)
158 |             log.debug("Using OSC address: %s", addr)
159 |             log.debug("Decoded payload to values: %r --> %r", payload, values)
160 |             return addr, values
161 | 
162 |     def convert_mqtt_values(self, converters, values):
163 |         """Convert decoded MQTT payload values via 'from_mqtt' conversion funcs.
164 |         """
165 |         return tuple(func(value) if func else value
166 |                      for func, value in zip(converters, values))
167 | 
168 |     def decode_values(self, data, rule):
169 |         """Decode MQTT message payload byte string into Python values."""
170 |         if rule.type == 'json':
171 |             values = json.loads(data.decode(rule.format or 'utf-8'))
172 |         elif rule.type == 'struct':
173 |             values = struct.unpack_from(rule.format, data)
174 |         elif rule.type == 'array':
175 |             values = tuple(array.array(rule.format, data))
176 |         elif rule.type == 'string':
177 |             values = (data.decode(rule.format or 'utf-8'),)
178 |         else:
179 |             values = (data,)
180 | 
181 |         return values
182 | 
183 |     def from_osc(self, addr, values, tags):
184 |         """Convert OSC message to MQTT.
185 | 
186 |         Since OSC messages always specify the types of their values, only the
187 |         'type' and 'format' of the matching conversion rule is used to encode
188 |         the OSC values into an MQTT message payload string.
189 | 
190 |         """
191 |         result = self.match_rule(addr)
192 | 
193 |         if result:
194 |             rule, match = result
195 | 
196 |             # add matches extracted from OSC address to values
197 |             if rule.address_groups:
198 |                 extra_values = match.group(*rule.address_groups)
199 | 
200 |                 if len(rule.address_groups) == 1:
201 |                     extra_values = [extra_values]
202 |                 else:
203 |                     extra_values = list(extra_values)
204 | 
205 |                 values = values + extra_values
206 | 
207 |             topic_kwargs = match.groupdict('')
208 |             topic_kwargs['_values'] = values
209 | 
210 |             if rule.from_osc not in (None, ''):
211 |                 values = self.convert_osc_values(rule.from_osc, values)
212 | 
213 |             topic = rule.topic.format(*match.groups(''), **topic_kwargs)
214 |             log.debug("Using MQTT topic: %s", topic)
215 |             data = self.encode_values(values, rule)
216 |             log.debug("Encoded values to payload: %r --> %r", values, data)
217 |             return topic, data
218 | 
219 |     def encode_values(self, values, rule):
220 |         """Encode Python values into MQTT message payload."""
221 |         if rule.type == 'json':
222 |             return json.dumps(values)
223 |         elif rule.type == 'struct':
224 |             return bytearray(struct.pack(rule.format, *values))
225 |         elif type == 'array':
226 |             return bytearray(array.array(rule.format, values).tostring())
227 |         elif rule.type == 'string':
228 |             return "".join(str(s) for s in values)
229 |         else:
230 |             if len(values) == 1:
231 |                 return str(values[0]).encode()
232 |             else:
233 |                 return str(values).encode()
234 | 
235 |     def convert_osc_values(self, converters, values):
236 |         """Convert values from OSC types via 'from_osc' conversion funcs."""
237 |         return tuple(func(value) if func else value
238 |                      for func, value in zip(converters, values))
239 | 


--------------------------------------------------------------------------------
/osc2mqtt/lru_cache.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | #
  3 | # lru_cache.py
  4 | #
  5 | """Backport of functools.lru_cache decorator from Python 3.3.
  6 | 
  7 | Source:
  8 | 
  9 |     http://code.activestate.com/recipes/578078-py26-and-py30-backport-of-python-33s-lru-cache/
 10 | 
 11 | """
 12 | 
 13 | import functools
 14 | from collections import namedtuple
 15 | from functools import update_wrapper
 16 | from threading import RLock
 17 | 
 18 | 
 19 | _CacheInfo = namedtuple("CacheInfo", ["hits", "misses", "maxsize", "currsize"])
 20 | 
 21 | 
 22 | @functools.wraps(functools.update_wrapper)
 23 | def update_wrapper(wrapper,
 24 |                    wrapped,
 25 |                    assigned = functools.WRAPPER_ASSIGNMENTS,
 26 |                    updated = functools.WRAPPER_UPDATES):
 27 |     """Patch two bugs in functools.update_wrapper."""
 28 |     # workaround for http://bugs.python.org/issue3445
 29 |     assigned = tuple(attr for attr in assigned if hasattr(wrapped, attr))
 30 |     wrapper = functools.update_wrapper(wrapper, wrapped, assigned, updated)
 31 |     # workaround for https://bugs.python.org/issue17482
 32 |     wrapper.__wrapped__ = wrapped
 33 |     return wrapper
 34 | 
 35 | 
 36 | class _HashedSeq(list):
 37 |     __slots__ = 'hashvalue'
 38 | 
 39 |     def __init__(self, tup, hash=hash):
 40 |         self[:] = tup
 41 |         self.hashvalue = hash(tup)
 42 | 
 43 |     def __hash__(self):
 44 |         return self.hashvalue
 45 | 
 46 | 
 47 | def _make_key(args, kwds, typed,
 48 |              kwd_mark = (object(),),
 49 |              fasttypes = {int, str, frozenset, type(None)},
 50 |              sorted=sorted, tuple=tuple, type=type, len=len):
 51 |     'Make a cache key from optionally typed positional and keyword arguments'
 52 |     key = args
 53 |     if kwds:
 54 |         sorted_items = sorted(kwds.items())
 55 |         key += kwd_mark
 56 |         for item in sorted_items:
 57 |             key += item
 58 |     if typed:
 59 |         key += tuple(type(v) for v in args)
 60 |         if kwds:
 61 |             key += tuple(type(v) for k, v in sorted_items)
 62 |     elif len(key) == 1 and type(key[0]) in fasttypes:
 63 |         return key[0]
 64 |     return _HashedSeq(key)
 65 | 
 66 | 
 67 | def lru_cache(maxsize=128, typed=False):
 68 |     """Least-recently-used cache decorator.
 69 | 
 70 |     If *maxsize* is set to None, the LRU features are disabled and the cache
 71 |     can grow without bound.
 72 | 
 73 |     If *typed* is True, arguments of different types will be cached separately.
 74 |     For example, f(3.0) and f(3) will be treated as distinct calls with
 75 |     distinct results.
 76 | 
 77 |     Arguments to the cached function must be hashable.
 78 | 
 79 |     View the cache statistics named tuple (hits, misses, maxsize, currsize) with
 80 |     f.cache_info().  Clear the cache and statistics with f.cache_clear().
 81 |     Access the underlying function with f.__wrapped__.
 82 | 
 83 |     See:  http://en.wikipedia.org/wiki/Cache_algorithms#Least_Recently_Used
 84 | 
 85 |     """
 86 | 
 87 |     # Users should only access the lru_cache through its public API:
 88 |     #       cache_info, cache_clear, and f.__wrapped__
 89 |     # The internals of the lru_cache are encapsulated for thread safety and
 90 |     # to allow the implementation to change (including a possible C version).
 91 | 
 92 |     def decorating_function(user_function):
 93 | 
 94 |         cache = dict()
 95 |         stats = [0, 0]                  # make statistics updateable non-locally
 96 |         HITS, MISSES = 0, 1             # names for the stats fields
 97 |         make_key = _make_key
 98 |         cache_get = cache.get           # bound method to lookup key or return None
 99 |         _len = len                      # localize the global len() function
100 |         lock = RLock()                  # because linkedlist updates aren't threadsafe
101 |         root = []                       # root of the circular doubly linked list
102 |         root[:] = [root, root, None, None]      # initialize by pointing to self
103 |         nonlocal_root = [root]                  # make updateable non-locally
104 |         PREV, NEXT, KEY, RESULT = 0, 1, 2, 3    # names for the link fields
105 | 
106 |         if maxsize == 0:
107 | 
108 |             def wrapper(*args, **kwds):
109 |                 # no caching, just do a statistics update after a successful call
110 |                 result = user_function(*args, **kwds)
111 |                 stats[MISSES] += 1
112 |                 return result
113 | 
114 |         elif maxsize is None:
115 | 
116 |             def wrapper(*args, **kwds):
117 |                 # simple caching without ordering or size limit
118 |                 key = make_key(args, kwds, typed)
119 |                 result = cache_get(key, root)   # root used here as a unique not-found sentinel
120 |                 if result is not root:
121 |                     stats[HITS] += 1
122 |                     return result
123 |                 result = user_function(*args, **kwds)
124 |                 cache[key] = result
125 |                 stats[MISSES] += 1
126 |                 return result
127 | 
128 |         else:
129 | 
130 |             def wrapper(*args, **kwds):
131 |                 # size limited caching that tracks accesses by recency
132 |                 key = make_key(args, kwds, typed) if kwds or typed else args
133 |                 with lock:
134 |                     link = cache_get(key)
135 |                     if link is not None:
136 |                         # record recent use of the key by moving it to the front of the list
137 |                         root, = nonlocal_root
138 |                         link_prev, link_next, key, result = link
139 |                         link_prev[NEXT] = link_next
140 |                         link_next[PREV] = link_prev
141 |                         last = root[PREV]
142 |                         last[NEXT] = root[PREV] = link
143 |                         link[PREV] = last
144 |                         link[NEXT] = root
145 |                         stats[HITS] += 1
146 |                         return result
147 |                 result = user_function(*args, **kwds)
148 |                 with lock:
149 |                     root, = nonlocal_root
150 |                     if key in cache:
151 |                         # getting here means that this same key was added to the
152 |                         # cache while the lock was released.  since the link
153 |                         # update is already done, we need only return the
154 |                         # computed result and update the count of misses.
155 |                         pass
156 |                     elif _len(cache) >= maxsize:
157 |                         # use the old root to store the new key and result
158 |                         oldroot = root
159 |                         oldroot[KEY] = key
160 |                         oldroot[RESULT] = result
161 |                         # empty the oldest link and make it the new root
162 |                         root = nonlocal_root[0] = oldroot[NEXT]
163 |                         oldkey = root[KEY]
164 |                         oldvalue = root[RESULT]
165 |                         root[KEY] = root[RESULT] = None
166 |                         # now update the cache dictionary for the new links
167 |                         del cache[oldkey]
168 |                         cache[key] = oldroot
169 |                     else:
170 |                         # put result in a new link at the front of the list
171 |                         last = root[PREV]
172 |                         link = [last, root, key, result]
173 |                         last[NEXT] = root[PREV] = cache[key] = link
174 |                     stats[MISSES] += 1
175 |                 return result
176 | 
177 |         def cache_info():
178 |             """Report cache statistics"""
179 |             with lock:
180 |                 return _CacheInfo(stats[HITS], stats[MISSES], maxsize, len(cache))
181 | 
182 |         def cache_clear():
183 |             """Clear the cache and cache statistics"""
184 |             with lock:
185 |                 cache.clear()
186 |                 root = nonlocal_root[0]
187 |                 root[:] = [root, root, None, None]
188 |                 stats[:] = [0, 0]
189 | 
190 |         wrapper.__wrapped__ = user_function
191 |         wrapper.cache_info = cache_info
192 |         wrapper.cache_clear = cache_clear
193 |         return update_wrapper(wrapper, user_function)
194 | 
195 |     return decorating_function
196 | 


--------------------------------------------------------------------------------
/osc2mqtt/util.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | """Utility functions for reading osc2mqtt configuration."""
 3 | 
 4 | from __future__ import absolute_import, unicode_literals
 5 | 
 6 | import shlex
 7 | 
 8 | 
 9 | def as_bool(val):
10 |     return str(val).lower() in ('1', 'enabled', 'on', 't', 'true', 'y', 'yes')
11 | 
12 | 
13 | def parse_hostport(addr, port=9000):
14 |     if ('::' in addr and ']:' in addr) or ('::' not in addr and ':' in addr):
15 |         host, port = addr.rsplit(':', 1)
16 |     else:
17 |         host = addr
18 | 
19 |     if host.startswith('[') and host.endswith(']'):
20 |         host = host[1:-1]
21 | 
22 |     return (host, int(port))
23 | 
24 | 
25 | def parse_list(s):
26 |     lexer = shlex.shlex(s, posix=True)
27 |     lexer.whitespace = ','
28 |     lexer.whitespace_split = True
29 |     lexer.commenters = ''
30 |     return [token.strip() for token in lexer]
31 | 


--------------------------------------------------------------------------------
/parse_requirements.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | # -*- coding: utf-8 -*-
 3 | 
 4 | import re
 5 | 
 6 | def parse_requirements(requirements, ignore=('setuptools',)):
 7 |     """Read dependencies from file and strip off version numbers.
 8 | 
 9 |     Supports extra requirements and '>=' and '<=' version qualifiers.
10 |     """
11 |     with open(requirements) as f:
12 |         packages = set()
13 |         for line in f:
14 |             line = line.strip()
15 |             if not line or line.startswith(('#', '-r', '--')):
16 |                 continue
17 | 
18 |             # XXX: Ugly hack!
19 |             extras = []
20 |             def get_extras(match):
21 |                 extras.append(match.group(1))
22 | 
23 |             line = re.sub(r'\s*\[(.*?)\]', get_extras, line)
24 | 
25 |             if '#egg=' in line:
26 |                 line = line.split('#egg=')[1]
27 | 
28 |             pkg = re.split('[=<>]=', line)[0].strip()
29 | 
30 |             if pkg not in ignore:
31 |                 if extras:
32 |                     pkg = 'pkg [%s]' % extras[0]
33 |                 packages.add(pkg)
34 | 
35 |         return tuple(packages)
36 | 
37 | 
38 | if __name__ == '__main__':
39 |     import sys
40 |     print("\n".join(sorted(parse_requirements(
41 |         sys.argv[1] if sys.argv[1:] else 'requirements.txt'))))
42 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | paho-mqtt==1.1
2 | pyliblo==0.9.2
3 | 


--------------------------------------------------------------------------------
/setup.cfg:
--------------------------------------------------------------------------------
 1 | [egg_info]
 2 | tag_build = .dev
 3 | #tag_date = true
 4 | 
 5 | [aliases]
 6 | # A handy alias to build a release (source and egg)
 7 | release = build egg_info -RDb "" sdist --formats=zip,gztar,bztar bdist_wheel
 8 | # A handy alias to upload a release to pypi
 9 | release_upload = build egg_info -RDb "" sdist --formats=zip,gztar,bztar bdist_wheel upload
10 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | # -*- coding: utf-8 -*-
 3 | #
 4 | # setup.py - Setup file for the osc2mqtt project.
 5 | #
 6 | """An OSC to MQTT bridge based on pyliblo and paho-mqtt."""
 7 | 
 8 | from io import open
 9 | from setuptools import setup
10 | 
11 | from parse_requirements import parse_requirements
12 | 
13 | # Add custom distribution meta-data, avoids warning when running setup
14 | from distutils.dist import DistributionMetadata
15 | DistributionMetadata.repository = None
16 | 
17 | classifiers = """\
18 | Development Status :: 4 - Beta
19 | Environment :: Console
20 | Intended Audience :: Developers
21 | Intended Audience :: End Users/Desktop
22 | Intended Audience :: Manufacturing
23 | Intended Audience :: Other Audience
24 | License :: OSI Approved :: MIT License
25 | Operating System :: Microsoft :: Windows
26 | Operating System :: POSIX
27 | Operating System :: MacOS :: MacOS X
28 | Programming Language :: Python
29 | Programming Language :: Python :: 2.7
30 | Programming Language :: Python :: 3.3
31 | Programming Language :: Python :: 3.4
32 | Topic :: Communications
33 | Topic :: Internet
34 | Topic :: Home Automation
35 | Topic :: Multimedia :: Sound/Audio
36 | """
37 | name = 'osc2mqtt'
38 | url = 'https://github.com/SpotlightKid/%s' % name.lower()
39 | readme = open('README.rst', encoding='utf-8').read()
40 | 
41 | setup(
42 |     name = name,
43 |     version = '0.2b2',
44 |     description = __doc__.splitlines()[0],
45 |     long_description = "\n".join(readme.splitlines()[2:]),
46 |     keywords = 'osc mqtt iot',
47 |     classifiers = [c.strip() for c in classifiers.splitlines()
48 |         if c.strip() and not c.startswith('#')],
49 |     author = 'Christopher Arndt',
50 |     author_email = 'chris@chrisarndt.de',
51 |     url = url,
52 |     repository = url,
53 |     download_url = url + '/releases',
54 |     license = 'MIT License',
55 |     platforms = 'POSIX, Windows, MacOS X',
56 |     packages = ['osc2mqtt'],
57 |     install_requires = parse_requirements('requirements.txt'),
58 |     entry_points = {
59 |         'console_scripts': [
60 |             'osc2mqtt = osc2mqtt.__main__:main'
61 |         ]
62 |     },
63 |     zip_safe = True
64 | )
65 | 


--------------------------------------------------------------------------------
/start.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | #
 3 | # start osc2mqtt.py OSC to MQTT bridge with proper hosts and ports
 4 | #
 5 | 
 6 | MQTT_HOST="localhost"
 7 | MQTT_PORT="1883"
 8 | OSC_PORT="9001"
 9 | 
10 | PYTHONPATH=$(pwd) python -m osc2mqtt -m $MQTT_HOST:$MQTT_PORT -p $OSC_PORT "$@"
11 | 


--------------------------------------------------------------------------------