"""

if isinstance(v, StoneExampleRef):

return "reference"

elif isinstance(v, numbers.Integral):

# Must come before real numbers check since integrals are reals too

return 'integer'

elif isinstance(v, numbers.Real):

return 'float'

elif isinstance(v, (tuple, list)):

return 'list'

elif isinstance(v, six.string_types):

return 'string'

elif v is None:

return 'null'

else:

"""

__metaclass__ = ABCMeta

def __init__(self):

"""No-op. Exists so that introspection can be certain that an init

pass

@property

def name(self):

"""Returns an easy to read name for the type."""

return self.__class__.__name__

@abstractmethod

def check(self, val):

"""

pass

@abstractmethod

def check_example(self, ex_field):

"""

pass

def __repr__(self):

def check_attr_repr(self, attr_field):

try:

self.check(attr_field.value)

except ValueError as e:

raise InvalidSpec(e.args[0], attr_field.lineno, attr_field.path)

"""

def __init__(self, data_type):

self.data_type = data_type

def check(self, val):

if val is not None:

return self.data_type.check(val)

def check_example(self, ex_field):

if ex_field.value is not None:

return self.data_type.check_example(ex_field)

def check_attr_repr(self, attr_field):

if attr_field.value is None:

return None

else:

def check(self, val):

if val is not None:

raise ValueError('void type can only be null')

def check_example(self, ex_field):

if ex_field.value is not None:

raise InvalidSpec('example of void type must be null',

ex_field.lineno, ex_field.path)

def check_attr_repr(self, attr_field):

def check(self, val):

if not isinstance(val, (bytes, six.text_type)):

raise ValueError('%r is not valid bytes' % val)

def check_example(self, ex_field):

if not isinstance(ex_field.value, (bytes, six.text_type)):

raise InvalidSpec("'%s' is not valid bytes",

ex_field.lineno, ex_field.path)

def check_attr_repr(self, attr_field):

try:

self.check(attr_field.value)

except ValueError as e:

raise InvalidSpec(e.args[0], attr_field.lineno, attr_field.path)

v = attr_field.value

if isinstance(v, six.text_type):

return v.encode('utf-8')

else:

"""

def __init__(self, min_value=None, max_value=None):

"""

if min_value is not None:

if not isinstance(min_value, numbers.Integral):

raise ParameterError('min_value must be an integral number')

if min_value < self.minimum:

raise ParameterError('min_value cannot be less than the '

'minimum value for this type (%s < %s)' %

(min_value, self.minimum))

if max_value is not None:

if not isinstance(max_value, numbers.Integral):

raise ParameterError('max_value must be an integral number')

if max_value > self.maximum:

raise ParameterError('max_value cannot be greater than the '

'maximum value for this type (%s < %s)' %

(max_value, self.maximum))

self.min_value = min_value

self.max_value = max_value

def check(self, val):

if not isinstance(val, numbers.Integral):

raise ValueError('%s is not a valid integer' %

generic_type_name(val))

if not (self.minimum <= val <= self.maximum):

raise ValueError('%d is not within range [%r, %r]'

% (val, self.minimum, self.maximum))

if self.min_value is not None and val < self.min_value:

raise ValueError('%d is less than %d' %

(val, self.min_value))

if self.max_value is not None and val > self.max_value:

raise ValueError('%d is greater than %d' %

(val, self.max_value))

def check_example(self, ex_field):

try:

self.check(ex_field.value)

except ValueError as e:

raise InvalidSpec(e.args[0], ex_field.lineno, ex_field.path)

def __repr__(self):

"""

minimum = None

maximum = None

def __init__(self, min_value=None, max_value=None):

"""

if min_value is not None:

if not isinstance(min_value, numbers.Real):

raise ParameterError('min_value must be a real number')

if not isinstance(min_value, float):

try:

min_value = float(min_value)

except OverflowError:

raise ParameterError('min_value is too small for a float')

if self.minimum is not None and min_value < self.minimum:

