def encode_params(self, data=None, **kwargs):
"""
Build the body for a text/plain request.
Will successfully encode parameters when passed as a dict or a list of
2-tuples. Order is retained if data is a list of 2-tuples but arbitrary
if parameters are supplied as a dict.
"""
charset = kwargs.get("charset", self.charset)
collection_format = kwargs.get("collection_format",
self.collection_format)
output_str = kwargs.get("output_str", self.output_str)
if data is None:
return b"", self.get_content_type(charset)
elif isinstance(data, bytes):
return data, self.get_content_type(charset)
elif isinstance(data, str):
return self._encode(data, charset), self.get_content_type(charset)
elif hasattr(data, 'read'):
return data, self.get_content_type(charset)
elif collection_format == 'multi' and hasattr(data, '__iter__'):
result = []
for k, vs in to_key_val_list(data):
if isinstance(vs, basestring) or not hasattr(vs, '__iter__'):
vs = [vs]
for v in vs:
result.append(b"=".join([
self._encode(k, charset),
self._encode(v, charset, output_str)
]))
return b'\n'.join(result), self.get_content_type(charset)
elif collection_format == 'plain' and hasattr(data, '__iter__'):
results = []
for k, vs in to_key_val_dict(data).items():
results.append(b"=".join([
self._encode(k, charset),
self._encode(vs, charset, output_str)
]))
return b'\n'.join(results), self.get_content_type(charset)
elif hasattr(data, '__iter__'):
results = []
for k, vs in to_key_val_dict(data).items():
if isinstance(vs, list):
v = self.COLLECTION_SEPARATORS[collection_format].join(
e for e in vs)
key = k + '[]'
else:
v = vs
key = k
results.append(b"=".join([
self._encode(key, charset),
self._encode(v, charset, output_str)
]))
return b"\n".join(results), self.get_content_type(charset)
else:
return str(data).encode(charset) if charset else str(data),\
self.get_content_type(charset)
def log_print_request(method, url, query_params=None, headers=None, body=None):
"""
Log an HTTP request data in a user-friendly representation.
:param method: HTTP method
:param url: URL
:param query_params: Query parameters in the URL
:param headers: Headers (dict)
:param body: Body (raw body, string)
:return: None
"""
log_msg = '\n>>>>>>>>>>>>>>>>>>>>> Request >>>>>>>>>>>>>>>>>>> \n'
log_msg += '\t> Method: %s\n' % method
log_msg += '\t> Url: %s\n' % url
if query_params is not None:
log_msg += '\t> Query params: {}\n'.format(str(query_params))
if headers is not None:
log_msg += '\t> Headers:\n{}\n'.format(
json.dumps(dict(headers), sort_keys=True, indent=4))
if body is not None:
try:
log_msg += '\t> Payload sent:\n{}\n'.format(
_get_pretty_body(headers, body))
except:
log_msg += "\t> Payload could't be formatted"
logger.debug(log_msg)
def encode_params(self, data=None, **kwargs):
"""
Build the body for a text/plain request.
Will successfully encode parameters when passed as a dict or a list of
2-tuples. Order is retained if data is a list of 2-tuples but arbitrary
if parameters are supplied as a dict.
"""
charset = kwargs.get("charset", self.charset)
collection_format = kwargs.get("collection_format", self.collection_format)
output_str = kwargs.get("output_str", self.output_str)
if data is None:
return "", self.get_content_type(charset)
elif isinstance(data, (str, bytes)):
return data, self.get_content_type(charset)
elif hasattr(data, 'read'):
return data, self.get_content_type(charset)
elif collection_format == 'multi' and hasattr(data, '__iter__'):
result = []
for k, vs in to_key_val_list(data):
if isinstance(vs, basestring) or not hasattr(vs, '__iter__'):
vs = [vs]
for v in vs:
result.append(b"=".join([self._encode(k, charset), self._encode(v, charset, output_str)]))
return b'\n'.join(result), self.get_content_type(charset)
elif collection_format == 'plain' and hasattr(data, '__iter__'):
results = []
for k, vs in to_key_val_dict(data).items():
results.append(b"=".join([self._encode(k, charset), self._encode(vs, charset, output_str)]))
return b'\n'.join(results), self.get_content_type(charset)
elif hasattr(data, '__iter__'):
results = []
for k, vs in to_key_val_dict(data).items():
if isinstance(vs, list):
v = self.COLLECTION_SEPARATORS[collection_format].join(e for e in vs)
key = k + '[]'
else:
v = vs
key = k
results.append(b"=".join([self._encode(key, charset), self._encode(v, charset, output_str)]))
return b"\n".join(results), self.get_content_type(charset)
else:
return str(data).encode(charset) if charset else str(data), self.get_content_type(charset)
def get_primitive_as_string(strings_dict, value):
if isinstance(value, bool) and value:
return strings_dict["true"]
elif isinstance(value, bool):
return strings_dict["false"]
elif value is None:
return strings_dict["null"]
else:
return str(value)
def get_primitive_as_csharp_string(value):
if isinstance(value, bool) and value:
return "True"
elif isinstance(value, bool):
return "False"
elif value is None:
return "Null"
else:
return str(value)
def get_primitive_as_java_string(value):
if isinstance(value, bool) and value:
return "true"
elif isinstance(value, bool):
return "false"
elif value is None:
return "null"
else:
return str(value)
def as_http_request_context(self):
scheme, domain_or_ip, port, path, _ = urlsplit(self.url)
host = scheme + "://" + domain_or_ip
if port:
host += ":" + str(port)
body_params, renderer = self.post_data
return HttpRequestContext(
host=host, method=self.method, url_path=path, query_params=self.query_string, headers=self.headers,
renderer=renderer, body_params=body_params
)
def encode_params(self, data=None, **kwargs):
"""
Build the body for a application/json request.
"""
if isinstance(data, basestring):
raise ValueError("Data must not be a string.")
if data is None:
return b"", self.content_type
fields = to_key_val_dict(data or "")
try:
body = json.dumps(fields)
except:
body = json.dumps(fields, encoding='latin-1')
return str(body).encode(), self.content_type
def log_print_response(status_code, response, headers=None):
"""
Log an HTTP response data in a user-friendly representation.
:param status_code: HTTP Status Code
:param response: Raw response content (string)
:param headers: Headers in the response (dict)
:return: None
"""
log_msg = '\n<<<<<<<<<<<<<<<<<<<<<< Response <<<<<<<<<<<<<<<<<<\n'
log_msg += '\t< Response code: {}\n'.format(str(status_code))
if headers is not None:
log_msg += '\t< Headers:\n{}\n'.format(
json.dumps(dict(headers), sort_keys=True, indent=4))
try:
log_msg += '\t< Payload received:\n{}'.format(
_get_pretty_body(headers, response))
except:
log_msg += '\t< Payload received:\n{}'.format(response)
logger.debug(log_msg)
def generate_url(scheme=None, host=None, port=None, path=None, query=None):
"""
Generate URI from parameters.
:param str scheme:
:param str host:
:param int port:
:param str path:
:param dict query:
:return:
"""
url = ""
if scheme is not None:
url += "%s://" % scheme
if host is not None:
url += host
if port is not None:
url += ":%s" % str(port)
if path is not None:
url += ensure_url_path_starts_with_slash(path)
if query is not None:
url += "?%s" % (urlencode(query))
return url
