def _flatten(self, meta):
     for key, value in mapping_iterator(meta):
         if isinstance(value, Mapping):
             for child, value in self._flatten(value):
                 yield '%s_%s' % (key, child), value
         else:
             yield key, self._to_string(value)

def _flatten(meta):
    for key, value in mapping_iterator(meta):
        if isinstance(value, Mapping):
            for child, v in _flatten(value):
                yield '%s_%s' % (key, child), v
        else:
            yield key, _flatten_value(value)

 def __call__(self, response, **kw):
     r = response.request
     url, headers, _ = self._client.sign(
         r.url, r.method, r.body, r.headers)
     for key, value in mapping_iterator(headers):
         r.add_header(key, value)
     r.url = url

 def _ready(self, data):
     charset = self.charset
     data = parse_qs(data.decode(charset), keep_blank_values=True)
     forms = self.result[0]
     for key, values in mapping_iterator(data):
         for value in values:
             forms[key] = value
     return self.result

 def __call__(self, response, exc=None):
     r = response.request
     url, headers, data = self._client.sign(r.full_url, r.method, r.data,
                                            r.headers)
     for key, value in mapping_iterator(headers):
         r.add_header(key, value)
     r.full_url = url
     r.data = data

 def _ready(self, data):
     self.environ["wsgi.input"] = BytesIO(data)
     charset = self.charset
     data = parse_qs(data.decode(charset), keep_blank_values=True)
     forms = self.result[0]
     for key, values in mapping_iterator(data):
         for value in values:
             forms[key] = value
     return self.result

 def __init__(self, proxies=None, headers=None, verify=True,
              cookies=None, store_cookies=True, cert=None,
              max_redirects=10, decompress=True, version=None,
              websocket_handler=None, parser=None, trust_env=True,
              loop=None, client_version=None, timeout=None, stream=False,
              pool_size=10, frame_parser=None, logger=None,
              close_connections=False, keep_alive=None):
     super().__init__(
         partial(Connection, HttpResponse),
         loop=loop,
         keep_alive=keep_alive or cfg_value('http_keep_alive')
     )
     self.logger = logger or LOGGER
     self.client_version = client_version or self.client_version
     self.connection_pools = {}
     self.pool_size = pool_size
     self.trust_env = trust_env
     self.timeout = timeout
     self.store_cookies = store_cookies
     self.max_redirects = max_redirects
     self.cookies = cookiejar_from_dict(cookies)
     self.decompress = decompress
     self.version = version or self.version
     # SSL Verification default
     self.verify = verify
     # SSL client certificate default, if String, path to ssl client
     # cert file (.pem). If Tuple, ('cert', 'key') pair
     self.cert = cert
     self.stream = stream
     self.close_connections = close_connections
     dheaders = CIMultiDict(self.DEFAULT_HTTP_HEADERS)
     dheaders['user-agent'] = self.client_version
     # override headers
     if headers:
         for name, value in mapping_iterator(headers):
             if value is None:
                 dheaders.pop(name, None)
             else:
                 dheaders[name] = value
     self.headers = dheaders
     self.proxies = dict(proxies or ())
     if not self.proxies and self.trust_env:
         self.proxies = get_environ_proxies()
         if 'no' not in self.proxies:
             self.proxies['no'] = ','.join(self.no_proxy)
     self.websocket_handler = websocket_handler
     self.http_parser = parser or http.HttpResponseParser
     self.frame_parser = frame_parser or websocket.frame_parser
     # Add hooks
     self.event('on_headers').bind(handle_cookies)
     self.event('pre_request').bind(WebSocket())
     self.event('post_request').bind(Expect())
     self.event('post_request').bind(Redirect())
     self._decompressors = dict(
         gzip=GzipDecompress(),
         deflate=DeflateDecompress()
     )