raise ParameterError('min_value cannot be less than the '

'minimum value for this type (%f < %f)' %

(min_value, self.minimum))

if max_value is not None:

if not isinstance(max_value, numbers.Real):

raise ParameterError('max_value must be a real number')

if not isinstance(max_value, float):

try:

max_value = float(max_value)

except OverflowError:

raise ParameterError('max_value is too large for a float')

if self.maximum is not None and max_value > self.maximum:

raise ParameterError('max_value cannot be greater than the '

'maximum value for this type (%f < %f)' %

(max_value, self.maximum))

self.min_value = min_value

self.max_value = max_value

def check(self, val):

if not isinstance(val, numbers.Real):

raise ValueError('%s is not a valid real number' %

generic_type_name(val))

if not isinstance(val, float):

try:

val = float(val)

except OverflowError:

raise ValueError('%r is too large for float' % val)

if math.isnan(val) or math.isinf(val):

# Parser doesn't support NaN or Inf yet.

raise ValueError('%f values are not supported' % val)

if self.minimum is not None and val < self.minimum:

raise ValueError('%f is less than %f' %

(val, self.minimum))

if self.maximum is not None and val > self.maximum:

raise ValueError('%f is greater than %f' %

(val, self.maximum))

if self.min_value is not None and val < self.min_value:

raise ValueError('%f is less than %f' %

(val, self.min_value))

if self.max_value is not None and val > self.max_value:

raise ValueError('%f is greater than %f' %

(val, self.min_value))

def check_example(self, ex_field):

try:

self.check(ex_field.value)

except ValueError as e:

raise InvalidSpec(e.args[0], ex_field.lineno, ex_field.path)

def __repr__(self):

def check(self, val):

if not isinstance(val, bool):

raise ValueError('%r is not a valid boolean' % val)

def check_example(self, ex_field):

try:

self.check(ex_field.value)

except ValueError as e:

def __init__(self, min_length=None, max_length=None, pattern=None):

if min_length is not None:

if not isinstance(min_length, numbers.Integral):

raise ParameterError('min_length must be an integral number')

if min_length < 0:

raise ParameterError('min_length must be >= 0')

if max_length is not None:

if not isinstance(max_length, numbers.Integral):

raise ParameterError('max_length must be an integral number')

if max_length < 1:

raise ParameterError('max_length must be > 0')

if min_length and max_length:

if max_length < min_length:

raise ParameterError('max_length must be >= min_length')

self.min_length = min_length

self.max_length = max_length

self.pattern = pattern

self.pattern_re = None

if pattern:

if not isinstance(pattern, six.string_types):

raise ParameterError('pattern must be a string')

try:

self.pattern_re = re.compile(pattern)

except re.error as e:

raise ParameterError(

'could not compile regex pattern {!r}: {}'.format(

pattern, e.args[0]))

def check(self, val):

if not isinstance(val, six.string_types):

raise ValueError('%s is not a valid string' %

generic_type_name(val))

elif self.max_length is not None and len(val) > self.max_length:

raise ValueError("'%s' has more than %d character(s)"

% (val, self.max_length))

elif self.min_length is not None and len(val) < self.min_length:

raise ValueError("'%s' has fewer than %d character(s)"

% (val, self.min_length))

elif self.pattern and not self.pattern_re.match(val):

raise ValueError("'%s' did not match pattern '%s'"

% (val, self.pattern))

def check_example(self, ex_field):

try:

self.check(ex_field.value)

except ValueError as e:

def __init__(self, format):

if not isinstance(format, six.string_types):

raise ParameterError('format must be a string')

self.format = format

def check(self, val):

if not isinstance(val, six.string_types):

raise ValueError('timestamp must be specified as a string')

# Raises a ValueError if val is the incorrect format

datetime.datetime.strptime(val, self.format)

def check_example(self, ex_field):

try:

self.check(ex_field.value)

except ValueError as e:

raise InvalidSpec(e.args[0], ex_field.lineno, ex_field.path)

def check_attr_repr(self, attr_field):

try:

