def __init__(self, raw_hdfs_file, fs, mode, encoding=None, errors=None): self.mode = mode self.base_mode, is_text = common.parse_mode(self.mode) self.buff_size = raw_hdfs_file.buff_size if self.buff_size <= 0: self.buff_size = common.BUFSIZE if is_text: self.__encoding = encoding or self.__class__.ENCODING self.__errors = errors or self.__class__.ERRORS try: codecs.lookup(self.__encoding) codecs.lookup_error(self.__errors) except LookupError as e: raise ValueError(e) else: if encoding: raise ValueError( "binary mode doesn't take an encoding argument") if errors: raise ValueError("binary mode doesn't take an errors argument") self.__encoding = self.__errors = None cls = io.BufferedReader if self.base_mode == "r" else io.BufferedWriter self.f = cls(raw_hdfs_file, buffer_size=self.buff_size) self.__fs = fs info = fs.get_path_info(self.f.raw.name) self.__name = info["name"] self.__size = info["size"] self.closed = False
def validate_encoding_error_handler(setting, value, option_parser, config_parser=None, config_section=None): try: codecs.lookup_error(value) except AttributeError: # prior to Python 2.3 if value not in ("strict", "ignore", "replace", "xmlcharrefreplace"): raise ( LookupError( 'unknown encoding error handler: "%s" (choices: ' '"strict", "ignore", "replace", or "xmlcharrefreplace")' % value ), None, sys.exc_info()[2], ) except LookupError: raise ( LookupError( 'unknown encoding error handler: "%s" (choices: ' '"strict", "ignore", "replace", "backslashreplace", ' '"xmlcharrefreplace", and possibly others; see documentation for ' "the Python ``codecs`` module)" % value ), None, sys.exc_info()[2], ) return value
def change_encoding(file, encoding=None, errors=ERRORS): encoding = encoding or file.encoding errors = errors or file.errors codecs.lookup_error(errors) newfile = io.TextIOWrapper(file.buffer, encoding, errors, line_buffering=file.line_buffering) newfile.mode = file.mode newfile._changed_encoding = True return newfile
def test_lookup_error(self): #sanity self.assertRaises(LookupError, codecs.lookup_error, "blah garbage xyz") def garbage_error1(someError): pass codecs.register_error("blah garbage xyz", garbage_error1) self.assertEqual(codecs.lookup_error("blah garbage xyz"), garbage_error1) def garbage_error2(someError): pass codecs.register_error("some other", garbage_error2) self.assertEqual(codecs.lookup_error("some other"), garbage_error2)
def register_surrogateescape(): """ Registers the surrogateescape error handler on Python 2 (only) """ if utils.PY3: return try: codecs.lookup_error(FS_ERRORS) except LookupError: codecs.register_error(FS_ERRORS, surrogateescape_handler)
def validate_encoding_error_handler(setting, value, option_parser, config_parser=None, config_section=None): try: codecs.lookup_error(value) except LookupError: raise LookupError( 'unknown encoding error handler: "%s" (choices: ' '"strict", "ignore", "replace", "backslashreplace", ' '"xmlcharrefreplace", and possibly others; see documentation for ' 'the Python ``codecs`` module)' % value) return value
def test_lookup(self): self.assertEquals(codecs.strict_errors, codecs.lookup_error("strict")) self.assertEquals(codecs.ignore_errors, codecs.lookup_error("ignore")) self.assertEquals(codecs.strict_errors, codecs.lookup_error("strict")) self.assertEquals( codecs.xmlcharrefreplace_errors, codecs.lookup_error("xmlcharrefreplace") ) self.assertEquals( codecs.backslashreplace_errors, codecs.lookup_error("backslashreplace") )
def test_lookup(self): if test_support.due_to_ironpython_bug("http://tkbgitvstfat01:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=148421"): return self.assertEquals(codecs.strict_errors, codecs.lookup_error("strict")) self.assertEquals(codecs.ignore_errors, codecs.lookup_error("ignore")) self.assertEquals(codecs.strict_errors, codecs.lookup_error("strict")) self.assertEquals( codecs.xmlcharrefreplace_errors, codecs.lookup_error("xmlcharrefreplace") ) self.assertEquals( codecs.backslashreplace_errors, codecs.lookup_error("backslashreplace") )
def open_file_read_unicode(fname, which_error_handler="replace-if-possible"): """Open and read the file named 'fname', returning a Unicode string. It will also try to gloss over any Unicode-decoding errors that may occur, such as: UnicodeDecodeError: 'utf8' codec can't decode byte 0x97 in position 867373: invalid start byte It will return the string read (as a Unicode string object), plus a boolean value of whether the string contains non-ASCII Unicode. It will also return a list of objects describing any Unicode-decoding errors that occurred. (So IN SUMMARY, it returns a tuple of THREE ITEMS. I HOPE THIS IS CLEAR.) """ error_handler = codecs.lookup_error(which_error_handler) error_handler.reset() # Note that we open the file with the encoding "utf-8-sig", since this # encoding will remove the BOM (byte-order mark) if present. # See http://docs.python.org/library/codecs.html ; search for "-sig". f = codecs.open(fname, encoding="utf-8-sig", errors=which_error_handler) # 's' will be a Unicode string, which may or may not contain non-ASCII. s = f.read() return (s, contains_non_ascii_unicode(s), error_handler.errors)
def latscii_error( uerr ): key = ord(uerr.object[uerr.start:uerr.end]) try: return unichr(decoding_map[key]), uerr.end except KeyError: handler = codecs.lookup_error('replace') return handler(uerr)
def validate_encoding_error_handler(name, value): try: codecs.lookup_error(value) except AttributeError: # prior to Python 2.3 if value not in ('strict', 'ignore', 'replace'): raise (LookupError( 'unknown encoding error handler: "%s" (choices: ' '"strict", "ignore", or "replace")' % value), None, sys.exc_info()[2]) except LookupError: raise (LookupError( 'unknown encoding error handler: "%s" (choices: ' '"strict", "ignore", "replace", "backslashreplace", ' '"xmlcharrefreplace", and possibly others; see documentation for ' 'the Python ``codecs`` module)' % value), None, sys.exc_info()[2]) return value
def quote_ident(self, str): encodable = str.encode("utf-8", "strict").decode("utf-8") nul_index = encodable.find("\x00") if nul_index >= 0: error = UnicodeEncodeError("NUL-terminated utf-8", encodable, nul_index, nul_index + 1, "NUL not allowed") error_handler = codecs.lookup_error(errors) replacement, _ = error_handler(error) encodable = encodable.replace("\x00", replacement) return '"' + encodable.replace('"', '""') + '"'
def encode(self, input, errors='strict'): error = codecs.lookup_error(errors) def repl(match): start, end = match.span() return encoding_map.get(match.group()) or \ error(UnicodeEncodeError(encoding, input, start, end, "undefined conversion emoji"))[0] output = google_emoji_re.sub(repl, input) return (base_codec.encode(output, errors)[0], len(input))
def convert(conv, data, final, errors='strict'): try: res = conv.convert(data, finished=final, options=Option.DontUseReplacementChar) return (res,len(res)) except UnicodeEncodeError as uerr: rep,rp = codecs.lookup_error(errors)(uerr) try: prefix = conv.convert(uerr.object[:uerr.start] + rep, finished=final, options=Option.DontUseReplacementChar) except UnicodeEncodeError: raise UnicodeEncodeError(*(uerr.args[:4] + ('cannot convert replacement %r to target encoding' % rep,))) suffix = Codec.convert(conv, data[rp:], final, errors) return (prefix+suffix[0],rp+suffix[1]) except UnicodeDecodeError as uerr: rep,rp = codecs.lookup_error(errors)(uerr) prefix = conv.convert(uerr.object[:uerr.start], finished=final, options=Option.DontUseReplacementChar) suffix = Codec.convert(conv, data[rp:], final, errors) return (prefix+rep+suffix[0],rp+suffix[1])
def quote_identifier(s, errors="strict"): encodable = s.encode("utf-8", errors).decode("utf-8") nul_index = encodable.find("\x00") if nul_index >= 0: error = UnicodeEncodeError("NUL-terminated utf-8", encodable, nul_index, nul_index + 1, "NUL not allowed") error_handler = codecs.lookup_error(errors) replacement, _ = error_handler(error) encodable = encodable.replace("\x00", replacement) return "\"" + encodable.replace("\"", "\"\"") + "\""
def _quote_identifier(self, s, errors="ignore"): encodable = s.encode("utf-8", errors).decode("utf-8") nul_index = encodable.find("\x00") if nul_index >= 0: error = UnicodeEncodeError("utf-8", encodable, nul_index, nul_index + 1, "NUL not allowed") error_handler = codecs.lookup_error(errors) replacement, _ = error_handler(error) encodable = encodable.replace("\x00", replacement) return u'"' + encodable.replace('"', '""') + u'"'
def imap_utf7_decode(input, errors='strict'): error = codecs.lookup_error(errors) output = [] shifted = 0 b64 = False i = 0 while i < len(input): b = input[i] if b64: if b == 0x2d: # '-' if shifted == i: output.append('&') else: dec = bytes(input[shifted:i]) + b'=' * ((4 - (i - shifted)) % 4) try: utf16 = base64.b64decode(dec, altchars=b'+,', validate=True) output.append(utf16.decode('utf-16-be')) except (binascii.Error, UnicodeDecodeError) as e: if isinstance(e, binascii.Error): reason = 'invalid Base64' else: reason = 'invalid UTF-16BE' exc = UnicodeDecodeError('imap-utf-7', input, shifted - 1, i + 1, reason) replace, i = error(exc) shifted = i output.append(replace) b64 = False continue shifted = i + 1 b64 = False else: if b == 0x26: # '&' output.append(codecs.decode(input[shifted:i], 'ascii')) shifted = i + 1 b64 = True if b < 0x20 or b > 0x7e: output.append(codecs.decode(input[shifted:i], 'ascii')) exc = UnicodeDecodeError('imap-utf-7', input, i, i + 1, 'character must be Base64 encoded') replace, i = error(exc) shifted = i output.append(replace) continue i += 1 if b64: exc = UnicodeDecodeError('imap-utf-7', input, len(input), len(input), 'input does not end in US-ASCII') replace, cont = error(exc) output.append(replace) else: output.append(codecs.decode(input[shifted:], 'ascii')) return ''.join(output), len(input)
def _fscodec(): encoding = sys.getfilesystemencoding() if encoding == 'mbcs': errors = 'strict' else: try: from codecs import lookup_error lookup_error('surrogateescape') except LookupError: errors = 'strict' else: errors = 'surrogateescape' def fsencode(filename): """ Encode filename to the filesystem encoding with 'surrogateescape' error handler, return bytes unchanged. On Windows, use 'strict' error handler if the file system encoding is 'mbcs' (which is the default encoding). """ if isinstance(filename, six.binary_type): return filename elif isinstance(filename, six.text_type): return filename.encode(encoding, errors) else: raise TypeError("expect bytes or str, not %s" % type(filename).__name__) def fsdecode(filename): """ Decode filename from the filesystem encoding with 'surrogateescape' error handler, return str unchanged. On Windows, use 'strict' error handler if the file system encoding is 'mbcs' (which is the default encoding). """ if isinstance(filename, six.text_type): return filename elif isinstance(filename, six.binary_type): return filename.decode(encoding, errors) else: raise TypeError("expect bytes or str, not %s" % type(filename).__name__) return fsencode, fsdecode
def ignore_unicode_errors(errors='ignore'): """Overwrite the ``strict`` codecs error handler temporarily. This is useful e.g. if the engine truncates a string, which results in a string that contains a splitted multi-byte character at the end of the string. :param str errors: Error handler that will be looked up via :func:`codecs.lookup_error`. :raise LookupError: Raised if the error handler was not found. Example: .. code:: python import memory # Allocate four bytes to create an erroneous string ptr = memory.alloc(4) # Write data to the memory that will usually result in a # UnicodeDecodeError ptr.set_uchar(ord('a'), 0) ptr.set_uchar(ord('b'), 1) ptr.set_uchar(226, 2) # Add the invalid byte ptr.set_uchar(0, 3) # Indicate the end of the string with ignore_unicode_errors(): # Read the data as a string. Now, it will only print 'ab', because # the invalid byte has been removed/ignored. print(ptr.get_string_array()) """ old_handler = codecs.lookup_error('strict') codecs.register_error('strict', codecs.lookup_error(errors)) try: yield finally: codecs.register_error('strict', old_handler)
def test_fake_error_class(self): handlers = [ codecs.strict_errors, codecs.ignore_errors, codecs.replace_errors, codecs.backslashreplace_errors, codecs.xmlcharrefreplace_errors, codecs.lookup_error('surrogateescape'), codecs.lookup_error('surrogatepass'), ] for cls in UnicodeEncodeError, UnicodeDecodeError, UnicodeTranslateError: class FakeUnicodeError(str): __class__ = cls for handler in handlers: with self.subTest(handler=handler, error_class=cls): self.assertRaises(TypeError, handler, FakeUnicodeError()) class FakeUnicodeError(Exception): __class__ = cls for handler in handlers: with self.subTest(handler=handler, error_class=cls): with self.assertRaises((TypeError, FakeUnicodeError)): handler(FakeUnicodeError())
def _quote_id(self, s, errors=u"strict"): encodable = s.encode("utf-8", errors).decode(u"utf-8") nul_index = encodable.find(u"\x00") if nul_index >= 0: error = UnicodeEncodeError(u"NUL-terminated utf-8", encodable, nul_index, nul_index + 1, u"NUL not allowed") error_handler = codecs.lookup_error(errors) replacement, _ = error_handler(error) encodable = encodable.replace(u"\x00", replacement) return u"\"" + encodable.replace(u"\"", u"\"\"") + u"\""
def latscii_error(uerr): text = uerr.object[uerr.start:uerr.end] ret = '' for c in text: key = ord(c) try: ret += unichr(decoding_map[key]) except KeyError: handler = codecs.lookup_error('replace') return handler(uerr) return ret, uerr.end
def _quote(s, errors='strict'): encodable = s.encode('utf-8', errors).decode('utf-8') nul_index = encodable.find('\x00') if nul_index >= 0: error = UnicodeEncodeError('NUL-terminated utf-8', encodable, nul_index, nul_index + 1, 'NUL not allowed') error_handler = codecs.lookup_error(errors) replacement, _ = error_handler(error) encodable = encodable.replace('\x00', replacement) return '"' + encodable.replace('"', '""') + '"'
def __init__(self, transmogrifier, name, options, previous): self.previous = previous if options.get('from'): from_ = options['from'].strip().lower() if from_ != 'unicode': if from_ == 'default': from_ = _get_default_encoding(transmogrifier.context) # Test if the decoder is available codecs.getdecoder(from_) self.from_ = from_ self.from_error_handler = options.get( 'from-error-handler', self.from_error_handler).strip().lower() # Test if the error handler is available codecs.lookup_error(self.from_error_handler) if options.get('to'): to = options['to'].strip().lower() if to != 'unicode': if to == 'default': to = _get_default_encoding(transmogrifier.context) # Test if the encoder is available codecs.getencoder(to) self.to = to self.to_error_handler = options.get( 'to-error-handler', self.to_error_handler).strip().lower() # Test if the error handler is available codecs.lookup_error(self.to_error_handler) self.matcher = Matcher(*options['keys'].splitlines()) self.condition = Condition(options.get('condition', 'python:True'), transmogrifier, name, options)
def _fscodec(): encoding = sys.getfilesystemencoding() errors = "strict" if encoding != "mbcs": try: codecs.lookup_error("surrogateescape") except LookupError: pass else: errors = "surrogateescape" def fsencode(filename): """ Encode filename to the filesystem encoding with 'surrogateescape' error handler, return bytes unchanged. On Windows, use 'strict' error handler if the file system encoding is 'mbcs' (which is the default encoding). """ if isinstance(filename, bytes): return filename else: return filename.encode(encoding, errors) return fsencode
def quote_identifier(s, errors="strict"): # Quotes a SQLite identifier. Source: http://stackoverflow.com/a/6701665 encodable = s.encode("utf-8", errors).decode("utf-8") nul_index = encodable.find("\x00") if nul_index >= 0: error = UnicodeEncodeError("NUL-terminated utf-8", encodable, nul_index, nul_index + 1, "NUL not allowed") error_handler = codecs.lookup_error(errors) replacement, _ = error_handler(error) encodable = encodable.replace("\x00", replacement) return "\"" + encodable.replace("\"", "\"\"") + "\""
def test_longstrings(self): # test long strings to check for memory overflow problems errors = [ "strict", "ignore", "replace", "xmlcharrefreplace", "backslashreplace"] # register the handlers under different names, # to prevent the codec from recognizing the name for err in errors: codecs.register_error("test." + err, codecs.lookup_error(err)) l = 1000 errors += [ "test." + err for err in errors ] for uni in [ s*l for s in (u"x", u"\u3042", u"a\xe4") ]: for enc in ("ascii", "latin-1", "iso-8859-1", "iso-8859-15", "utf-8", "utf-7", "utf-16"): for err in errors: try: uni.encode(enc, err) except UnicodeError: pass
def quote_identifier(s, errors="replace"): ''' SqLite does not provide an identifier sanitizer so we use this method ''' encodable = s.encode("utf-8", errors).decode("utf-8") nul_index = encodable.find("\x00") if nul_index >= 0: error = UnicodeEncodeError("NUL-terminated utf-8", encodable, nul_index, nul_index + 1, "NUL not allowed") error_handler = codecs.lookup_error(errors) replacement, _ = error_handler(error) encodable = encodable.replace("\x00", replacement) return "\"" + encodable.replace("\"", "\"\"") + "\""
def test_badandgoodsurrogateescapeexceptions(self): surrogateescape_errors = codecs.lookup_error('surrogateescape') # "surrogateescape" complains about a non-exception passed in self.assertRaises( TypeError, surrogateescape_errors, 42 ) # "surrogateescape" complains about the wrong exception types self.assertRaises( TypeError, surrogateescape_errors, UnicodeError("ouch") ) # "surrogateescape" can not be used for translating self.assertRaises( TypeError, surrogateescape_errors, UnicodeTranslateError("\udc80", 0, 1, "ouch") ) # Use the correct exception for s in ("a", "\udc7f", "\udd00"): with self.subTest(str=s): self.assertRaises( UnicodeEncodeError, surrogateescape_errors, UnicodeEncodeError("ascii", s, 0, 1, "ouch") ) self.assertEqual( surrogateescape_errors( UnicodeEncodeError("ascii", "a\udc80b", 1, 2, "ouch")), (b"\x80", 2) ) self.assertRaises( UnicodeDecodeError, surrogateescape_errors, UnicodeDecodeError("ascii", bytearray(b"a"), 0, 1, "ouch") ) self.assertEqual( surrogateescape_errors( UnicodeDecodeError("ascii", bytearray(b"a\x80b"), 1, 2, "ouch")), ("\udc80", 2) )
def decode(self, input, errors='strict', final=True): error_function = codecs.lookup_error(errors) input_buffer = ByteBuffer.wrap(array('b', input)) decoder = Charset.forName(self.encoding).newDecoder() output_buffer = CharBuffer.allocate(min(max(int(len(input) / 2), 256), 1024)) builder = StringBuilder(int(decoder.averageCharsPerByte() * len(input))) while True: result = decoder.decode(input_buffer, output_buffer, False) pos = output_buffer.position() output_buffer.rewind() builder.append(output_buffer.subSequence(0, pos)) if result.isUnderflow(): if final: _process_incomplete_decode(self.encoding, input, error_function, input_buffer, builder) break _process_decode_errors(self.encoding, input, result, error_function, input_buffer, builder) return builder.toString(), input_buffer.position()
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.header is None: self.header = std_msgs.msg.Header() if self.elements is None: self.elements = None end = 0 _x = self start = end end += 12 (_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.header.frame_id = str[start:end] start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) self.elements = [] for i in range(0, length): val1 = spencer_tracking_msgs.msg.CompositeDetectedPerson() _x = val1 start = end end += 32 (_x.composite_detection_id, _x.mean_confidence, _x.max_confidence, _x.min_confidence,) = _get_struct_Q3d().unpack(str[start:end]) _v25 = val1.pose _v26 = _v25.pose _v27 = _v26.position _x = _v27 start = end end += 24 (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end]) _v28 = _v26.orientation _x = _v28 start = end end += 32 (_x.x, _x.y, _x.z, _x.w,) = _get_struct_4d().unpack(str[start:end]) start = end end += 288 _v25.covariance = numpy.frombuffer(str[start:end], dtype=numpy.float64, count=36) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) val1.original_detections = [] for i in range(0, length): val2 = spencer_tracking_msgs.msg.DetectedPerson() _x = val2 start = end end += 16 (_x.detection_id, _x.confidence,) = _get_struct_Qd().unpack(str[start:end]) _v29 = val2.pose _v30 = _v29.pose _v31 = _v30.position _x = _v31 start = end end += 24 (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end]) _v32 = _v30.orientation _x = _v32 start = end end += 32 (_x.x, _x.y, _x.z, _x.w,) = _get_struct_4d().unpack(str[start:end]) start = end end += 288 _v29.covariance = numpy.frombuffer(str[start:end], dtype=numpy.float64, count=36) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val2.modality = str[start:end].decode('utf-8', 'rosmsg') else: val2.modality = str[start:end] val1.original_detections.append(val2) self.elements.append(val1) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize(self, str): """ unpack serialized message in str into this message instance :param str: byte array of serialized message, ``str`` """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.header is None: self.header = std_msgs.msg.Header() if self.status is None: self.status = actionlib_msgs.msg.GoalStatus() if self.feedback is None: self.feedback = control_msgs.msg.SingleJointPositionFeedback() end = 0 _x = self start = end end += 12 ( _x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs, ) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.header.frame_id = str[start:end] _x = self start = end end += 8 ( _x.status.goal_id.stamp.secs, _x.status.goal_id.stamp.nsecs, ) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.status.goal_id.id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.status.goal_id.id = str[start:end] start = end end += 1 (self.status.status, ) = _get_struct_B().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.status.text = str[start:end].decode('utf-8', 'rosmsg') else: self.status.text = str[start:end] _x = self start = end end += 12 ( _x.feedback.header.seq, _x.feedback.header.stamp.secs, _x.feedback.header.stamp.nsecs, ) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.feedback.header.frame_id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.feedback.header.frame_id = str[start:end] _x = self start = end end += 24 ( _x.feedback.position, _x.feedback.velocity, _x.feedback.error, ) = _get_struct_3d().unpack(str[start:end]) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.plan is None: self.plan = rtabmap_ros.msg.Path() end = 0 _x = self start = end end += 12 ( _x.plan.header.seq, _x.plan.header.stamp.secs, _x.plan.header.stamp.nsecs, ) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.plan.header.frame_id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.plan.header.frame_id = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) pattern = '<%si' % length start = end s = struct.Struct(pattern) end += s.size self.plan.nodeIds = numpy.frombuffer(str[start:end], dtype=numpy.int32, count=length) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) self.plan.poses = [] for i in range(0, length): val1 = geometry_msgs.msg.Pose() _v7 = val1.position _x = _v7 start = end end += 24 ( _x.x, _x.y, _x.z, ) = _get_struct_3d().unpack(str[start:end]) _v8 = val1.orientation _x = _v8 start = end end += 32 ( _x.x, _x.y, _x.z, _x.w, ) = _get_struct_4d().unpack(str[start:end]) self.plan.poses.append(val1) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def provide_surrogateescape(): r""" Provide the ``surrogateescape`` error handler for bytes-to-unicode decoding. The source code of the function has been copied from https://bitbucket.org/haypo/misc/src/d76f4ff5d27c746c883d40160c8b4fb0891e79f2/python/surrogateescape.py?at=default and then adjusted, optimized and commented. Original code was created by Victor Stinner and released by him under the Python license and the BSD 2-clause license. The ``surrogateescape`` error handler is provided out-of-the-box in Python 3 but not in Python 2. It can be used to convert arbitrary binary data to Unicode in a practically non-destructive way. .. seealso:: https://www.python.org/dev/peps/pep-0383. This implementation (for Python 2) covers only the decoding part of the handler, i.e. the :class:`str`-to-:class:`unicode` conversion. The encoding (:class:`unicode`-to-:class:`str`) part is not implemented. Note, however, that once we transformed a binary data into a *surrogate-escaped* Unicode data we can (in Python 2) freely encode/decode it (:class:`unicode`-to/from-:class:`str`), not using ``surrogateescape`` anymore, e.g.: >>> # We assume that the function has already been called -- >>> # as it is imported and called in N6SDK/n6sdk/__init__.py >>> b = 'ołówek \xee\xdd' # utf-8 text + some non-utf-8 mess >>> b 'o\xc5\x82\xc3\xb3wek \xee\xdd' >>> u = b.decode('utf-8', 'surrogateescape') >>> u u'o\u0142\xf3wek \udcee\udcdd' >>> b2 = u.encode('utf-8') >>> b2 # now all stuff is utf-8 encoded 'o\xc5\x82\xc3\xb3wek \xed\xb3\xae\xed\xb3\x9d' >>> u2 = b2.decode('utf-8') >>> u2 == u True >>> u.encode('latin2', # doctest: +IGNORE_EXCEPTION_DETAIL ... 'surrogateescape') # does not work for *encoding* Traceback (most recent call last): ... TypeError: don't know how to handle UnicodeEncodeError in error callback This function is idempotent (i.e., it can be called safely multiple times -- because if the handler is already registered the function does not try to register it again) though it is not thread-safe (typically it does not matter as the function is supposed to be called somewhere at the beginning of program execution). .. note:: This function is called automatically on first import of :mod:`n6sdk` module or any of its submodules. .. warning:: In Python 3 (if you were using a Python-3-based application or script to handle data produced with Python 2), the ``utf-8`` codec (as well as other ``utf-...`` codecs) does not decode *surrogate-escaped* data encoded to bytes with the Python 2's ``utf-8`` codec unless the ``surrogatepass`` error handler is used for decoding (on the Python 3 side). """ def surrogateescape( exc, # to avoid namespace dict lookups: isinstance=isinstance, UnicodeDecodeError=UnicodeDecodeError, ord=ord, unichr=unichr, unicode_join=u''.join): if isinstance(exc, UnicodeDecodeError): decoded = [] append_to_decoded = decoded.append for ch in exc.object[exc.start:exc.end]: code = ord(ch) if 0x80 <= code <= 0xFF: append_to_decoded(unichr(0xDC00 + code)) elif code <= 0x7F: append_to_decoded(unichr(code)) else: raise exc decoded = unicode_join(decoded) return (decoded, exc.end) else: raise TypeError( "don't know how to handle {} in error callback".format( type(exc).__name__)) import codecs try: codecs.lookup_error('surrogateescape') except LookupError: codecs.register_error('surrogateescape', surrogateescape)
open = builtins.open def compat_open(*args, **kwargs): if (sys._getframe(1).f_code.co_flags & 0xa000) == 0xa000: return open(*args, **kwargs) else: return python_open(*args, **kwargs) ################################################################################ # Make strict use surrogateescape error handling. if PY2: import codecs strict_error = codecs.lookup_error("strict") codecs.register_error("python_strict", strict_error) surrogateescape_error = codecs.lookup_error("surrogateescape") codecs.register_error("strict", surrogateescape_error) import renpy renpy.update_path() ################################################################################ # String (text and binary) types and functions. basestring = future.utils.string_types # @ReservedAssignment pystr = str str = future.utils.text_type # @ReservedAssignment unicode = future.utils.text_type # @ReservedAssignment
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.header is None: self.header = std_msgs.msg.Header() if self.goal_id is None: self.goal_id = actionlib_msgs.msg.GoalID() if self.goal is None: self.goal = part_fetcher.msg.PartFetcherGoal() end = 0 _x = self start = end end += 12 (_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.header.frame_id = str[start:end] _x = self start = end end += 8 (_x.goal_id.stamp.secs, _x.goal_id.stamp.nsecs,) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.goal_id.id = str[start:end].decode('utf-8', 'rosmsg') else: self.goal_id.id = str[start:end] _x = self start = end end += 16 (_x.goal.object_id, _x.goal.object_frame.header.seq, _x.goal.object_frame.header.stamp.secs, _x.goal.object_frame.header.stamp.nsecs,) = _get_struct_i3I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.goal.object_frame.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.goal.object_frame.header.frame_id = str[start:end] _x = self start = end end += 68 (_x.goal.object_frame.pose.position.x, _x.goal.object_frame.pose.position.y, _x.goal.object_frame.pose.position.z, _x.goal.object_frame.pose.orientation.x, _x.goal.object_frame.pose.orientation.y, _x.goal.object_frame.pose.orientation.z, _x.goal.object_frame.pose.orientation.w, _x.goal.desired_frame.header.seq, _x.goal.desired_frame.header.stamp.secs, _x.goal.desired_frame.header.stamp.nsecs,) = _get_struct_7d3I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.goal.desired_frame.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.goal.desired_frame.header.frame_id = str[start:end] _x = self start = end end += 56 (_x.goal.desired_frame.pose.position.x, _x.goal.desired_frame.pose.position.y, _x.goal.desired_frame.pose.position.z, _x.goal.desired_frame.pose.orientation.x, _x.goal.desired_frame.pose.orientation.y, _x.goal.desired_frame.pose.orientation.z, _x.goal.desired_frame.pose.orientation.w,) = _get_struct_7d().unpack(str[start:end]) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.joint_trajectory is None: self.joint_trajectory = trajectory_msgs.msg.JointTrajectory() if self.model_pose is None: self.model_pose = geometry_msgs.msg.Pose() end = 0 start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.model_name = str[start:end].decode('utf-8', 'rosmsg') else: self.model_name = str[start:end] _x = self start = end end += 12 ( _x.joint_trajectory.header.seq, _x.joint_trajectory.header.stamp.secs, _x.joint_trajectory.header.stamp.nsecs, ) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.joint_trajectory.header.frame_id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.joint_trajectory.header.frame_id = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) self.joint_trajectory.joint_names = [] for i in range(0, length): start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1 = str[start:end].decode('utf-8', 'rosmsg') else: val1 = str[start:end] self.joint_trajectory.joint_names.append(val1) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) self.joint_trajectory.points = [] for i in range(0, length): val1 = trajectory_msgs.msg.JointTrajectoryPoint() start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) pattern = '<%sd' % length start = end s = struct.Struct(pattern) end += s.size val1.positions = numpy.frombuffer(str[start:end], dtype=numpy.float64, count=length) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) pattern = '<%sd' % length start = end s = struct.Struct(pattern) end += s.size val1.velocities = numpy.frombuffer(str[start:end], dtype=numpy.float64, count=length) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) pattern = '<%sd' % length start = end s = struct.Struct(pattern) end += s.size val1.accelerations = numpy.frombuffer(str[start:end], dtype=numpy.float64, count=length) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) pattern = '<%sd' % length start = end s = struct.Struct(pattern) end += s.size val1.effort = numpy.frombuffer(str[start:end], dtype=numpy.float64, count=length) _v4 = val1.time_from_start _x = _v4 start = end end += 8 ( _x.secs, _x.nsecs, ) = _get_struct_2i().unpack(str[start:end]) self.joint_trajectory.points.append(val1) _x = self start = end end += 58 ( _x.model_pose.position.x, _x.model_pose.position.y, _x.model_pose.position.z, _x.model_pose.orientation.x, _x.model_pose.orientation.y, _x.model_pose.orientation.z, _x.model_pose.orientation.w, _x.set_model_pose, _x.disable_physics_updates, ) = _get_struct_7d2B().unpack(str[start:end]) self.set_model_pose = bool(self.set_model_pose) self.disable_physics_updates = bool(self.disable_physics_updates) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.action_goal is None: self.action_goal = stdr_msgs.msg.DeleteRobotActionGoal() if self.action_result is None: self.action_result = stdr_msgs.msg.DeleteRobotActionResult() if self.action_feedback is None: self.action_feedback = stdr_msgs.msg.DeleteRobotActionFeedback( ) end = 0 _x = self start = end end += 12 ( _x.action_goal.header.seq, _x.action_goal.header.stamp.secs, _x.action_goal.header.stamp.nsecs, ) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_goal.header.frame_id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_goal.header.frame_id = str[start:end] _x = self start = end end += 8 ( _x.action_goal.goal_id.stamp.secs, _x.action_goal.goal_id.stamp.nsecs, ) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_goal.goal_id.id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_goal.goal_id.id = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_goal.goal.name = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_goal.goal.name = str[start:end] _x = self start = end end += 12 ( _x.action_result.header.seq, _x.action_result.header.stamp.secs, _x.action_result.header.stamp.nsecs, ) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_result.header.frame_id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_result.header.frame_id = str[start:end] _x = self start = end end += 8 ( _x.action_result.status.goal_id.stamp.secs, _x.action_result.status.goal_id.stamp.nsecs, ) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_result.status.goal_id.id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_result.status.goal_id.id = str[start:end] start = end end += 1 (self.action_result.status.status, ) = _get_struct_B().unpack( str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_result.status.text = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_result.status.text = str[start:end] _x = self start = end end += 13 ( _x.action_result.result.success, _x.action_feedback.header.seq, _x.action_feedback.header.stamp.secs, _x.action_feedback.header.stamp.nsecs, ) = _get_struct_B3I().unpack(str[start:end]) self.action_result.result.success = bool( self.action_result.result.success) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_feedback.header.frame_id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_feedback.header.frame_id = str[start:end] _x = self start = end end += 8 ( _x.action_feedback.status.goal_id.stamp.secs, _x.action_feedback.status.goal_id.stamp.nsecs, ) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_feedback.status.goal_id.id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_feedback.status.goal_id.id = str[start:end] start = end end += 1 (self.action_feedback.status.status, ) = _get_struct_B().unpack( str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_feedback.status.text = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_feedback.status.text = str[start:end] return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ codecs.lookup_error("rosmsg").msg_type = self._type try: end = 0 start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.port_name = str[start:end].decode('utf-8', 'rosmsg') else: self.port_name = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.package_path = str[start:end].decode('utf-8', 'rosmsg') else: self.package_path = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.module_name = str[start:end].decode('utf-8', 'rosmsg') else: self.module_name = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.class_name = str[start:end].decode('utf-8', 'rosmsg') else: self.class_name = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.controller_name = str[start:end].decode('utf-8', 'rosmsg') else: self.controller_name = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) self.dependencies = [] for i in range(0, length): start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1 = str[start:end].decode('utf-8', 'rosmsg') else: val1 = str[start:end] self.dependencies.append(val1) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ if python3: codecs.lookup_error("rosmsg").msg_type = self._type try: if self.map is None: self.map = nav_msgs.msg.OccupancyGrid() end = 0 _x = self start = end end += 12 ( _x.map.header.seq, _x.map.header.stamp.secs, _x.map.header.stamp.nsecs, ) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.map.header.frame_id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.map.header.frame_id = str[start:end] _x = self start = end end += 76 ( _x.map.info.map_load_time.secs, _x.map.info.map_load_time.nsecs, _x.map.info.resolution, _x.map.info.width, _x.map.info.height, _x.map.info.origin.position.x, _x.map.info.origin.position.y, _x.map.info.origin.position.z, _x.map.info.origin.orientation.x, _x.map.info.origin.orientation.y, _x.map.info.origin.orientation.z, _x.map.info.origin.orientation.w, ) = _get_struct_2If2I7d().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) pattern = '<%sb' % length start = end s = struct.Struct(pattern) end += s.size self.map.data = numpy.frombuffer(str[start:end], dtype=numpy.int8, count=length) start = end end += 1 (self.result, ) = _get_struct_B().unpack(str[start:end]) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.header is None: self.header = std_msgs.msg.Header() if self.status is None: self.status = actionlib_msgs.msg.GoalStatus() if self.feedback is None: self.feedback = ros_essentials_cpp.msg.FibonacciFeedback() end = 0 _x = self start = end end += 12 ( _x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs, ) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.header.frame_id = str[start:end] _x = self start = end end += 8 ( _x.status.goal_id.stamp.secs, _x.status.goal_id.stamp.nsecs, ) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.status.goal_id.id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.status.goal_id.id = str[start:end] start = end end += 1 (self.status.status, ) = _get_struct_B().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.status.text = str[start:end].decode('utf-8', 'rosmsg') else: self.status.text = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) pattern = '<%si' % length start = end end += struct.calcsize(pattern) self.feedback.sequence = numpy.frombuffer(str[start:end], dtype=numpy.int32, count=length) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize(self, str): """ unpack serialized message in str into this message instance :param str: byte array of serialized message, ``str`` """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.header is None: self.header = std_msgs.msg.Header() if self.elements is None: self.elements = None end = 0 _x = self start = end end += 12 (_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.header.frame_id = str[start:end] start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) self.elements = [] for i in range(0, length): val1 = spencer_tracking_msgs.msg.CompositeDetectedPerson() _x = val1 start = end end += 32 (_x.composite_detection_id, _x.mean_confidence, _x.max_confidence, _x.min_confidence,) = _get_struct_Q3d().unpack(str[start:end]) _v9 = val1.pose _v10 = _v9.pose _v11 = _v10.position _x = _v11 start = end end += 24 (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end]) _v12 = _v10.orientation _x = _v12 start = end end += 32 (_x.x, _x.y, _x.z, _x.w,) = _get_struct_4d().unpack(str[start:end]) start = end end += 288 _v9.covariance = _get_struct_36d().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) val1.original_detections = [] for i in range(0, length): val2 = spencer_tracking_msgs.msg.DetectedPerson() _x = val2 start = end end += 16 (_x.detection_id, _x.confidence,) = _get_struct_Qd().unpack(str[start:end]) _v13 = val2.pose _v14 = _v13.pose _v15 = _v14.position _x = _v15 start = end end += 24 (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end]) _v16 = _v14.orientation _x = _v16 start = end end += 32 (_x.x, _x.y, _x.z, _x.w,) = _get_struct_4d().unpack(str[start:end]) start = end end += 288 _v13.covariance = _get_struct_36d().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val2.modality = str[start:end].decode('utf-8', 'rosmsg') else: val2.modality = str[start:end] val1.original_detections.append(val2) self.elements.append(val1) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def get_handle( path_or_buf: FilePathOrBuffer, mode: str, encoding: str | None = None, compression: CompressionOptions = None, memory_map: bool = False, is_text: bool = True, errors: str | None = None, storage_options: StorageOptions = None, ) -> IOHandles: """ Get file handle for given path/buffer and mode. Parameters ---------- path_or_buf : str or file handle File path or object. mode : str Mode to open path_or_buf with. encoding : str or None Encoding to use. compression : str or dict, default None If string, specifies compression mode. If dict, value at key 'method' specifies compression mode. Compression mode must be one of {'infer', 'gzip', 'bz2', 'zip', 'xz', None}. If compression mode is 'infer' and `filepath_or_buffer` is path-like, then detect compression from the following extensions: '.gz', '.bz2', '.zip', or '.xz' (otherwise no compression). If dict and compression mode is one of {'zip', 'gzip', 'bz2'}, or inferred as one of the above, other entries passed as additional compression options. .. versionchanged:: 1.0.0 May now be a dict with key 'method' as compression mode and other keys as compression options if compression mode is 'zip'. .. versionchanged:: 1.1.0 Passing compression options as keys in dict is now supported for compression modes 'gzip' and 'bz2' as well as 'zip'. memory_map : bool, default False See parsers._parser_params for more information. is_text : bool, default True Whether the type of the content passed to the file/buffer is string or bytes. This is not the same as `"b" not in mode`. If a string content is passed to a binary file/buffer, a wrapper is inserted. errors : str, default 'strict' Specifies how encoding and decoding errors are to be handled. See the errors argument for :func:`open` for a full list of options. storage_options: StorageOptions = None Passed to _get_filepath_or_buffer .. versionchanged:: 1.2.0 Returns the dataclass IOHandles """ # Windows does not default to utf-8. Set to utf-8 for a consistent behavior encoding = encoding or "utf-8" # read_csv does not know whether the buffer is opened in binary/text mode if _is_binary_mode(path_or_buf, mode) and "b" not in mode: mode += "b" # validate encoding and errors if isinstance(encoding, str): codecs.lookup(encoding) if isinstance(errors, str): codecs.lookup_error(errors) # open URLs ioargs = _get_filepath_or_buffer( path_or_buf, encoding=encoding, compression=compression, mode=mode, storage_options=storage_options, ) handle = ioargs.filepath_or_buffer handles: list[Buffer] # memory mapping needs to be the first step handle, memory_map, handles = _maybe_memory_map( handle, memory_map, ioargs.encoding, ioargs.mode, errors, ioargs.compression["method"] not in _compression_to_extension, ) is_path = isinstance(handle, str) compression_args = dict(ioargs.compression) compression = compression_args.pop("method") # Only for write methods if "r" not in mode and is_path: check_parent_directory(str(handle)) if compression: # compression libraries do not like an explicit text-mode ioargs.mode = ioargs.mode.replace("t", "") # GZ Compression if compression == "gzip": if is_path: assert isinstance(handle, str) handle = gzip.GzipFile( filename=handle, mode=ioargs.mode, **compression_args, ) else: handle = gzip.GzipFile( # error: Argument "fileobj" to "GzipFile" has incompatible type # "Union[str, Union[IO[Any], RawIOBase, BufferedIOBase, TextIOBase, # TextIOWrapper, mmap]]"; expected "Optional[IO[bytes]]" fileobj=handle, # type: ignore[arg-type] mode=ioargs.mode, **compression_args, ) # BZ Compression elif compression == "bz2": handle = bz2.BZ2File( # Argument 1 to "BZ2File" has incompatible type "Union[str, # Union[IO[Any], RawIOBase, BufferedIOBase, TextIOBase, TextIOWrapper, # mmap]]"; expected "Union[Union[str, bytes, _PathLike[str], # _PathLike[bytes]], IO[bytes]]" handle, # type: ignore[arg-type] mode=ioargs.mode, **compression_args, ) # ZIP Compression elif compression == "zip": handle = _BytesZipFile(handle, ioargs.mode, **compression_args) if handle.mode == "r": handles.append(handle) zip_names = handle.namelist() if len(zip_names) == 1: handle = handle.open(zip_names.pop()) elif len(zip_names) == 0: raise ValueError( f"Zero files found in ZIP file {path_or_buf}") else: raise ValueError("Multiple files found in ZIP file. " f"Only one file per ZIP: {zip_names}") # XZ Compression elif compression == "xz": handle = get_lzma_file(lzma)(handle, ioargs.mode) # Unrecognized Compression else: msg = f"Unrecognized compression type: {compression}" raise ValueError(msg) assert not isinstance(handle, str) handles.append(handle) elif isinstance(handle, str): # Check whether the filename is to be opened in binary mode. # Binary mode does not support 'encoding' and 'newline'. if ioargs.encoding and "b" not in ioargs.mode: # Encoding handle = open( handle, ioargs.mode, encoding=ioargs.encoding, errors=errors, newline="", ) else: # Binary mode handle = open(handle, ioargs.mode) handles.append(handle) # Convert BytesIO or file objects passed with an encoding is_wrapped = False if not is_text and ioargs.mode == "rb" and isinstance(handle, TextIOBase): handle = BytesIOWrapper( handle, encoding=ioargs.encoding, ) handles.append(handle) # the (text) handle is always provided by the caller # since get_handle would have opened it in binary mode is_wrapped = True elif is_text and (compression or _is_binary_mode(handle, ioargs.mode)): handle = TextIOWrapper( # error: Argument 1 to "TextIOWrapper" has incompatible type # "Union[IO[bytes], IO[Any], RawIOBase, BufferedIOBase, TextIOBase, mmap]"; # expected "IO[bytes]" handle, # type: ignore[arg-type] encoding=ioargs.encoding, errors=errors, newline="", ) handles.append(handle) # only marked as wrapped when the caller provided a handle is_wrapped = not (isinstance(ioargs.filepath_or_buffer, str) or ioargs.should_close) if "r" in ioargs.mode and not hasattr(handle, "read"): raise TypeError("Expected file path name or file-like object, " f"got {type(ioargs.filepath_or_buffer)} type") handles.reverse() # close the most recently added buffer first if ioargs.should_close: assert not isinstance(ioargs.filepath_or_buffer, str) handles.append(ioargs.filepath_or_buffer) assert not isinstance(handle, str) return IOHandles( handle=handle, created_handles=handles, is_wrapped=is_wrapped, is_mmap=memory_map, compression=ioargs.compression, )
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.action_goal is None: self.action_goal = raspimouse_ros.msg.MusicActionGoal() if self.action_result is None: self.action_result = raspimouse_ros.msg.MusicActionResult() if self.action_feedback is None: self.action_feedback = raspimouse_ros.msg.MusicActionFeedback() end = 0 _x = self start = end end += 12 (_x.action_goal.header.seq, _x.action_goal.header.stamp.secs, _x.action_goal.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_goal.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.action_goal.header.frame_id = str[start:end] _x = self start = end end += 8 (_x.action_goal.goal_id.stamp.secs, _x.action_goal.goal_id.stamp.nsecs,) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_goal.goal_id.id = str[start:end].decode('utf-8', 'rosmsg') else: self.action_goal.goal_id.id = str[start:end] start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) pattern = '<%sH'%length start = end s = struct.Struct(pattern) end += s.size self.action_goal.goal.freqs = numpy.frombuffer(str[start:end], dtype=numpy.uint16, count=length) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) pattern = '<%sf'%length start = end s = struct.Struct(pattern) end += s.size self.action_goal.goal.durations = numpy.frombuffer(str[start:end], dtype=numpy.float32, count=length) _x = self start = end end += 12 (_x.action_result.header.seq, _x.action_result.header.stamp.secs, _x.action_result.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_result.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.action_result.header.frame_id = str[start:end] _x = self start = end end += 8 (_x.action_result.status.goal_id.stamp.secs, _x.action_result.status.goal_id.stamp.nsecs,) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_result.status.goal_id.id = str[start:end].decode('utf-8', 'rosmsg') else: self.action_result.status.goal_id.id = str[start:end] start = end end += 1 (self.action_result.status.status,) = _get_struct_B().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_result.status.text = str[start:end].decode('utf-8', 'rosmsg') else: self.action_result.status.text = str[start:end] _x = self start = end end += 13 (_x.action_result.result.finished, _x.action_feedback.header.seq, _x.action_feedback.header.stamp.secs, _x.action_feedback.header.stamp.nsecs,) = _get_struct_B3I().unpack(str[start:end]) self.action_result.result.finished = bool(self.action_result.result.finished) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_feedback.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.action_feedback.header.frame_id = str[start:end] _x = self start = end end += 8 (_x.action_feedback.status.goal_id.stamp.secs, _x.action_feedback.status.goal_id.stamp.nsecs,) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_feedback.status.goal_id.id = str[start:end].decode('utf-8', 'rosmsg') else: self.action_feedback.status.goal_id.id = str[start:end] start = end end += 1 (self.action_feedback.status.status,) = _get_struct_B().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_feedback.status.text = str[start:end].decode('utf-8', 'rosmsg') else: self.action_feedback.status.text = str[start:end] start = end end += 4 (self.action_feedback.feedback.remaining_steps,) = _get_struct_I().unpack(str[start:end]) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.models is None: self.models = None if self.pose is None: self.pose = geometry_msgs.msg.Pose() end = 0 start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) self.models = [] for i in range(0, length): val1 = nist_gear.msg.Model() start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1.type = str[start:end].decode('utf-8', 'rosmsg') else: val1.type = str[start:end] _v10 = val1.pose _v11 = _v10.position _x = _v11 start = end end += 24 ( _x.x, _x.y, _x.z, ) = _get_struct_3d().unpack(str[start:end]) _v12 = _v10.orientation _x = _v12 start = end end += 32 ( _x.x, _x.y, _x.z, _x.w, ) = _get_struct_4d().unpack(str[start:end]) self.models.append(val1) _x = self start = end end += 56 ( _x.pose.position.x, _x.pose.position.y, _x.pose.position.z, _x.pose.orientation.x, _x.pose.orientation.y, _x.pose.orientation.z, _x.pose.orientation.w, ) = _get_struct_7d().unpack(str[start:end]) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize(self, str): """ unpack serialized message in str into this message instance :param str: byte array of serialized message, ``str`` """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.header is None: self.header = std_msgs.msg.Header() if self.agent_states is None: self.agent_states = None end = 0 _x = self start = end end += 12 (_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.header.frame_id = str[start:end] start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) self.agent_states = [] for i in range(0, length): val1 = pedsim_msgs.msg.AgentState() _v17 = val1.header start = end end += 4 (_v17.seq,) = _get_struct_I().unpack(str[start:end]) _v18 = _v17.stamp _x = _v18 start = end end += 8 (_x.secs, _x.nsecs,) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: _v17.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: _v17.frame_id = str[start:end] _x = val1 start = end end += 10 (_x.id, _x.type,) = _get_struct_QH().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1.social_state = str[start:end].decode('utf-8', 'rosmsg') else: val1.social_state = str[start:end] _v19 = val1.pose _v20 = _v19.position _x = _v20 start = end end += 24 (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end]) _v21 = _v19.orientation _x = _v21 start = end end += 32 (_x.x, _x.y, _x.z, _x.w,) = _get_struct_4d().unpack(str[start:end]) _v22 = val1.twist _v23 = _v22.linear _x = _v23 start = end end += 24 (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end]) _v24 = _v22.angular _x = _v24 start = end end += 24 (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end]) _v25 = val1.forces _v26 = _v25.desired_force _x = _v26 start = end end += 24 (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end]) _v27 = _v25.obstacle_force _x = _v27 start = end end += 24 (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end]) _v28 = _v25.social_force _x = _v28 start = end end += 24 (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end]) _v29 = _v25.group_coherence_force _x = _v29 start = end end += 24 (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end]) _v30 = _v25.group_gaze_force _x = _v30 start = end end += 24 (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end]) _v31 = _v25.group_repulsion_force _x = _v31 start = end end += 24 (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end]) _v32 = _v25.random_force _x = _v32 start = end end += 24 (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end]) self.agent_states.append(val1) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.header is None: self.header = std_msgs.msg.Header() if self.status is None: self.status = actionlib_msgs.msg.GoalStatus() if self.feedback is None: self.feedback = movo_arc_lib.msg.single_task_move_safeFeedback( ) end = 0 _x = self start = end end += 12 ( _x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs, ) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.header.frame_id = str[start:end] _x = self start = end end += 8 ( _x.status.goal_id.stamp.secs, _x.status.goal_id.stamp.nsecs, ) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.status.goal_id.id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.status.goal_id.id = str[start:end] start = end end += 1 (self.status.status, ) = _get_struct_B().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.status.text = str[start:end].decode('utf-8', 'rosmsg') else: self.status.text = str[start:end] start = end end += 1 (self.feedback.NotImplemented, ) = _get_struct_B().unpack( str[start:end]) self.feedback.NotImplemented = bool(self.feedback.NotImplemented) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.header is None: self.header = imc_ros_msgs.msg.Header() if self.state is None: self.state = std_msgs.msg.UInt8() if self.plan_id is None: self.plan_id = std_msgs.msg.String() if self.plan_eta is None: self.plan_eta = std_msgs.msg.Int32() if self.plan_progress is None: self.plan_progress = std_msgs.msg.Float32() if self.man_id is None: self.man_id = std_msgs.msg.String() if self.man_type is None: self.man_type = std_msgs.msg.UInt16() if self.man_eta is None: self.man_eta = std_msgs.msg.Int32() if self.last_outcome is None: self.last_outcome = std_msgs.msg.UInt8() end = 0 _x = self start = end end += 12 ( _x.header.rosheader.seq, _x.header.rosheader.stamp.secs, _x.header.rosheader.stamp.nsecs, ) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.header.rosheader.frame_id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.header.rosheader.frame_id = str[start:end] _x = self start = end end += 21 ( _x.header.sync.data, _x.header.mgid.data, _x.header.size.data, _x.header.timestamp.data, _x.header.src.data, _x.header.src_ent.data, _x.header.dst.data, _x.header.dst_ent.data, _x.state.data, ) = _get_struct_3HdHBH2B().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.plan_id.data = str[start:end].decode('utf-8', 'rosmsg') else: self.plan_id.data = str[start:end] _x = self start = end end += 8 ( _x.plan_eta.data, _x.plan_progress.data, ) = _get_struct_if().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.man_id.data = str[start:end].decode('utf-8', 'rosmsg') else: self.man_id.data = str[start:end] _x = self start = end end += 7 ( _x.man_type.data, _x.man_eta.data, _x.last_outcome.data, ) = _get_struct_HiB().unpack(str[start:end]) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.action_goal is None: self.action_goal = part_fetcher.msg.PartFetcherActionGoal() if self.action_result is None: self.action_result = part_fetcher.msg.PartFetcherActionResult() if self.action_feedback is None: self.action_feedback = part_fetcher.msg.PartFetcherActionFeedback() end = 0 _x = self start = end end += 12 (_x.action_goal.header.seq, _x.action_goal.header.stamp.secs, _x.action_goal.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_goal.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.action_goal.header.frame_id = str[start:end] _x = self start = end end += 8 (_x.action_goal.goal_id.stamp.secs, _x.action_goal.goal_id.stamp.nsecs,) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_goal.goal_id.id = str[start:end].decode('utf-8', 'rosmsg') else: self.action_goal.goal_id.id = str[start:end] _x = self start = end end += 16 (_x.action_goal.goal.object_id, _x.action_goal.goal.object_frame.header.seq, _x.action_goal.goal.object_frame.header.stamp.secs, _x.action_goal.goal.object_frame.header.stamp.nsecs,) = _get_struct_i3I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_goal.goal.object_frame.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.action_goal.goal.object_frame.header.frame_id = str[start:end] _x = self start = end end += 68 (_x.action_goal.goal.object_frame.pose.position.x, _x.action_goal.goal.object_frame.pose.position.y, _x.action_goal.goal.object_frame.pose.position.z, _x.action_goal.goal.object_frame.pose.orientation.x, _x.action_goal.goal.object_frame.pose.orientation.y, _x.action_goal.goal.object_frame.pose.orientation.z, _x.action_goal.goal.object_frame.pose.orientation.w, _x.action_goal.goal.desired_frame.header.seq, _x.action_goal.goal.desired_frame.header.stamp.secs, _x.action_goal.goal.desired_frame.header.stamp.nsecs,) = _get_struct_7d3I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_goal.goal.desired_frame.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.action_goal.goal.desired_frame.header.frame_id = str[start:end] _x = self start = end end += 68 (_x.action_goal.goal.desired_frame.pose.position.x, _x.action_goal.goal.desired_frame.pose.position.y, _x.action_goal.goal.desired_frame.pose.position.z, _x.action_goal.goal.desired_frame.pose.orientation.x, _x.action_goal.goal.desired_frame.pose.orientation.y, _x.action_goal.goal.desired_frame.pose.orientation.z, _x.action_goal.goal.desired_frame.pose.orientation.w, _x.action_result.header.seq, _x.action_result.header.stamp.secs, _x.action_result.header.stamp.nsecs,) = _get_struct_7d3I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_result.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.action_result.header.frame_id = str[start:end] _x = self start = end end += 8 (_x.action_result.status.goal_id.stamp.secs, _x.action_result.status.goal_id.stamp.nsecs,) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_result.status.goal_id.id = str[start:end].decode('utf-8', 'rosmsg') else: self.action_result.status.goal_id.id = str[start:end] start = end end += 1 (self.action_result.status.status,) = _get_struct_B().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_result.status.text = str[start:end].decode('utf-8', 'rosmsg') else: self.action_result.status.text = str[start:end] _x = self start = end end += 16 (_x.action_result.result.rtn_code, _x.action_feedback.header.seq, _x.action_feedback.header.stamp.secs, _x.action_feedback.header.stamp.nsecs,) = _get_struct_i3I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_feedback.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.action_feedback.header.frame_id = str[start:end] _x = self start = end end += 8 (_x.action_feedback.status.goal_id.stamp.secs, _x.action_feedback.status.goal_id.stamp.nsecs,) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_feedback.status.goal_id.id = str[start:end].decode('utf-8', 'rosmsg') else: self.action_feedback.status.goal_id.id = str[start:end] start = end end += 1 (self.action_feedback.status.status,) = _get_struct_B().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_feedback.status.text = str[start:end].decode('utf-8', 'rosmsg') else: self.action_feedback.status.text = str[start:end] start = end end += 4 (self.action_feedback.feedback.fdbk,) = _get_struct_i().unpack(str[start:end]) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.publisher is None: self.publisher = None if self.subscriber is None: self.subscriber = None if self.services is None: self.services = None end = 0 start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.masteruri = str[start:end].decode('utf-8', 'rosmsg') else: self.masteruri = str[start:end] start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) self.nodes = [] for i in range(0, length): start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1 = str[start:end].decode('utf-8', 'rosmsg') else: val1 = str[start:end] self.nodes.append(val1) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) self.publisher = [] for i in range(0, length): val1 = fkie_multimaster_msgs.msg.SyncTopicInfo() start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1.topic = str[start:end].decode('utf-8', 'rosmsg') else: val1.topic = str[start:end] start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1.node = str[start:end].decode('utf-8', 'rosmsg') else: val1.node = str[start:end] start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1.nodeuri = str[start:end].decode('utf-8', 'rosmsg') else: val1.nodeuri = str[start:end] self.publisher.append(val1) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) self.subscriber = [] for i in range(0, length): val1 = fkie_multimaster_msgs.msg.SyncTopicInfo() start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1.topic = str[start:end].decode('utf-8', 'rosmsg') else: val1.topic = str[start:end] start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1.node = str[start:end].decode('utf-8', 'rosmsg') else: val1.node = str[start:end] start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1.nodeuri = str[start:end].decode('utf-8', 'rosmsg') else: val1.nodeuri = str[start:end] self.subscriber.append(val1) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) self.services = [] for i in range(0, length): val1 = fkie_multimaster_msgs.msg.SyncServiceInfo() start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1.service = str[start:end].decode('utf-8', 'rosmsg') else: val1.service = str[start:end] start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1.serviceuri = str[start:end].decode('utf-8', 'rosmsg') else: val1.serviceuri = str[start:end] start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1.node = str[start:end].decode('utf-8', 'rosmsg') else: val1.node = str[start:end] start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1.nodeuri = str[start:end].decode('utf-8', 'rosmsg') else: val1.nodeuri = str[start:end] self.services.append(val1) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.action_goal is None: self.action_goal = pal_interaction_msgs.msg.ASRFileActionGoal() if self.action_result is None: self.action_result = pal_interaction_msgs.msg.ASRFileActionResult( ) if self.action_feedback is None: self.action_feedback = pal_interaction_msgs.msg.ASRFileActionFeedback( ) end = 0 _x = self start = end end += 12 ( _x.action_goal.header.seq, _x.action_goal.header.stamp.secs, _x.action_goal.header.stamp.nsecs, ) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_goal.header.frame_id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_goal.header.frame_id = str[start:end] _x = self start = end end += 8 ( _x.action_goal.goal_id.stamp.secs, _x.action_goal.goal_id.stamp.nsecs, ) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_goal.goal_id.id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_goal.goal_id.id = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_goal.goal.file = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_goal.goal.file = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_goal.goal.lang_id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_goal.goal.lang_id = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_goal.goal.grammar = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_goal.goal.grammar = str[start:end] _x = self start = end end += 12 ( _x.action_result.header.seq, _x.action_result.header.stamp.secs, _x.action_result.header.stamp.nsecs, ) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_result.header.frame_id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_result.header.frame_id = str[start:end] _x = self start = end end += 8 ( _x.action_result.status.goal_id.stamp.secs, _x.action_result.status.goal_id.stamp.nsecs, ) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_result.status.goal_id.id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_result.status.goal_id.id = str[start:end] start = end end += 1 (self.action_result.status.status, ) = _get_struct_B().unpack( str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_result.status.text = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_result.status.text = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_result.result.file = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_result.result.file = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_result.result.msg = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_result.result.msg = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) self.action_result.result.recognised_utterances = [] for i in range(0, length): val1 = pal_interaction_msgs.msg.asrresult() start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1.text = str[start:end].decode('utf-8', 'rosmsg') else: val1.text = str[start:end] start = end end += 1 (val1.confidence, ) = _get_struct_b().unpack(str[start:end]) _v7 = val1.start _x = _v7 start = end end += 8 ( _x.secs, _x.nsecs, ) = _get_struct_2I().unpack(str[start:end]) _v8 = val1.end _x = _v8 start = end end += 8 ( _x.secs, _x.nsecs, ) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) val1.tags = [] for i in range(0, length): val2 = pal_interaction_msgs.msg.actiontag() start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val2.key = str[start:end].decode('utf-8', 'rosmsg') else: val2.key = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val2.value = str[start:end].decode('utf-8', 'rosmsg') else: val2.value = str[start:end] val1.tags.append(val2) self.action_result.result.recognised_utterances.append(val1) _x = self start = end end += 12 ( _x.action_feedback.header.seq, _x.action_feedback.header.stamp.secs, _x.action_feedback.header.stamp.nsecs, ) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_feedback.header.frame_id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_feedback.header.frame_id = str[start:end] _x = self start = end end += 8 ( _x.action_feedback.status.goal_id.stamp.secs, _x.action_feedback.status.goal_id.stamp.nsecs, ) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_feedback.status.goal_id.id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_feedback.status.goal_id.id = str[start:end] start = end end += 1 (self.action_feedback.status.status, ) = _get_struct_B().unpack( str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_feedback.status.text = str[start:end].decode( 'utf-8', 'rosmsg') else: self.action_feedback.status.text = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_feedback.feedback.recognised_utterance.text = str[ start:end].decode('utf-8', 'rosmsg') else: self.action_feedback.feedback.recognised_utterance.text = str[ start:end] _x = self start = end end += 17 ( _x.action_feedback.feedback.recognised_utterance.confidence, _x.action_feedback.feedback.recognised_utterance.start.secs, _x.action_feedback.feedback.recognised_utterance.start.nsecs, _x.action_feedback.feedback.recognised_utterance.end.secs, _x.action_feedback.feedback.recognised_utterance.end.nsecs, ) = _get_struct_b4I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) self.action_feedback.feedback.recognised_utterance.tags = [] for i in range(0, length): val1 = pal_interaction_msgs.msg.actiontag() start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1.key = str[start:end].decode('utf-8', 'rosmsg') else: val1.key = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1.value = str[start:end].decode('utf-8', 'rosmsg') else: val1.value = str[start:end] self.action_feedback.feedback.recognised_utterance.tags.append( val1) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.action_goal is None: self.action_goal = pkg_ros_iot_bridge.msg.msgRosIotActionGoal() if self.action_result is None: self.action_result = pkg_ros_iot_bridge.msg.msgRosIotActionResult() if self.action_feedback is None: self.action_feedback = pkg_ros_iot_bridge.msg.msgRosIotActionFeedback() end = 0 _x = self start = end end += 12 (_x.action_goal.header.seq, _x.action_goal.header.stamp.secs, _x.action_goal.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_goal.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.action_goal.header.frame_id = str[start:end] _x = self start = end end += 8 (_x.action_goal.goal_id.stamp.secs, _x.action_goal.goal_id.stamp.nsecs,) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_goal.goal_id.id = str[start:end].decode('utf-8', 'rosmsg') else: self.action_goal.goal_id.id = str[start:end] _x = self start = end end += 14 (_x.action_goal.goal.distance, _x.action_goal.goal.angle, _x.action_result.header.seq, _x.action_result.header.stamp.secs, _x.action_result.header.stamp.nsecs,) = _get_struct_2b3I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_result.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.action_result.header.frame_id = str[start:end] _x = self start = end end += 8 (_x.action_result.status.goal_id.stamp.secs, _x.action_result.status.goal_id.stamp.nsecs,) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_result.status.goal_id.id = str[start:end].decode('utf-8', 'rosmsg') else: self.action_result.status.goal_id.id = str[start:end] start = end end += 1 (self.action_result.status.status,) = _get_struct_B().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_result.status.text = str[start:end].decode('utf-8', 'rosmsg') else: self.action_result.status.text = str[start:end] _x = self start = end end += 15 (_x.action_result.result.final_x, _x.action_result.result.final_y, _x.action_result.result.final_theta, _x.action_feedback.header.seq, _x.action_feedback.header.stamp.secs, _x.action_feedback.header.stamp.nsecs,) = _get_struct_3b3I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_feedback.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.action_feedback.header.frame_id = str[start:end] _x = self start = end end += 8 (_x.action_feedback.status.goal_id.stamp.secs, _x.action_feedback.status.goal_id.stamp.nsecs,) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_feedback.status.goal_id.id = str[start:end].decode('utf-8', 'rosmsg') else: self.action_feedback.status.goal_id.id = str[start:end] start = end end += 1 (self.action_feedback.status.status,) = _get_struct_B().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.action_feedback.status.text = str[start:end].decode('utf-8', 'rosmsg') else: self.action_feedback.status.text = str[start:end] _x = self start = end end += 3 (_x.action_feedback.feedback.cur_x, _x.action_feedback.feedback.cur_y, _x.action_feedback.feedback.cur_theta,) = _get_struct_3b().unpack(str[start:end]) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.header is None: self.header = std_msgs.msg.Header() if self.direction is None: self.direction = geometry_msgs.msg.Vector3() if self.normal is None: self.normal = geometry_msgs.msg.Vector3() if self.palmpos is None: self.palmpos = geometry_msgs.msg.Point() if self.ypr is None: self.ypr = geometry_msgs.msg.Vector3() if self.thumb_metacarpal is None: self.thumb_metacarpal = geometry_msgs.msg.Point() if self.thumb_proximal is None: self.thumb_proximal = geometry_msgs.msg.Point() if self.thumb_intermediate is None: self.thumb_intermediate = geometry_msgs.msg.Point() if self.thumb_distal is None: self.thumb_distal = geometry_msgs.msg.Point() if self.thumb_tip is None: self.thumb_tip = geometry_msgs.msg.Point() if self.index_metacarpal is None: self.index_metacarpal = geometry_msgs.msg.Point() if self.index_proximal is None: self.index_proximal = geometry_msgs.msg.Point() if self.index_intermediate is None: self.index_intermediate = geometry_msgs.msg.Point() if self.index_distal is None: self.index_distal = geometry_msgs.msg.Point() if self.index_tip is None: self.index_tip = geometry_msgs.msg.Point() if self.middle_metacarpal is None: self.middle_metacarpal = geometry_msgs.msg.Point() if self.middle_proximal is None: self.middle_proximal = geometry_msgs.msg.Point() if self.middle_intermediate is None: self.middle_intermediate = geometry_msgs.msg.Point() if self.middle_distal is None: self.middle_distal = geometry_msgs.msg.Point() if self.middle_tip is None: self.middle_tip = geometry_msgs.msg.Point() if self.ring_metacarpal is None: self.ring_metacarpal = geometry_msgs.msg.Point() if self.ring_proximal is None: self.ring_proximal = geometry_msgs.msg.Point() if self.ring_intermediate is None: self.ring_intermediate = geometry_msgs.msg.Point() if self.ring_distal is None: self.ring_distal = geometry_msgs.msg.Point() if self.ring_tip is None: self.ring_tip = geometry_msgs.msg.Point() if self.pinky_metacarpal is None: self.pinky_metacarpal = geometry_msgs.msg.Point() if self.pinky_proximal is None: self.pinky_proximal = geometry_msgs.msg.Point() if self.pinky_intermediate is None: self.pinky_intermediate = geometry_msgs.msg.Point() if self.pinky_distal is None: self.pinky_distal = geometry_msgs.msg.Point() if self.pinky_tip is None: self.pinky_tip = geometry_msgs.msg.Point() end = 0 _x = self start = end end += 12 (_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.header.frame_id = str[start:end] _x = self start = end end += 696 (_x.direction.x, _x.direction.y, _x.direction.z, _x.normal.x, _x.normal.y, _x.normal.z, _x.palmpos.x, _x.palmpos.y, _x.palmpos.z, _x.ypr.x, _x.ypr.y, _x.ypr.z, _x.thumb_metacarpal.x, _x.thumb_metacarpal.y, _x.thumb_metacarpal.z, _x.thumb_proximal.x, _x.thumb_proximal.y, _x.thumb_proximal.z, _x.thumb_intermediate.x, _x.thumb_intermediate.y, _x.thumb_intermediate.z, _x.thumb_distal.x, _x.thumb_distal.y, _x.thumb_distal.z, _x.thumb_tip.x, _x.thumb_tip.y, _x.thumb_tip.z, _x.index_metacarpal.x, _x.index_metacarpal.y, _x.index_metacarpal.z, _x.index_proximal.x, _x.index_proximal.y, _x.index_proximal.z, _x.index_intermediate.x, _x.index_intermediate.y, _x.index_intermediate.z, _x.index_distal.x, _x.index_distal.y, _x.index_distal.z, _x.index_tip.x, _x.index_tip.y, _x.index_tip.z, _x.middle_metacarpal.x, _x.middle_metacarpal.y, _x.middle_metacarpal.z, _x.middle_proximal.x, _x.middle_proximal.y, _x.middle_proximal.z, _x.middle_intermediate.x, _x.middle_intermediate.y, _x.middle_intermediate.z, _x.middle_distal.x, _x.middle_distal.y, _x.middle_distal.z, _x.middle_tip.x, _x.middle_tip.y, _x.middle_tip.z, _x.ring_metacarpal.x, _x.ring_metacarpal.y, _x.ring_metacarpal.z, _x.ring_proximal.x, _x.ring_proximal.y, _x.ring_proximal.z, _x.ring_intermediate.x, _x.ring_intermediate.y, _x.ring_intermediate.z, _x.ring_distal.x, _x.ring_distal.y, _x.ring_distal.z, _x.ring_tip.x, _x.ring_tip.y, _x.ring_tip.z, _x.pinky_metacarpal.x, _x.pinky_metacarpal.y, _x.pinky_metacarpal.z, _x.pinky_proximal.x, _x.pinky_proximal.y, _x.pinky_proximal.z, _x.pinky_intermediate.x, _x.pinky_intermediate.y, _x.pinky_intermediate.z, _x.pinky_distal.x, _x.pinky_distal.y, _x.pinky_distal.z, _x.pinky_tip.x, _x.pinky_tip.y, _x.pinky_tip.z,) = _get_struct_87d().unpack(str[start:end]) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.header is None: self.header = std_msgs.msg.Header() if self.heaviest_processes is None: self.heaviest_processes = None end = 0 _x = self start = end end += 12 ( _x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs, ) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.header.frame_id = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) pattern = '<%sf' % length start = end s = struct.Struct(pattern) end += s.size self.cpu_percent = numpy.frombuffer(str[start:end], dtype=numpy.float32, count=length) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) self.heaviest_processes = [] for i in range(0, length): val1 = mav_system_msgs.msg.ProcessInfo() start = end end += 4 (val1.pid, ) = _get_struct_I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1.name = str[start:end].decode('utf-8', 'rosmsg') else: val1.name = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1.username = str[start:end].decode('utf-8', 'rosmsg') else: val1.username = str[start:end] start = end end += 4 (val1.cpu_percent, ) = _get_struct_f().unpack(str[start:end]) self.heaviest_processes.append(val1) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize(self, str): """ unpack serialized message in str into this message instance :param str: byte array of serialized message, ``str`` """ if python3: codecs.lookup_error("rosmsg").msg_type = self._type try: if self.lanes is None: self.lanes = None end = 0 start = end end += 4 (self.id,) = _get_struct_i().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) self.lanes = [] for i in range(0, length): val1 = subscriber.msg.Lane() _v17 = val1.header start = end end += 4 (_v17.seq,) = _get_struct_I().unpack(str[start:end]) _v18 = _v17.stamp _x = _v18 start = end end += 8 (_x.secs, _x.nsecs,) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: _v17.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: _v17.frame_id = str[start:end] _x = val1 start = end end += 8 (_x.increment, _x.lane_id,) = _get_struct_2i().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) val1.waypoints = [] for i in range(0, length): val2 = subscriber.msg.Waypoint() _x = val2 start = end end += 8 (_x.gid, _x.lid,) = _get_struct_2i().unpack(str[start:end]) _v19 = val2.pose _v20 = _v19.header start = end end += 4 (_v20.seq,) = _get_struct_I().unpack(str[start:end]) _v21 = _v20.stamp _x = _v21 start = end end += 8 (_x.secs, _x.nsecs,) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: _v20.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: _v20.frame_id = str[start:end] _v22 = _v19.pose _v23 = _v22.position _x = _v23 start = end end += 24 (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end]) _v24 = _v22.orientation _x = _v24 start = end end += 32 (_x.x, _x.y, _x.z, _x.w,) = _get_struct_4d().unpack(str[start:end]) _v25 = val2.twist _v26 = _v25.header start = end end += 4 (_v26.seq,) = _get_struct_I().unpack(str[start:end]) _v27 = _v26.stamp _x = _v27 start = end end += 8 (_x.secs, _x.nsecs,) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: _v26.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: _v26.frame_id = str[start:end] _v28 = _v25.twist _v29 = _v28.linear _x = _v29 start = end end += 24 (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end]) _v30 = _v28.angular _x = _v30 start = end end += 24 (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end]) _v31 = val2.dtlane _x = _v31 start = end end += 64 (_x.dist, _x.dir, _x.apara, _x.r, _x.slope, _x.cant, _x.lw, _x.rw,) = _get_struct_8d().unpack(str[start:end]) start = end end += 4 (val2.change_flag,) = _get_struct_i().unpack(str[start:end]) _v32 = val2.wpstate _x = _v32 start = end end += 9 (_x.aid, _x.lanechange_state, _x.steering_state, _x.accel_state, _x.stop_state, _x.event_state,) = _get_struct_i5B().unpack(str[start:end]) _x = val2 start = end end += 28 (_x.lane_id, _x.left_lane_id, _x.right_lane_id, _x.stop_line_id, _x.cost, _x.time_cost, _x.direction,) = _get_struct_4I2fI().unpack(str[start:end]) val1.waypoints.append(val2) _x = val1 start = end end += 17 (_x.lane_index, _x.cost, _x.closest_object_distance, _x.closest_object_velocity, _x.is_blocked,) = _get_struct_I3fB().unpack(str[start:end]) val1.is_blocked = bool(val1.is_blocked) self.lanes.append(val1) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.header is None: self.header = std_msgs.msg.Header() if self.status is None: self.status = actionlib_msgs.msg.GoalStatus() if self.result is None: self.result = my_robot_tutorial.msg.Navigate2DResult() end = 0 _x = self start = end end += 12 ( _x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs, ) = _get_struct_3I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.header.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: self.header.frame_id = str[start:end] _x = self start = end end += 8 ( _x.status.goal_id.stamp.secs, _x.status.goal_id.stamp.nsecs, ) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.status.goal_id.id = str[start:end].decode( 'utf-8', 'rosmsg') else: self.status.goal_id.id = str[start:end] start = end end += 1 (self.status.status, ) = _get_struct_B().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.status.text = str[start:end].decode('utf-8', 'rosmsg') else: self.status.text = str[start:end] start = end end += 4 (self.result.elapsed_time, ) = _get_struct_f().unpack( str[start:end]) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ if python3: codecs.lookup_error("rosmsg").msg_type = self._type try: if self.lanes is None: self.lanes = None end = 0 start = end end += 4 (self.id,) = _get_struct_i().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) self.lanes = [] for i in range(0, length): val1 = subscriber.msg.Lane() _v49 = val1.header start = end end += 4 (_v49.seq,) = _get_struct_I().unpack(str[start:end]) _v50 = _v49.stamp _x = _v50 start = end end += 8 (_x.secs, _x.nsecs,) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: _v49.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: _v49.frame_id = str[start:end] _x = val1 start = end end += 8 (_x.increment, _x.lane_id,) = _get_struct_2i().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) val1.waypoints = [] for i in range(0, length): val2 = subscriber.msg.Waypoint() _x = val2 start = end end += 8 (_x.gid, _x.lid,) = _get_struct_2i().unpack(str[start:end]) _v51 = val2.pose _v52 = _v51.header start = end end += 4 (_v52.seq,) = _get_struct_I().unpack(str[start:end]) _v53 = _v52.stamp _x = _v53 start = end end += 8 (_x.secs, _x.nsecs,) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: _v52.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: _v52.frame_id = str[start:end] _v54 = _v51.pose _v55 = _v54.position _x = _v55 start = end end += 24 (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end]) _v56 = _v54.orientation _x = _v56 start = end end += 32 (_x.x, _x.y, _x.z, _x.w,) = _get_struct_4d().unpack(str[start:end]) _v57 = val2.twist _v58 = _v57.header start = end end += 4 (_v58.seq,) = _get_struct_I().unpack(str[start:end]) _v59 = _v58.stamp _x = _v59 start = end end += 8 (_x.secs, _x.nsecs,) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length,) = _struct_I.unpack(str[start:end]) start = end end += length if python3: _v58.frame_id = str[start:end].decode('utf-8', 'rosmsg') else: _v58.frame_id = str[start:end] _v60 = _v57.twist _v61 = _v60.linear _x = _v61 start = end end += 24 (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end]) _v62 = _v60.angular _x = _v62 start = end end += 24 (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end]) _v63 = val2.dtlane _x = _v63 start = end end += 64 (_x.dist, _x.dir, _x.apara, _x.r, _x.slope, _x.cant, _x.lw, _x.rw,) = _get_struct_8d().unpack(str[start:end]) start = end end += 4 (val2.change_flag,) = _get_struct_i().unpack(str[start:end]) _v64 = val2.wpstate _x = _v64 start = end end += 9 (_x.aid, _x.lanechange_state, _x.steering_state, _x.accel_state, _x.stop_state, _x.event_state,) = _get_struct_i5B().unpack(str[start:end]) _x = val2 start = end end += 28 (_x.lane_id, _x.left_lane_id, _x.right_lane_id, _x.stop_line_id, _x.cost, _x.time_cost, _x.direction,) = _get_struct_4I2fI().unpack(str[start:end]) val1.waypoints.append(val2) _x = val1 start = end end += 17 (_x.lane_index, _x.cost, _x.closest_object_distance, _x.closest_object_velocity, _x.is_blocked,) = _get_struct_I3fB().unpack(str[start:end]) val1.is_blocked = bool(val1.is_blocked) self.lanes.append(val1) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def deserialize_numpy(self, str, numpy): """ unpack serialized message in str into this message instance using numpy for array types :param str: byte array of serialized message, ``str`` :param numpy: numpy python module """ codecs.lookup_error("rosmsg").msg_type = self._type try: if self.poisonStamp is None: self.poisonStamp = brics_actuator.msg.Poison() if self.torques is None: self.torques = None end = 0 start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.poisonStamp.originator = str[start:end].decode( 'utf-8', 'rosmsg') else: self.poisonStamp.originator = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: self.poisonStamp.description = str[start:end].decode( 'utf-8', 'rosmsg') else: self.poisonStamp.description = str[start:end] start = end end += 4 (self.poisonStamp.qos, ) = _get_struct_f().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) self.torques = [] for i in range(0, length): val1 = brics_actuator.msg.JointValue() _v4 = val1.timeStamp _x = _v4 start = end end += 8 ( _x.secs, _x.nsecs, ) = _get_struct_2I().unpack(str[start:end]) start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1.joint_uri = str[start:end].decode('utf-8', 'rosmsg') else: val1.joint_uri = str[start:end] start = end end += 4 (length, ) = _struct_I.unpack(str[start:end]) start = end end += length if python3: val1.unit = str[start:end].decode('utf-8', 'rosmsg') else: val1.unit = str[start:end] start = end end += 8 (val1.value, ) = _get_struct_d().unpack(str[start:end]) self.torques.append(val1) return self except struct.error as e: raise genpy.DeserializationError(e) # most likely buffer underfill
def test_badandgoodsurrogatepassexceptions(self): surrogatepass_errors = codecs.lookup_error('surrogatepass') # "surrogatepass" complains about a non-exception passed in self.assertRaises( TypeError, surrogatepass_errors, 42 ) # "surrogatepass" complains about the wrong exception types self.assertRaises( TypeError, surrogatepass_errors, UnicodeError("ouch") ) # "surrogatepass" can not be used for translating self.assertRaises( TypeError, surrogatepass_errors, UnicodeTranslateError("\ud800", 0, 1, "ouch") ) # Use the correct exception for enc in ("utf-8", "utf-16le", "utf-16be", "utf-32le", "utf-32be"): with self.subTest(encoding=enc): self.assertRaises( UnicodeEncodeError, surrogatepass_errors, UnicodeEncodeError(enc, "a", 0, 1, "ouch") ) self.assertRaises( UnicodeDecodeError, surrogatepass_errors, UnicodeDecodeError(enc, "a".encode(enc), 0, 1, "ouch") ) for s in ("\ud800", "\udfff", "\ud800\udfff"): with self.subTest(str=s): self.assertRaises( UnicodeEncodeError, surrogatepass_errors, UnicodeEncodeError("ascii", s, 0, len(s), "ouch") ) tests = [ ("utf-8", "\ud800", b'\xed\xa0\x80', 3), ("utf-16le", "\ud800", b'\x00\xd8', 2), ("utf-16be", "\ud800", b'\xd8\x00', 2), ("utf-32le", "\ud800", b'\x00\xd8\x00\x00', 4), ("utf-32be", "\ud800", b'\x00\x00\xd8\x00', 4), ("utf-8", "\udfff", b'\xed\xbf\xbf', 3), ("utf-16le", "\udfff", b'\xff\xdf', 2), ("utf-16be", "\udfff", b'\xdf\xff', 2), ("utf-32le", "\udfff", b'\xff\xdf\x00\x00', 4), ("utf-32be", "\udfff", b'\x00\x00\xdf\xff', 4), ("utf-8", "\ud800\udfff", b'\xed\xa0\x80\xed\xbf\xbf', 3), ("utf-16le", "\ud800\udfff", b'\x00\xd8\xff\xdf', 2), ("utf-16be", "\ud800\udfff", b'\xd8\x00\xdf\xff', 2), ("utf-32le", "\ud800\udfff", b'\x00\xd8\x00\x00\xff\xdf\x00\x00', 4), ("utf-32be", "\ud800\udfff", b'\x00\x00\xd8\x00\x00\x00\xdf\xff', 4), ] for enc, s, b, n in tests: with self.subTest(encoding=enc, str=s, bytes=b): self.assertEqual( surrogatepass_errors( UnicodeEncodeError(enc, "a" + s + "b", 1, 1 + len(s), "ouch")), (b, 1 + len(s)) ) self.assertEqual( surrogatepass_errors( UnicodeDecodeError(enc, bytearray(b"a" + b[:n] + b"b"), 1, 1 + n, "ouch")), (s[:1], 1 + n) )
def get(self, request, *args, **kwargs): # Results can contain a wide array of non-ascii or binary characters, escape them codecs.register_error("strict", codecs.lookup_error("surrogateescape")) result = self.get_object() serializer = serializers.DetailedResultSerializer(result) return Response({"result": serializer.data})