def full_url(url, params, method=None):
    p = urlparse(url)
    if not p.netloc and method == 'CONNECT':
        p = urlparse('http://%s' % url)

    params = mapping_iterator(params)
    query = parse_qsl(p.query)
    query.extend(split_url_params(params))
    query = urlencode(query)
    return urlunparse((p.scheme, p.netloc, p.path,
                       p.params, query, p.fragment))

 def _encode_url(self, data):
     query = self.query
     if data:
         data = native_str(data)
         if isinstance(data, str):
             data = parse_qsl(data)
         else:
             data = mapping_iterator(data)
         query = parse_qsl(query)
         query.extend(data)
         query = urlencode(query)
     self.query = query

    def get(self, request):
        '''Get all routes grouped in sections.

        This is the only method available for the router base route.'''
        if request.response.content_type in JSON_CONTENT_TYPES:
            json = Json(as_list=True)
            for name, section in mapping_iterator(self.sections):
                json.append(OrderedDict((('name', name),
                                         ('routes', section.json(request)))))
            return json.http_response(request)
        else:
            raise HttpException(status=415)

    def _full_url(self, url, params):
        """Full url of endpoint
        """
        p = urlparse(url)
        if not p.netloc and self.method == 'CONNECT':
            p = urlparse('http://%s' % url)

        params = mapping_iterator(params)
        query = parse_qsl(p.query)
        query.extend(split_url_params(params))
        query = urlencode(query)
        return urlunparse((p.scheme, p.netloc, p.path,
                           p.params, query, p.fragment))

 def _encode_url(self, body):
     query = self.query
     if body:
         body = native_str(body)
         if isinstance(body, str):
             body = parse_qsl(body)
         else:
             body = mapping_iterator(body)
         query = parse_qsl(query)
         query.extend(body)
         self.data = query
         query = urlencode(query)
     self.query = query

 def _encode_files(self, data):
     fields = []
     for field, val in mapping_iterator(data or ()):
         if isinstance(val, str) or isinstance(val, bytes) or not hasattr(val, "__iter__"):
             val = [val]
         for v in val:
             if v is not None:
                 if not isinstance(v, bytes):
                     v = str(v)
                 fields.append(
                     (
                         field.decode("utf-8") if isinstance(field, bytes) else field,
                         v.encode("utf-8") if isinstance(v, str) else v,
                     )
                 )
     for (k, v) in mapping_iterator(self.files):
         # support for explicit filename
         ft = None
         if isinstance(v, (tuple, list)):
             if len(v) == 2:
                 fn, fp = v
             else:
                 fn, fp, ft = v
         else:
             fn = guess_filename(v) or k
             fp = v
         if isinstance(fp, bytes):
             fp = BytesIO(fp)
         elif isinstance(fp, str):
             fp = StringIO(fp)
         if ft:
             new_v = (fn, fp.read(), ft)
         else:
             new_v = (fn, fp.read())
         fields.append((k, new_v))
     #
     return encode_multipart_formdata(fields, charset=self.charset)

def process_meta(meta, cfg):
    as_list = MultiValue()
    for key, values in mapping_iterator(meta):
        key = slugify(key, separator='_')
        if not isinstance(values, (list, tuple)):
            values = (values,)
        if key not in METADATA_PROCESSORS:
            bits = key.split('_', 1)
            values = guess(as_list(values, cfg))
            if len(bits) > 1 and bits[0] == 'meta':
                k = '_'.join(bits[1:])
                yield k, values
            else:
                yield key, values
        #
        elif values:
            process = METADATA_PROCESSORS[key]
            yield key, process(values, cfg)

 def update(self, iterable):
     for name, value in mapping_iterator(iterable):
         self[name] = value

 def _update_modify(self, iterable):
     for field, value in mapping_iterator(iterable):
         yield self._get_field_value(field, value)

def chain_meta(meta1, meta2):
    return chain(mapping_iterator(meta1), mapping_iterator(meta2))

def split_url_params(params):
    for key, values in mapping_iterator(params):
        if not isinstance(values, (list, tuple)):
            values = (values,)
        for value in values:
            yield key, value

 def update(self, iterable):
     for name, value in mapping_iterator(iterable):
         self.set(name, value)

 def hmset(self, key, iterable):
     args = []
     [args.extend(pair) for pair in mapping_iterator(iterable)]
     return self.execute('hmset', key, *args)