code: def _parse_schema(schema, method):
      
      if method and schema.get('readOnly', False):
          return _READONLY_PROPERTY
  
      # allOf: Must be valid against all of the subschemas
      if 'allOf' in schema:
          schema_ = copy.deepcopy(schema['allOf'][0])
          for x in schema['allOf'][1:]:
              _dict_merge(schema_, x)
  
          return _parse_schema(schema_, method)
  
      # anyOf: Must be valid against any of the subschemas
      # TODO(stephenfin): Handle anyOf
  
      # oneOf: Must be valid against exactly one of the subschemas
      if 'oneOf' in schema:
          # we only show the first one since we can't show everything
          return _parse_schema(schema['oneOf'][0], method)
  
      if 'enum' in schema:
          # we only show the first one since we can't show everything
          return schema['enum'][0]
  
      schema_type = schema.get('type', 'object')
  
      if schema_type == 'array':
          # special case oneOf so that we can show examples for all possible
          # combinations
          if 'oneOf' in schema['items']:
              return [
                  _parse_schema(x, method) for x in schema['items']['oneOf']]
  
          return [_parse_schema(schema['items'], method)]
  
      if schema_type == 'object':
          if method and all(v.get('readOnly', False)
                            for v in schema['properties'].values()):
              return _READONLY_PROPERTY
  
          results = []
          for name, prop in schema.get('properties', {}).items():
              result = _parse_schema(prop, method)
              if result != _READONLY_PROPERTY:
                  results.append((name, result))
  
          return collections.OrderedDict(results)
  
      if (schema_type, schema.get('format')) in _TYPE_MAPPING:
          return _TYPE_MAPPING[(schema_type, schema.get('format'))]
  
      return _TYPE_MAPPING[(schema_type, None)]
docs: Convert a Schema Object to a Python object.
  
      Args:
          schema: An ``OrderedDict`` representing the schema object.