self.check(attr_field.value)

except ValueError as e:

msg = e.args[0]

if isinstance(msg, six.binary_type):

# For Python 2 compatibility.

msg = msg.decode('utf-8')

raise InvalidSpec(msg, attr_field.lineno, attr_field.path)

def __init__(self, data_type, min_items=None, max_items=None):

self.data_type = data_type

if min_items is not None and min_items < 0:

raise ParameterError('min_items must be >= 0')

if max_items is not None and max_items < 1:

raise ParameterError('max_items must be > 0')

if min_items and max_items and max_items < min_items:

raise ParameterError('max_length must be >= min_length')

self.min_items = min_items

self.max_items = max_items

def check(self, val):

raise NotImplementedError

def check_example(self, ex_field):

try:

self._check_list_container(ex_field.value)

for item in ex_field.value:

new_ex_field = StoneExampleField(ex_field.path,

ex_field.lineno,

ex_field.lexpos,

ex_field.name,

item)

self.data_type.check_example(new_ex_field)

except ValueError as e:

raise InvalidSpec(e.args[0], ex_field.lineno, ex_field.path)

def _check_list_container(self, val):

if not isinstance(val, list):

raise ValueError('%s is not a valid list' % generic_type_name(val))

elif self.max_items is not None and len(val) > self.max_items:

raise ValueError('list has more than %s item(s)' % self.max_items)

elif self.min_items is not None and len(val) < self.min_items:

"""

if raw_doc is None:

return None

docstring = ''

consecutive_newlines = 0

# Remove all leading and trailing whitespace in the documentation block

for c in raw_doc.strip():

if c == '\n':

consecutive_newlines += 1

if consecutive_newlines > 1:

docstring += c

else:

if consecutive_newlines == 1:

docstring += ' '

consecutive_newlines = 0

docstring += c

"""

def __init__(self,

name,

data_type,

doc,

token):

"""

self.name = name

self.data_type = data_type

self.raw_doc = doc

self.doc = doc_unwrap(doc)

self._token = token

def __repr__(self):

return 'Field(%r, %r)' % (self.name,

"""

def __init__(self,

name,

data_type,

doc,

token,

deprecated=False):

"""

super(StructField, self).__init__(name, data_type, doc, token)

self.deprecated = deprecated

self.has_default = False

self._default = None

def set_default(self, default):

self.has_default = True

self._default = default

@property

def default(self):

if not self.has_default:

raise Exception('Type has no default')

else:

return self._default

def check_attr_repr(self, attr):

if attr is not None:

attr = self.data_type.check_attr_repr(attr)

if attr is None:

if self.has_default:

return self.default

_, unwrapped_nullable, _ = unwrap(self.data_type)

if unwrapped_nullable:

return None

else:

raise KeyError(self.name)

return attr

def __repr__(self):

return 'StructField(%r, %r)' % (self.name,

"""

def __init__(self,

name,

data_type,

doc,

token,

catch_all=False):

super(UnionField, self).__init__(name, data_type, doc, token)

self.catch_all = catch_all

def __repr__(self):

