merge fix

Author: attwad

CHANGELOG.md

@@ -3,9 +3,17 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/) and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [Unreleased]
+
+### Added
+
+- Support for sending and receiving Int64 datatype (`h`).
+
 ## [1.7.7]
 
--  Flaky test ntp bug fix.
+###  Fixed
+
+Flaky NTP test
 
 ## [1.7.6]
 

README.rst

@@ -20,7 +20,7 @@ Features
 
 * UDP blocking/threading/forking/asyncio server implementations
 * UDP client
-* int, float, string, double, MIDI, timestamps, blob OSC arguments
+* int, int64, float, string, double, MIDI, timestamps, blob OSC arguments
 * simple OSC address<->callback matching system
 * extensive unit test coverage
 * basic client and server examples

pythonosc/osc_message.py

@@ -40,6 +40,8 @@ def _parse_datagram(self) -> None:
             for param in type_tag:
                 if param == "i":  # Integer.
                     val, index = osc_types.get_int(self._dgram, index)
+                elif param == "h":  # Int64.
+                    val, index = osc_types.get_int64(self._dgram, index)
                 elif param == "f":  # Float.
                     val, index = osc_types.get_float(self._dgram, index)
                 elif param == "d":  # Double.

pythonosc/osc_message_builder.py

@@ -15,6 +15,7 @@ class OscMessageBuilder(object):
     ARG_TYPE_FLOAT = "f"
     ARG_TYPE_DOUBLE = "d"
     ARG_TYPE_INT = "i"
+    ARG_TYPE_INT64 = "h"
     ARG_TYPE_STRING = "s"
     ARG_TYPE_BLOB = "b"
     ARG_TYPE_RGBA = "r"
@@ -27,7 +28,7 @@ class OscMessageBuilder(object):
     ARG_TYPE_ARRAY_STOP = "]"
 
     _SUPPORTED_ARG_TYPES = (
-        ARG_TYPE_FLOAT, ARG_TYPE_DOUBLE, ARG_TYPE_INT, ARG_TYPE_BLOB, ARG_TYPE_STRING,
+        ARG_TYPE_FLOAT, ARG_TYPE_DOUBLE, ARG_TYPE_INT, ARG_TYPE_INT64, ARG_TYPE_BLOB, ARG_TYPE_STRING,
         ARG_TYPE_RGBA, ARG_TYPE_MIDI, ARG_TYPE_TRUE, ARG_TYPE_FALSE, ARG_TYPE_NIL)
 
     def __init__(self, address: str=None) -> None:
@@ -105,7 +106,10 @@ def _get_arg_type(self, arg_value: Union[str, bytes, bool, int, float, tuple, li
         elif arg_value is False:
             arg_type = self.ARG_TYPE_FALSE
         elif isinstance(arg_value, int):
-            arg_type = self.ARG_TYPE_INT
+            if arg_value.bit_length() > 32:
+                arg_type = self.ARG_TYPE_INT64
+            else:
+                arg_type = self.ARG_TYPE_INT
         elif isinstance(arg_value, float):
             arg_type = self.ARG_TYPE_FLOAT
         elif isinstance(arg_value, tuple) and len(arg_value) == 4:
@@ -146,6 +150,8 @@ def build(self) -> osc_message.OscMessage:
                     dgram += osc_types.write_string(value)
                 elif arg_type == self.ARG_TYPE_INT:
                     dgram += osc_types.write_int(value)
+                elif arg_type == self.ARG_TYPE_INT64:
+                    dgram += osc_types.write_int64(value)
                 elif arg_type == self.ARG_TYPE_FLOAT:
                     dgram += osc_types.write_float(value)
                 elif arg_type == self.ARG_TYPE_DOUBLE:

pythonosc/parsing/osc_types.py

@@ -21,6 +21,7 @@ class BuildError(Exception):
 
 # Datagram length in bytes for types that have a fixed size.
 _INT_DGRAM_LEN = 4
+_INT64_DGRAM_LEN = 8
 _UINT64_DGRAM_LEN = 8
 _FLOAT_DGRAM_LEN = 4
 _DOUBLE_DGRAM_LEN = 8
@@ -126,6 +127,42 @@ def get_int(dgram: bytes, start_index: int) -> Tuple[int, int]:
         raise ParseError('Could not parse datagram %s' % e)
 
 
+def write_int64(val: int) -> bytes:
+    """Returns the datagram for the given 64-bit big-endian signed parameter value
+
+    Raises:
+      - BuildError if the int64 could not be converted.
+    """
+    try:
+        return struct.pack('>q', val)
+    except struct.error as e:
+        raise BuildError('Wrong argument value passed: {}'.format(e))
+
+
+def get_int64(dgram: bytes, start_index: int) -> Tuple[int, int]:
+    """Get a 64-bit big-endian signed integer from the datagram.
+
+    Args:
+      dgram: A datagram packet.
+      start_index: An index where the 64-bit integer starts in the datagram.
+
+    Returns:
+      A tuple containing the 64-bit integer and the new end index.
+
+    Raises:
+      ParseError if the datagram could not be parsed.
+    """
+    try:
+        if len(dgram[start_index:]) < _INT64_DGRAM_LEN:
+            raise ParseError('Datagram is too short')
+        return (
+            struct.unpack('>q',
+                          dgram[start_index:start_index + _INT64_DGRAM_LEN])[0],
+            start_index + _INT64_DGRAM_LEN)
+    except (struct.error, TypeError) as e:
+        raise ParseError('Could not parse datagram %s' % e)
+
+
 def get_uint64(dgram: bytes, start_index: int) -> Tuple[int, int]:
     """Get a 64-bit big-endian unsigned integer from the datagram.
 

pythonosc/test/test_osc_message.py

@@ -34,8 +34,9 @@
     b"/SYNC\x00\x00\x00"
     b"T"  # True
     b"F"  # False
-    b"[]\x00\x00\x00"  # Empty array
-    b"t\x00\x00\x00\x00\x00\x00\x00\x00"
+    b"[]th\x00\x00"  # Empty array
+    b"\x00\x00\x00\x00\x00\x00\x00\x00"
+    b"\x00\x00\x00\xe8\xd4\xa5\x10\x00"  # 1000000000000
 )
 
 _DGRAM_COMPLEX_ARRAY_PARAMS = (
@@ -99,12 +100,13 @@ def test_all_non_standard_params(self):
         msg = osc_message.OscMessage(_DGRAM_ALL_NON_STANDARD_TYPES_OF_PARAMS)
 
         self.assertEqual("/SYNC", msg.address)
-        self.assertEqual(4, len(msg.params))
+        self.assertEqual(5, len(msg.params))
         self.assertEqual(True, msg.params[0])
         self.assertEqual(False, msg.params[1])
         self.assertEqual([], msg.params[2])
         self.assertEqual((datetime(1900, 1, 1, 0, 0, 0), 0), msg.params[3])
-        self.assertEqual(4, len(list(msg)))
+        self.assertEqual(1000000000000, msg.params[4])
+        self.assertEqual(5, len(list(msg)))
 
     def test_complex_array_params(self):
         msg = osc_message.OscMessage(_DGRAM_COMPLEX_ARRAY_PARAMS)

pythonosc/test/test_osc_message_builder.py

@@ -27,6 +27,7 @@ def test_all_param_types(self):
         builder = osc_message_builder.OscMessageBuilder(address="/SYNC")
         builder.add_arg(4.0)
         builder.add_arg(2)
+        builder.add_arg(1099511627776)
         builder.add_arg("value")
         builder.add_arg(True)
         builder.add_arg(False)
@@ -36,6 +37,7 @@ def test_all_param_types(self):
         # The same args but with explicit types.
         builder.add_arg(4.0, builder.ARG_TYPE_FLOAT)
         builder.add_arg(2, builder.ARG_TYPE_INT)
+        builder.add_arg(1099511627776, builder.ARG_TYPE_INT64)
         builder.add_arg("value", builder.ARG_TYPE_STRING)
         builder.add_arg(True)
         builder.add_arg(False)
@@ -45,13 +47,13 @@ def test_all_param_types(self):
         builder.add_arg(4278255360, builder.ARG_TYPE_RGBA)
         builder.add_arg((1, 145, 36, 125), builder.ARG_TYPE_MIDI)
         builder.add_arg(1e-9, builder.ARG_TYPE_DOUBLE)
-        self.assertEqual(len("fisTFb[i[s]]N") * 2 + 3, len(builder.args))
+        self.assertEqual(len("fihsTFb[i[s]]N") * 2 + 3, len(builder.args))
         self.assertEqual("/SYNC", builder.address)
         builder.address = '/SEEK'
         msg = builder.build()
         self.assertEqual("/SEEK", msg.address)
         self.assertSequenceEqual(
-            [4.0, 2, "value", True, False, b"\x01\x02\x03", [1, ["abc"]]] * 2 +
+            [4.0, 2, 1099511627776, "value", True, False, b"\x01\x02\x03", [1, ["abc"]]] * 2 +
             [4278255360, (1, 145, 36, 125), 1e-9],
             msg.params)