def __init__(self, obj, tag):
if not isinstance(obj, VReference):
if isinstance(obj, VNativeObject):
if obj._v_native_tag() != tag:
raise VTaggedParseError('VNative tag mismatch')
else:
raise VTaggedParseError('Not a VReference or VNativeObject')
VEntity.__init__(self)
self._v_int_native_obj = obj._v_proxy()
self._v_tag = tag
self._v_active = False
def decoder(self, obj):
self.__lock.acquire()
try:
if not isinstance(obj, VTagged):
raise VTaggedParseError('Object must be VTagged')
value, tags = obj.value, obj.tags
if not tags:
raise VTaggedParseUnknown('No tags set on object')
encoding, etags = VEntity._v_lazy_native(tags[0]), tags[1:]
if not isinstance(encoding, (int, long) or encoding < -1):
raise VTaggedParseUnknown()
if encoding == -1:
if len(etags) < 2:
raise VTaggedParseError()
name, version = VEntity._v_lazy_native(etags[:2])
mod_tags = etags[2:]
try:
entry = self.__proxy.decoder_from_name(name, version)
except VModuleError:
raise VTaggedParseUnknown()
try:
return entry.decoder(value, *mod_tags)
except Exception as e:
raise VTaggedParseError(e.args)
oid_enc_type, oid_enc_len = encoding % 10, encoding // 10
if oid_enc_type in (0, 1):
if len(etags) < oid_enc_len:
raise VTaggedParseError()
oid_tags, mod_tags = etags[:oid_enc_len], etags[oid_enc_len:]
oid_tags = VEntity._v_lazy_native(oid_tags)
for t in oid_tags:
if not isinstance(t, (int, long)) or t < 0:
raise VTaggedParseError()
else:
return VTaggedParseUnknown()
if oid_enc_type == 1:
oid_tags = self.VSE_OID_PREFIX + oid_tags
oid = VObjectIdentifier(oid_tags)
try:
entry = self.__proxy.decoder_from_oid(oid)
except VModuleError:
raise VTaggedParseUnknown()
try:
return entry.decoder(value, *mod_tags)
except Exception as e:
raise VTaggedParseError(e.args)
finally:
self.__lock.release()
def _v_vse_decoder(cls, value, *tags):
"""Create object from VSE tag data"""
if tags:
raise VTaggedParseError('Encoding does not use residual tags')
value = VEntity._v_lazy_native(value)
if not isinstance(value, bytes):
raise VTaggedParseError('Encoding value must be bytes data')
_nums = []
_offset = 0
while value:
_num, _b_read = netbytes_to_signedint(value)
if _num is None:
raise VTaggedParseError('Invalid number encoding')
_nums.append(_num)
value = value[_b_read:]
if len(_nums) % 3 != 0:
raise VTaggedParseError('Invalid number encoding')
_vals = []
for i in xrange(len(_nums) // 3):
_digits = _nums[3 * i]
_base = _nums[3 * i + 1]
_exp = _nums[3 * i + 2]
_vals.append(VFloat(_digits, _exp, base=_base))
result = VArrayOfVFloat(_vals)
return (lambda x: x[0], [result])
def __init__(self, dim, data=None, fill=None, lazy=True):
VLockable.__init__(self)
if len(dim) < 1:
raise TypeError('Minimum 1 dimension required')
for d in dim:
if d <= 0:
raise TypeError('Each dimension must be >0')
self._dim = tuple(dim)
mul, m = [], 1
for d in dim:
mul.append(m)
m *= d
_len = m
self.__mul = tuple(mul)
if data is None:
fill = VEntity._v_lazy(fill)
self._data = [fill] * (_len)
else:
if isinstance(data, VTuple):
self._data = list(e for e in data)
else:
if lazy:
_lazy = VEntity._v_lazy
self._data = self._val_type()(_lazy(e) for e in data)
else:
self._data = self._val_type()(iter(data))
for e in self._data:
if not isinstance(e, VEntity):
raise TypeError('Invalid element type')
if len(self._data) != _len:
raise TypeError('Data has incorrect dimensions')
def _v_vse_decoder(cls, value, *tags):
"""Returns decoder for :class:`versile.orb.entity.VTagged`."""
if len(tags) != 2:
raise VTaggedParseError('Encoding requires 2 residual tags')
min_arg, max_arg = tags
min_arg = VEntity._v_lazy_native(min_arg)
max_arg = VEntity._v_lazy_native(max_arg)
for arg in (min_arg, max_arg):
if arg is None:
continue
if isinstance(arg, (int, long)) and arg >= 0:
continue
raise VTaggedParseError('Limit must be non-negative int or None')
if min_arg is not None and max_arg is not None and max_arg < min_arg:
raise VTaggedParseError('Max arguments must be None or > min args')
if isinstance(value, VObject):
value = value._v_proxy()
if not isinstance(value, VProxy):
raise VTaggedParseError('Encoding value must be object reference')
return (lambda x: cls(*x), [value, min_arg, max_arg])
def __getitem__(self, key):
"""Gets a dictionary value.
:param key: dictionary key
:type key: :class:`versile.orb.entity.VEntity` or lazy-convertible
:returns: dictionary value for key
:rtype: :class:`versile.orb.entity.VEntity`
:raises: :exc:`exceptions.KeyError`
"""
with self:
key = VEntity._v_lazy(key)
return self.__value[key]
def _v_obj_from_recv(cls, obj, activate=False):
"""Parses obj, converting VPythonObject to VPythonObject._obj
Also lazy-native converts from VEntity to native representation.
"""
t = type(obj)
if t in (tuple, set, frozenset):
return t(cls._v_obj_from_recv(e) for e in obj)
elif isinstance(obj, VNativeObject):
return obj._obj
elif isinstance(obj, VBasePython) and activate:
obj._v_activate()
return obj
elif isinstance(obj, VBasePythonException) and activate:
obj._v_activate()
obj = VEntity._v_lazy_native(obj)
return obj
else:
try:
return VEntity._v_lazy_native(obj)
except:
return obj
def __init__(self, *args):
if len(args) == 1:
_dt = args[0]
if not isinstance(_dt, datetime):
raise TypeError('Single argument must be datetime object')
try:
_dt = _dt.astimezone(self._utc)
except:
raise ValueError('Datetime must be TZ aware (have time zone)')
_conv = VUTCTime._v_converter(_dt)[1][0]
args = (_conv.days, _conv.secs)
if len(args) == 2:
if _pyver == 2:
_int_types = (int, long)
else:
_int_types = (int, )
days = VEntity._v_lazy_native(args[0])
secs = VEntity._v_lazy_native(args[1])
if not isinstance(days, _int_types):
raise TypeError('Days component must be an int (or long)')
if not isinstance(secs, _int_types):
# Later if such types are implemented, check for other
# structures than VFloat that may be resolved as a number
if not isinstance(secs, (Decimal, float, VFloat)):
raise TypeError('Secs must be integer or floating point')
if not isinstance(secs, VFloat):
# Verify 'secs' is within allowed boundaries
if not (0 <= secs < 86402):
raise ValueError('Secs outside allowed boundaries')
self.__days = days
self.__secs = secs
else:
raise ValueError('Illegal number of arguments')
def _v_vse_decoder(cls, value, *tags):
"""Create object from VSE tag data"""
if tags:
raise VTaggedParseError('Encoding does not use residual tags')
value = VEntity._v_lazy_native(value)
if not isinstance(value, bytes):
raise VTaggedParseError('Encoding value must be bytes data')
if len(value) % 8 != 0:
raise VTaggedParseError('Encoding must be multiple of 8 bytes')
_nums = []
_offset = 0
while _offset < len(value):
_nums.append(struct.unpack_from(b'>d', value, _offset)[0])
_offset += 8
result = VArrayOfDouble(_nums)
return (lambda x: x[0], [result])
def _v_vse_decoder(cls, value, *tags):
"""Create object from VSE tag data"""
if tags:
raise VTaggedParseError('Encoding does not use residual tags')
value = VEntity._v_lazy_native(value)
if not isinstance(value, bytes):
raise VTaggedParseError('Encoding value must be bytes data')
_nums = []
_offset = 0
while value:
_num, _b_read = netbytes_to_signedint(value)
if _num is None:
raise VTaggedParseError('Invalid number encoding')
_nums.append(_num)
value = value[_b_read:]
result = VArrayOfVInteger(_nums)
return (lambda x: x[0], [result])
def _v_convert_for_send(cls, result):
"""Parse 'result' for sending, into VEntity-compliant format."""
try:
return VEntity._v_lazy(result)
except:
if isinstance(result, Exception):
if isinstance(result, VException):
return result
# Try to up-convert local exception types
args = [cls._v_convert_for_send(e) for e in result.args]
name = cls._v_python_exc._CONVERSION.get(type(result), None)
if name:
return cls._v_python_exc(name, *args)
# If this failed, generate a non-standard VPythonException
rcls = result.__class__
e_name = '%s.%s' % (rcls.__module__, rcls.__name__)
return cls._v_python_exc(e_name, *args)
else:
return cls(result)
else:
return result
def _vse_obj_decoder(self, value, *tags):
if len(tags) != 1 or not isinstance(tags[0], VString):
raise VTaggedParseError('Invalid residual tag format')
residual_tag = VEntity._v_lazy_native(tags[0])
self.__lock.acquire()
try:
decoders = self.__handlers.get(residual_tag, None)
finally:
self.__lock.release()
if decoders:
obj_decoder, exc_decoder = decoders
decoded = obj_decoder(value)
else:
decoded = VNative(value, residual_tag)
if self.__activates:
decoded._v_activate()
return (lambda args: decoded, [])
def __setitem__(self, index, value):
"""Sets an element of the array.
:param index: array index
:type index: (int,)
:param value: element value
:type value: :class:`versile.orb.entity.VEntity` or lazy-convertible
:raises: :exc:`exceptions.TypeError`\ ,
:exc:`exceptions.IndexError`
"""
with self:
if len(index) != len(self._dim):
raise IndexError('Index has incorrect length')
for i, d in zip(index, self._dim):
if not 0 <= i < d:
raise IndexError('Index out of range')
if not isinstance(value, VEntity):
value = VEntity._v_lazy(value)
pos = 0
for i, m in zip(index, self.__mul):
pos += i * m
self._data[pos] = value
def _v_vse_decoder(cls, value, *tags):
"""Create object from VSE tag data"""
dim = VEntity._v_lazy_native(tags)
data = value
_assemble = lambda args: cls(dim, data=args)
return (_assemble, list(data))
def __init__(self, dim, data=None, fill=None, lazy=True):
VEntity.__init__(self)
VMultiArray.__init__(self, dim, data, fill, lazy)
def _v_vse_decoder(cls, value, *tags):
"""Create object from VSE tag data"""
if len(tags) != 1:
raise VTaggedParseError('Encoding requires a single residual tag')
tag = tags[0]
if _pyver == 2:
_itypes = (int, long, VInteger)
else:
_itypes = (int, VInteger)
if not isinstance(tag, _itypes):
raise VTaggedParseError('Residual tag must be an integer')
_val = VEntity._v_lazy_native(value)
if tag == VConcept.TYPE_URL:
if not isinstance(_val, tuple) or len(_val) != 2:
raise VTaggedParseError('Value must be an 2-tuple')
for _tmp in _val:
if _pyver == 2:
if not isinstance(_tmp, unicode):
raise VTaggedParseError('Value element must be string')
else:
if not isinstance(_tmp, str):
raise VTaggedParseError('Value element must be string')
_prefix, _postfix = _val
try:
_result = VUrlConcept.create(_prefix, _postfix)
except Exception as e:
raise VTaggedParseError(e)
else:
return (lambda x: _result, [])
if tag == VConcept.TYPE_EN_WIKIPEDIA:
if _pyver == 2:
if not isinstance(_val, unicode):
raise VTaggedParseError('Value must be string')
else:
if not isinstance(_val, str):
raise VTaggedParseError('Value must be string')
try:
_result = VEnWikipediaConcept.create(_val)
except Exception as e:
raise VTaggedParseError(e)
else:
return (lambda x: _result, [])
if tag == VConcept.TYPE_VP_DEFINED:
if not isinstance(value, _itypes):
raise VTaggedParseError('Value must be an integer')
_val = VEntity._v_lazy_native(value)
try:
_result = VPlatformConcept.create(_val)
except Exception as e:
raise VTaggedParseError(e)
else:
return (lambda x: _result, [])
raise VTaggedParseError('Invalid residual tag value')