return 'UnionField(%r, %r, %r)' % (self.name,

self.data_type,

"""

DEFAULT_EXAMPLE_LABEL = 'default'

def __init__(self, name, namespace, token):

"""

self._name = name

self.namespace = namespace

self._token = token

self._is_forward_ref = True

self.raw_doc = None

self.doc = None

self.fields = None

self._raw_examples = None

self._examples = None

self._fields_by_name = None

def set_attributes(self, doc, fields, parent_type=None):

"""

self.raw_doc = doc

self.doc = doc_unwrap(doc)

self.fields = fields

self.parent_type = parent_type

self._raw_examples = OrderedDict()

self._examples = OrderedDict()

self._fields_by_name = {} # Dict[str, Field]

# Check that no two fields share the same name.

for field in self.fields:

if field.name in self._fields_by_name:

orig_lineno = self._fields_by_name[field.name]._token.lineno

raise InvalidSpec("Field '%s' already defined on line %s." %

(field.name, orig_lineno),

field._token.lineno)

self._fields_by_name[field.name] = field

# Check that the fields for this type do not match any of the fields of

# its parents.

cur_type = self.parent_type

while cur_type:

for field in self.fields:

if field.name in cur_type._fields_by_name:

lineno = cur_type._fields_by_name[field.name]._token.lineno

raise InvalidSpec(

"Field '%s' already defined in parent '%s' on line %d."

% (field.name, cur_type.name, lineno),

field._token.lineno)

cur_type = cur_type.parent_type

# Indicate that the attributes of the type have been populated.

self._is_forward_ref = False

@property

def all_fields(self):

raise NotImplementedError

def has_documented_type_or_fields(self, include_inherited_fields=False):

"""Returns whether this type, or any of its fields, are documented.

if self.doc:

return True

else:

return self.has_documented_fields(include_inherited_fields)

def has_documented_fields(self, include_inherited_fields=False):

"""Returns whether at least one field is documented."""

fields = self.all_fields if include_inherited_fields else self.fields

for field in fields:

if field.doc:

return True

return False

@property

def name(self):

return self._name

def copy(self):

return copy.deepcopy(self)

def prepend_field(self, field):

self.fields.insert(0, field)

def get_examples(self, compact=False):

"""

# Copy it just in case the caller wants to mutate the object.

examples = copy.deepcopy(self._examples)

if not compact:

return examples

def make_compact(d):

# Traverse through dicts looking for ones that have a lone .tag

# key, which can be converted into the compact form.

if not isinstance(d, dict):

return

for key in d:

if isinstance(d[key], dict):

inner_d = d[key]

if len(inner_d) == 1 and '.tag' in inner_d:

d[key] = inner_d['.tag']

else:

make_compact(inner_d)

for example in examples.values():

if (isinstance(example.value, dict) and

len(example.value) == 1 and '.tag' in example.value):

# Handle the case where the top-level of the example can be

# made compact.

example.value = example.value['.tag']

else:

make_compact(example.value)

"""An example of a struct or union type."""

def __init__(self, label, text, value, token=None):

assert isinstance(label, six.text_type), type(label)

self.label = label

assert isinstance(text, (six.text_type, type(None))), type(text)

self.text = doc_unwrap(text) if text else text

assert isinstance(value, (six.text_type, OrderedDict)), type(value)

self.value = value

self._token = token

def __repr__(self):

return 'Example({!r}, {!r}, {!r})'.format(

"""

composite_type = 'struct'

def set_attributes(self, doc, fields, parent_type=None):

"""

if parent_type:

assert isinstance(parent_type, Struct)

self.subtypes = []

# These are only set if this struct enumerates subtypes.

self._enumerated_subtypes = None # Optional[List[Tuple[str, DataType]]]

self._is_catch_all = None # Optional[Bool]

super(Struct, self).set_attributes(doc, fields, parent_type)

if self.parent_type:

self.parent_type.subtypes.append(self)

def check(self, val):

raise NotImplementedError

def check_example(self, ex_field):

if not isinstance(ex_field.value, StoneExampleRef):

raise InvalidSpec(

"example must reference label of '%s'" % self.name,

ex_field.lineno, ex_field.path)

def check_attr_repr(self, attrs):

# Since we mutate it, let's make a copy to avoid mutating the argument.

attrs = attrs.copy()

validated_attrs = {}

for field in self.all_fields:

attr = field.check_attr_repr(attrs.pop(field.name, None))

validated_attrs[field.name] = attr

if attrs:

attr_name, attr_field = attrs.popitem()

raise InvalidSpec(

"Route attribute '%s' is not defined in 'stone_cfg.Route'."

% attr_name, attr_field.lineno, attr_field.path)

return validated_attrs

@property

def all_fields(self):

"""

return self.all_required_fields + self.all_optional_fields

def _filter_fields(self, filter_function):

"""

fields = []

if self.parent_type:

fields.extend(self.parent_type._filter_fields(filter_function))

fields.extend(filter(filter_function, self.fields))

return fields

@property

def all_required_fields(self):

"""

def required_check(f):

return not is_nullable_type(f.data_type) and not f.has_default

return self._filter_fields(required_check)

@property

def all_optional_fields(self):

"""

def optional_check(f):

return is_nullable_type(f.data_type) or f.has_default

return self._filter_fields(optional_check)

def has_enumerated_subtypes(self):

"""

return bool(self._enumerated_subtypes)

def get_enumerated_subtypes(self):

"""

assert self._enumerated_subtypes is not None

return self._enumerated_subtypes

def is_member_of_enumerated_subtypes_tree(self):

"""

return (self.has_enumerated_subtypes() or

(self.parent_type and

self.parent_type.has_enumerated_subtypes()))

def is_catch_all(self):

"""

assert self._enumerated_subtypes is not None

return self._is_catch_all

def set_enumerated_subtypes(self, subtype_fields, is_catch_all):

"""

assert self._enumerated_subtypes is None, \

'Enumerated subtypes already set.'

assert isinstance(is_catch_all, bool), type(is_catch_all)

self._is_catch_all = is_catch_all

self._enumerated_subtypes = []

if self.parent_type:

raise InvalidSpec(

"'%s' enumerates subtypes so it cannot extend another struct."

% self.name, self._token.lineno, self._token.path)

# Require that if this struct enumerates subtypes, its parent (and thus

# the entire hierarchy above this struct) does as well.

if self.parent_type and not self.parent_type.has_enumerated_subtypes():

raise InvalidSpec(

"'%s' cannot enumerate subtypes if parent '%s' does not." %

(self.name, self.parent_type.name),

self._token.lineno, self._token.path)

enumerated_subtype_names = set() # Set[str]

for subtype_field in subtype_fields:

path = subtype_field._token.path

lineno = subtype_field._token.lineno

# Require that a subtype only has a single type tag.

if subtype_field.data_type.name in enumerated_subtype_names:

raise InvalidSpec(

"Subtype '%s' can only be specified once." %

subtype_field.data_type.name, lineno, path)

# Require that a subtype has this struct as its parent.

if subtype_field.data_type.parent_type != self:

raise InvalidSpec(

"'%s' is not a subtype of '%s'." %

(subtype_field.data_type.name, self.name), lineno, path)

# Check for subtype tags that conflict with this struct's

# non-inherited fields.

if subtype_field.name in self._fields_by_name:

# Since the union definition comes first, use its line number

# as the source of the field's original declaration.

orig_field = self._fields_by_name[subtype_field.name]

raise InvalidSpec(

"Field '%s' already defined on line %d." %

(subtype_field.name, lineno),

orig_field._token.lineno,

orig_field._token.path)

# Walk up parent tree hierarchy to ensure no field conflicts.

# Checks for conflicts with subtype tags and regular fields.

cur_type = self.parent_type

while cur_type:

if subtype_field.name in cur_type._fields_by_name:

orig_field = cur_type._fields_by_name[subtype_field.name]

raise InvalidSpec(

"Field '%s' already defined in parent '%s' (%s:%d)."

% (subtype_field.name, cur_type.name,

orig_field._token.path, orig_field._token.lineno),

lineno, path)

cur_type = cur_type.parent_type

# Note the discrepancy between `fields` which contains only the

# struct fields, and `_fields_by_name` which contains the struct

# fields and enumerated subtype fields.

self._fields_by_name[subtype_field.name] = subtype_field

enumerated_subtype_names.add(subtype_field.data_type.name)

self._enumerated_subtypes.append(subtype_field)

assert len(self._enumerated_subtypes) > 0

# Check that all known subtypes are listed in the enumeration.

for subtype in self.subtypes:

if subtype.name not in enumerated_subtype_names:

raise InvalidSpec(

"'%s' does not enumerate all subtypes, missing '%s'" %

(self.name, subtype.name),

self._token.lineno)

def get_all_subtypes_with_tags(self):

"""