def produce_contexts(self, msg):
"""Produce contexts based on incoming message.
:param msg: Parsed request in this format: `[IN_REQUEST, body, header]`
"""
if not isinstance(msg, list):
logger.debug("Incoming request: %r", msg)
raise ValidationError(msg, "Request must be a list")
if not len(msg) >= 2:
logger.debug("Incoming request: %r", msg)
raise ValidationError(len(msg), "Request must have at least two "
"elements. It has %r")
if not isinstance(msg[0], int):
logger.debug("Incoming request: %r", msg)
raise ValidationError(msg[0], "Request version must be an integer. "
"It was %r")
processor = self._version_map.get(msg[0], None)
if processor is None:
logger.debug("Incoming request: %r", msg)
raise ValidationError(msg[0], "Unknown request type %r")
initial_ctx = processor(self, msg)
contexts = self.generate_contexts(initial_ctx)
p_ctx, others = contexts[0], contexts[1:]
return p_ctx, others
def _from_dict_value(self, key, cls, inst, validator):
if validator is self.SOFT_VALIDATION:
self.validate(key, cls, inst)
if issubclass(cls, AnyDict):
return inst
# get native type
if issubclass(cls, File) and isinstance(inst, self.complex_as):
retval = self._doc_to_object(cls.Attributes.type, inst, validator)
elif issubclass(cls, ComplexModelBase):
retval = self._doc_to_object(cls, inst, validator)
else:
if cls.Attributes.empty_is_none and inst in (u'', b''):
inst = None
if (validator is self.SOFT_VALIDATION
and isinstance(inst, six.string_types)
and not cls.validate_string(cls, inst)):
raise ValidationError((key, inst))
if issubclass(cls, (ByteArray, File)):
retval = self.from_string(cls, inst, self.binary_encoding)
else:
retval = self.from_string(cls, inst)
# validate native type
if validator is self.SOFT_VALIDATION and \
not cls.validate_native(cls, retval):
raise ValidationError((key, retval))
return retval
def from_element(self, ctx, cls, element):
if bool(element.get('{%s}nil' % _ns_xsi)):
if self.validator is self.SOFT_VALIDATION and not \
cls.Attributes.nillable:
raise ValidationError('')
return cls.Attributes.default
# if present, use the xsi:type="ns0:ObjectName"
# attribute to instantiate subclass objects
if self.parse_xsi_type:
xsi_type = element.get('{%s}type' % _ns_xsi, None)
if xsi_type is not None:
if ":" in xsi_type:
prefix, objtype = xsi_type.split(':', 1)
else:
prefix, objtype = None, xsi_type
ns = element.nsmap.get(prefix)
if ns is not None:
classkey = "{%s}%s" % (ns, objtype)
else:
raise ValidationError(xsi_type)
newclass = ctx.app.interface.classes.get(classkey, None)
if newclass is None:
raise ValidationError(xsi_type)
cls = newclass
logger.debug("xsi:type overrides %r to %r", cls, newclass)
handler = self.deserialization_handlers[cls]
return handler(ctx, cls, element)
def _from_dict_value(self, key, class_, value, validator):
if validator is self.SOFT_VALIDATION:
self.validate(key, class_, value)
if issubclass(class_, AnyDict):
return value
# get native type
if issubclass(class_, File) and isinstance(value, self.complex_as):
retval = self._doc_to_object(File.Value, value, validator)
elif issubclass(class_, ComplexModelBase):
retval = self._doc_to_object(class_, value, validator)
else:
if value == '' and class_.Attributes.empty_is_none:
value = None
if (validator is self.SOFT_VALIDATION
and isinstance(value, six.string_types)
and not class_.validate_string(class_, value)):
raise ValidationError((key, value))
if issubclass(class_, (ByteArray, File)):
retval = self.from_string(class_, value, self.binary_encoding)
else:
retval = self.from_string(class_, value)
# validate native type
if validator is self.SOFT_VALIDATION and \
not class_.validate_native(class_, retval):
raise ValidationError((key, retval))
return retval
def _from_dict_value(cls, class_, value, validator):
# validate raw input
if validator is cls.SOFT_VALIDATION:
if issubclass(class_, Unicode) and not isinstance(value, basestring):
raise ValidationError(value)
if issubclass(class_, Unicode) and not isinstance(value, unicode):
# Note that String is a subclass of Unicode
if not (issubclass(class_, String) and isinstance(value, str)):
value = ProtocolBase.from_string(class_, value)
elif issubclass(class_, Decimal) and not isinstance(value,
(int, long, float)):
raise ValidationError(value)
elif issubclass(class_, DateTime) and not (
isinstance(value, unicode) and
class_.validate_string(class_, value)):
raise ValidationError(value)
# get native type
if issubclass(class_, ComplexModelBase):
retval = cls._doc_to_object(class_, value, validator)
elif issubclass(class_, DateTime):
retval = ProtocolBase.from_string(class_, value)
else:
retval = value
# validate native type
if validator is cls.SOFT_VALIDATION and \
not class_.validate_native(class_, retval):
raise ValidationError(retval)
return retval
def process(value):
if value is not None:
if value.data is not None:
value.path = uuid1().get_hex()
fp = join(self.store, value.path)
if not abspath(fp).startswith(self.store):
raise ValidationError(
value.path, "Path %r contains "
"relative path operators (e.g. '..')")
with open(fp, 'wb') as file:
for d in value.data:
file.write(d)
elif value.handle is not None:
value.path = uuid1().hex
fp = join(self.store, value.path)
if not abspath(fp).startswith(self.store):
raise ValidationError(
value.path, "Path %r contains "
"relative path operators (e.g. '..')")
data = mmap(value.handle.fileno(), 0) # 0 = whole file
with open(fp, 'wb') as out_file:
out_file.write(data)
data.close()
elif value.path is not None:
in_file_path = value.path
if not isfile(in_file_path):
logger.error("File path in %r not found" % value)
if dirname(abspath(in_file_path)) != self.store:
dest = join(self.store, uuid1().get_hex())
if value.move:
shutil.move(in_file_path, dest)
print("move", in_file_path, dest)
else:
shutil.copy(in_file_path, dest)
value.path = basename(dest)
value.abspath = dest
else:
raise ValueError("Invalid file object passed in. All of "
".data, .handle and .path are None.")
value.store = self.store
value.abspath = join(self.store, value.path)
retval = self.get_object_as_json(
value,
self.cls,
ignore_wrappers=self.ignore_wrappers,
complex_as=self.complex_as,
)
return retval
def decompose_incoming_envelope(self, ctx, message=JsonDocument.REQUEST):
indoc = ctx.in_document
if not isinstance(indoc, dict):
raise ValidationError(indoc, "Invalid Request")
ver = indoc.get(self.VERSION)
if ver is None:
raise ValidationError(ver, "Unknown Version")
body = indoc.get(self.BODY)
err = indoc.get(self.FAULT)
if body is None and err is None:
raise ValidationError((body, err), "Request data not found")
ctx.protocol.error = False
if err is not None:
ctx.in_body_doc = err
ctx.protocol.error = True
else:
if not isinstance(body, dict):
raise ValidationError(body, "Request body not found")
if not len(body) == 1:
raise ValidationError(body, "Need len(body) == 1")
ctx.in_header_doc = indoc.get(self.HEAD)
if not isinstance(ctx.in_header_doc, list):
ctx.in_header_doc = [ctx.in_header_doc]
(ctx.method_request_string,ctx.in_body_doc), = body.items()
def _from_dict_value(self, class_, value, validator):
if validator is self.SOFT_VALIDATION:
self.validate(class_, value)
if issubclass(class_, AnyDict):
return value
# get native type
if issubclass(class_, ComplexModelBase):
retval = self._doc_to_object(class_, value, validator)
else:
if (validator is self.SOFT_VALIDATION
and isinstance(value, basestring)
and not class_.validate_string(class_, value)):
raise ValidationError(value)
if issubclass(class_, (ByteArray, file)):
retval = self.from_string(class_, value,
self.default_binary_encoding)
else:
retval = self.from_string(class_, value)
# validate native type
if validator is self.SOFT_VALIDATION and \
not class_.validate_native(class_, retval):
raise ValidationError(retval)
return retval
def produce_contexts(self, msg):
"""msg = [IN_REQUEST, body, header]"""
if not isinstance(msg, list):
logger.debug("Incoming request: %r", msg)
raise ValidationError(msg, "Request must be a list")
if not len(msg) >= 2:
logger.debug("Incoming request: %r", msg)
raise ValidationError(msg,
"Request must have at least two elements.")
if not isinstance(msg[0], int):
logger.debug("Incoming request: %r", msg)
raise ValidationError(msg[0],
"Request version must be an integer.")
processor = self._version_map.get(msg[0], None)
if processor is None:
logger.debug("Incoming request: %r", msg)
raise ValidationError(msg[0], "Unknown request type")
initial_ctx = processor(self, msg)
contexts = self.generate_contexts(initial_ctx)
return contexts[0], contexts[1:]
def from_string(cls, string):
if cls.Attributes.max_str_len is not None and len(
string) > cls.Attributes.max_str_len:
raise ValidationError(string, 'string too long.')
try:
return decimal.Decimal(string)
except decimal.InvalidOperation, e:
raise ValidationError(string)
def _to_native_values(self, cls, member, orig_k, k, v, req_enc, validator):
value = []
for v2 in v:
# some wsgi implementations pass unicode strings, some pass str
# strings. we get unicode here when we can and should.
if v2 is not None and req_enc is not None \
and not issubclass(member.type, String) \
and issubclass(member.type, Unicode) \
and not isinstance(v2, six.text_type):
try:
v2 = v2.decode(req_enc)
except UnicodeDecodeError as e:
raise ValidationError(v2, "%r while decoding %%r" % e)
# validate raw data (before deserialization)
try:
if (validator is self.SOFT_VALIDATION
and not member.type.validate_string(member.type, v2)):
raise ValidationError([orig_k, v2])
except TypeError:
raise ValidationError([orig_k, v2])
cls_attrs = self.get_cls_attrs(member.type)
v2 = self._parse(cls_attrs, v2)
# deserialize to native type
if issubclass(member.type, File):
if isinstance(v2, File.Value):
native_v2 = v2
else:
native_v2 = self.from_unicode(member.type, v2,
self.binary_encoding)
elif issubclass(member.type, ByteArray):
native_v2 = self.from_unicode(member.type, v2,
self.binary_encoding)
else:
try:
native_v2 = self.from_unicode(member.type, v2)
except ValidationError as e:
ns = "%s.%s" % (cls.get_namespace(), cls.get_type_name())
raise ValidationError(
e.faultstring,
"Validation failed for %s.%s: %%s" % (ns, k))
# validate native data (after deserialization)
native_v2 = self._sanitize(cls_attrs, native_v2)
if validator is self.SOFT_VALIDATION:
if not member.type.validate_native(member.type, native_v2):
raise ValidationError([orig_k, v2])
value.append(native_v2)
return value
def decimal_from_string(cls, string):
if cls.Attributes.max_str_len is not None and len(string) > \
cls.Attributes.max_str_len:
raise ValidationError(string, "Decimal %%r longer than %d characters"
% cls.Attributes.max_str_len)
try:
return decimal.Decimal(string)
except decimal.InvalidOperation, e:
raise ValidationError(string, "%%r: %r" % e)
def integer_from_string(cls, string):
if cls.Attributes.max_str_len is not None and len(string) > \
cls.Attributes.max_str_len:
raise ValidationError(string, "Integer %%r longer than %d characters"
% cls.Attributes.max_str_len)
try:
return int(string)
except ValueError:
raise ValidationError(string, "Could not cast %r to integer")
def cache_package(spec, own_url):
try:
spec = Requirement.parse(spec)
except ValueError:
raise ArgumentError(
"Not a URL, existing file, or requirement spec: %r" % (spec, ))
try:
# download and unpack source package
path = tempfile.mkdtemp('.spynepi')
logger.info("Downloading %r" % spec)
dist = PackageIndex().fetch_distribution(spec,
path,
force_scan=True,
source=True)
archive_path = dist.location
logger.info("Unpacking %r" % archive_path)
unpack_archive(dist.location, path)
# generate pypirc if possible
if os.environ.has_key('HOME'):
_generate_pypirc(own_url)
else: # FIXME: ??? No idea. Hopefully setuptools knows better.
pass # raise NotImplementedError("$HOME not defined, .pypirc not found.")
# find setup.py in package. plagiarized from setuptools.
setups = glob(os.path.join(path, '*', 'setup.py'))
if not setups:
raise ValidationError(
"Couldn't find a setup script in %r editable distribution: %r"
% (spec, os.path.join(path, '*', 'setup.py')))
if len(setups) > 1:
raise ValidationError(
"Multiple setup scripts found in %r editable distribution: %r"
% (spec, setups))
# self-register the package.
lib_dir = os.path.dirname(setups[0])
command = ["python", "setup.py", "register", "-r", REPO_NAME]
logger.info('calling %r', command)
subprocess.call(command, cwd=lib_dir, stdout=sys.stdout)
# self-upload the package
command = ["python", "-m", "spynepi.util.pypi.upload", archive_path]
logger.info('calling %r', command)
subprocess.call(command,
cwd=lib_dir,
stdin=sys.stdin,
stdout=sys.stdout)
finally:
shutil.rmtree(path)
def base_from_element(prot, cls, element):
if prot.validator is prot.SOFT_VALIDATION and not (
cls.validate_string(cls, element.text)):
raise ValidationError(element.text)
retval = callable(cls, element.text)
if prot.validator is prot.SOFT_VALIDATION and not (
cls.validate_native(cls, retval)):
raise ValidationError(element.text)
return retval
def decimal_from_unicode(self, cls, string):
cls_attrs = self.get_cls_attrs(cls)
if cls_attrs.max_str_len is not None and len(string) > \
cls_attrs.max_str_len:
raise ValidationError(string, "Decimal %%r longer than %d "
"characters" % cls_attrs.max_str_len)
try:
return D(string)
except InvalidOperation as e:
raise ValidationError(string, "%%r: %r" % e)
def byte_array_from_element(prot, cls, element):
if prot.validator is prot.SOFT_VALIDATION and not (cls.validate_string(
cls, element.text)):
raise ValidationError(element.text)
retval = prot.from_string(cls, element.text, prot.default_binary_encoding)
if prot.validator is prot.SOFT_VALIDATION and not (cls.validate_native(
cls, retval)):
raise ValidationError(retval)
return retval
def byte_array_from_element(self, ctx, cls, element):
if self.validator is self.SOFT_VALIDATION and not (
cls.validate_string(cls, element.text)):
raise ValidationError(element.text)
retval = self.from_unicode(cls, element.text, self.binary_encoding)
if self.validator is self.SOFT_VALIDATION and not (
cls.validate_native(cls, retval)):
raise ValidationError(retval)
return retval
def integer_from_string(self, cls, string):
if isinstance(string, six.string_types) and \
cls.Attributes.max_str_len is not None and \
len(string) > cls.Attributes.max_str_len:
raise ValidationError(
string, "Integer %%r longer than %d characters" %
cls.Attributes.max_str_len)
try:
return int(string)
except ValueError:
raise ValidationError(string, "Could not cast %r to integer")
def base_from_element(self, ctx, cls, element):
if self.validator is self.SOFT_VALIDATION and not (cls.validate_string(
cls, element.text)):
raise ValidationError(element.text)
retval = self.from_string(cls, element.text)
if self.validator is self.SOFT_VALIDATION and not (cls.validate_native(
cls, retval)):
raise ValidationError(retval)
return retval
def from_urlsafe_base64(cls, value):
#FIXME: Find out why we need to do this.
if isinstance(value, six.text_type):
value = value.encode('utf8')
try:
return (urlsafe_b64decode(_bytes_join(value)), )
except TypeError as e:
logger.exception(e)
if len(value) > 100:
raise ValidationError(value)
else:
raise ValidationError(value[:100] + "(...)")
def integer_from_string(self, cls, string):
cls_attrs = self.get_cls_attrs(cls)
if isinstance(string, (six.text_type, six.binary_type)) and \
cls_attrs.max_str_len is not None and \
len(string) > cls_attrs.max_str_len:
raise ValidationError(string,
"Integer %%r longer than %d characters"
% cls_attrs.max_str_len)
try:
return int(string)
except ValueError:
raise ValidationError(string, "Could not cast %r to integer")
def check_freq_dict(cls, d, fti=None):
if fti is None:
fti = cls.get_flat_type_info(cls)
for k, v in fti.items():
val = d[k]
min_o, max_o = v.Attributes.min_occurs, v.Attributes.max_occurs
if val < min_o:
raise ValidationError(
k, '%%r member must occur at least %d times.' % min_o)
elif val > max_o:
raise ValidationError(
k, '%%r member must occur at most %d times.' % max_o)
def unicode_from_element(prot, cls, element):
if prot.validator is prot.SOFT_VALIDATION and not (
cls.validate_string(cls, element.text)):
raise ValidationError(element.text)
s = element.text
if s is None:
s = ''
retval = cls.from_string(s)
if prot.validator is prot.SOFT_VALIDATION and not (
cls.validate_native(cls, retval)):
raise ValidationError(element.text)
return retval
def from_element(self, ctx, cls, element):
cls_attrs = self.get_cls_attrs(cls)
if bool(element.get(XSI('nil'))):
if self.validator is self.SOFT_VALIDATION and not \
cls_attrs.nillable:
raise ValidationError(None)
if self.replace_null_with_default:
return cls_attrs.default
return None
# if present, use the xsi:type="ns0:ObjectName"
# attribute to instantiate subclass objects
if self.parse_xsi_type:
xsi_type = element.get(XSI_TYPE, None)
if xsi_type is not None:
if ":" in xsi_type:
prefix, objtype = xsi_type.split(':', 1)
else:
prefix, objtype = None, xsi_type
ns = element.nsmap.get(prefix)
if ns is not None:
classkey = "{%s}%s" % (ns, objtype)
else:
logger.error(
"xsi:type namespace prefix "
"'%s' in '%s' not found in %r", ns, xsi_type,
element.nsmap)
raise ValidationError(xsi_type)
newclass = ctx.app.interface.classes.get(classkey, None)
if newclass is None:
logger.error(
"xsi:type '%s' interpreted as class key '%s' "
"is not recognized", xsi_type, classkey)
raise ValidationError(xsi_type)
cls = newclass
logger.debug("xsi:type '%s' overrides %r to %r", xsi_type, cls,
newclass)
handler = self.deserialization_handlers[cls]
return handler(ctx, cls, element)
def decompose_incoming_envelope(self, ctx, message):
"""Sets ``ctx.in_body_doc``, ``ctx.in_header_doc`` and
``ctx.method_request_string`` using ``ctx.in_document``.
"""
assert message in (ProtocolBase.REQUEST, ProtocolBase.RESPONSE)
# set ctx.in_header
ctx.transport.in_header_doc = None # use an rpc protocol if you want headers.
doc = ctx.in_document
ctx.in_header_doc = None
ctx.in_body_doc = doc
if len(doc) == 0:
raise Fault("Client", "Empty request")
logger.debug('\theader : %r' % (ctx.in_header_doc))
logger.debug('\tbody : %r' % (ctx.in_body_doc))
if not isinstance(doc, dict) or len(doc) != 1:
raise ValidationError("Need a dictionary with exactly one key "
"as method name.")
mrs, = doc.keys()
ctx.method_request_string = '{%s}%s' % (self.app.interface.get_tns(),
mrs)
def unicode_from_element(self, ctx, cls, element):
if self.validator is self.SOFT_VALIDATION and not (
cls.validate_string(cls, element.text)):
raise ValidationError(element.text)
s = element.text
if s is None:
s = ''
retval = self.from_unicode(cls, s)
if self.validator is self.SOFT_VALIDATION and not (
cls.validate_native(cls, retval)):
raise ValidationError(retval)
return retval
def from_string(cls, string):
duration = _duration_re.match(string).groupdict(0)
if duration is None:
ValidationError(string)
days = int(duration['days'])
days += int(duration['months']) * 30
days += int(duration['years']) * 365
hours = int(duration['hours'])
minutes = int(duration['minutes'])
seconds = float(duration['seconds'])
f, i = math.modf(seconds)
seconds = i
microseconds = int(1e6 * f)
delta = datetime.timedelta(days=days,
hours=hours,
minutes=minutes,
seconds=seconds,
microseconds=microseconds)
if duration['sign'] == "-":
delta *= -1
return delta
def from_string(cls, string):
try:
d = datetime.datetime.strptime(string, cls.Attributes.format)
return datetime.date(d.year, d.month, d.day)
except ValueError:
raise ValidationError(string)
def datetime_from_string_iso(self, cls, string):
astz = cls.Attributes.as_timezone
match = cls._utc_re.match(string)
if match:
tz = pytz.utc
retval = _parse_datetime_iso_match(match, tz=tz)
if astz is not None:
retval = retval.astimezone(astz)
return retval
if match is None:
match = cls._offset_re.match(string)
if match:
tz_hr, tz_min = [int(match.group(x)) for x in ("tz_hr", "tz_min")]
tz = FixedOffset(tz_hr * 60 + tz_min, {})
retval = _parse_datetime_iso_match(match, tz=tz)
if astz is not None:
retval = retval.astimezone(astz)
return retval
if match is None:
match = cls._local_re.match(string)
if match:
retval = _parse_datetime_iso_match(match)
if astz:
retval = retval.replace(tzinfo=astz)
return retval
raise ValidationError(string)
