def run_query(self, payload):
s = Session()
url = self.base_url
querystring = {
"output": "json",
"toolid": self.toolId,
"trace": "namespaces"
}
url = str(url) + "?" + \
urllib.parse.urlencode(querystring)
req = Request("POST", url, data=payload)
headers = {'Content-Type': "application/sparql-query"}
req.headers = headers
auth = self.get_hmac(req, url)
#print(auth)
headers = {
'Authorization': auth,
'Content-Type': "application/sparql-query"
}
req.headers = headers
prepared = req.prepare()
response = s.send(prepared)
if response.status_code == 200:
return response.json()
else:
raise Exception(
"Query failed to run by returning code of {}. {}".format(
response.status_code, response.text))
def test_http_response():
request = Request()
request.headers = {
'Authorization': 'token',
'header1': 'value1',
'header2': 'value2'
}
request.method = 'GET'
request.url = 'http://url.com'
request.body = None
response = HttpResponse()
response.status_code = 400
response.request = request
assert response.to_curl(request) == (
"curl -X 'GET' -v -H 'Authorization: <...>' "
"-H 'header1: value1' -H 'header2: value2' "
"'http://url.com'")
assert sorted(
response.hide_and_serialize_sensitive_headers(
request.headers).split('\n')) == [
'', 'Authorization: <...>', 'header1: value1',
'header2: value2'
]
with pytest.raises(ExtendedHTTPError) as exc_info:
# ensure error is raised
response.raise_for_status()
assert exc_info.value.response == response
assert exc_info.value.request == request
def _send_request(method, url, headers, body):
"""发送请求"""
s = Session()
prepped = Request(method, url).prepare()
prepped.headers = headers
prepped.body = body
r = s.send(prepped)
return r.status_code, r.text
def build_request(self, smarty_request):
request = Request(url=smarty_request.url_prefix, params=smarty_request.parameters)
request.headers = self.headers
if smarty_request.payload:
request.data = smarty_request.payload
request.method = 'POST'
else:
request.method = 'GET'
return request
def _inject_headers(self, request: requests.Request) -> requests.Request:
if request.headers is None:
request.headers = dict()
if 'Host' not in request.headers:
url = urlparse(request.url)
request.headers['Host'] = url.hostname
if 'Referer' not in request.headers:
if self.previous_url is not None:
request.headers['Referer'] = self.previous_url
else:
request.headers['Referer'] = request.url
return request
def sendHttpRequest(_args):
s = Session()
url = makeURL(_args)
req = Request(_args.get("method"), url)
if (_args.get("headers") is not None) : req.headers = _args.get("headers")
if (_args.get("auth") is not None) : req.auth = HTTPBasicAuth(_args.get("auth")[0], _args.get("auth")[1])
if (_args.get("params") is not None) : req.params = _args.get("params")
if (_args.get("cookies") is not None) : req.cookies = _args.get("cookies")
if (_args.get("data") is not None) : req.data = _args.get("data")
prepped = req.prepare()
if (_args.get("body") is not None) : prepped.body = _args.get("body")
# do something with prepped.body
# do something with prepped.headers
resp = s.send(prepped,timeout=_args.get("timeout"), proxies=_args.get("proxies"))
return resp
def sendHttpRequest(_args):
s = Session()
url = makeURL(_args)
req = Request(_args.get("method"), url)
if (_args.get("headers") is not None): req.headers = _args.get("headers")
if (_args.get("auth") is not None):
req.auth = HTTPBasicAuth(_args.get("auth")[0], _args.get("auth")[1])
if (_args.get("params") is not None): req.params = _args.get("params")
if (_args.get("cookies") is not None): req.cookies = _args.get("cookies")
if (_args.get("data") is not None): req.data = _args.get("data")
prepped = req.prepare()
if (_args.get("body") is not None): prepped.body = _args.get("body")
# do something with prepped.body
# do something with prepped.headers
resp = s.send(prepped,
timeout=_args.get("timeout"),
proxies=_args.get("proxies"))
return resp
def main():
file = None
with open(r'E:\MyDesktop\default_avatar_female_50.gif', 'rb') as f:
file = f.read()
fileMd5 = hashlib.md5(file).hexdigest()
date = httpdate_rfc1123()
uri = '/image-upyun-9527/3.webp'
method = 'PUT'
headers = {
'Authorization': sign(key, secret, method, uri, date),
'Date': date,
'Content-Length': str(len(file)),
'x-gmkerl-thumb': '/format/webp/quality/85/progressive/true/strip/true'
}
print(headers)
from requests import Session, Request
s = Session()
prepped = Request(method, 'http://v0.api.upyun.com' + uri).prepare()
prepped.headers = headers
prepped.body = file
r = s.send(prepped)
print(r.status_code, r.text)
def setUp(self):
# mock request object
request = Request()
request.method = 'GET'
request.url = 'http://example.com/'
request.headers = {}
request.params = {}
request.data = {}
request.params_and_data = {}
self.request = request
# mock consumer object
consumer = Mock()
consumer.key = '123'
consumer.secret = '456'
self.consumer = consumer
# mock token object
token = Mock()
token.key = '321'
token.secret = '456'
self.token = token
def inference_wrapper(self, request, model_key, parameters, callback):
try:
result = {}
subrequest = Request()
subrequest.headers = request.headers
subrequest.data = parameters
result = self.magaclient.inference(subrequest, model_key)
if not result['resultId']:
raise Exception(result['errorMessage'])
resultId = result['resultId']
while True:
result = self.magaclient.get_result(subrequest, resultId)
if result['status'] == 'READY':
break
except Exception as e:
result['errorMessage'] = str(e)
if callback is not None:
callback(request, model_key, result)
return STATUS_SUCCESS, ''
def process_request(req):
# api_stream = open(file, 'r')
# api = yaml.load_all(api_stream)
# for reqs in api:
# for req in reqs:
preq = Request()
pr("Testing: {0}, which is a {1} request".format(req['request']['name'],
req['request']['method']))
static_headers = process_static_headers(req['request']['headers'])
var_headers = process_var_headers(req['request']['headers'])
all_headers = dict(static_headers.items() + var_headers.items())
#print all_headers
if req['request']['params']:
preq.params = req['request']['params']
preq.headers = all_headers
preq.method = req['request']['method']
preq.url = req['request']['uri']
if 'body' in req['request'].keys():
if req['request']['body']['type'] == 'post-vars':
preq.data = req['request']['body']['value']
elif req['request']['body']['type'] == 'json':
preq.json = req['request']['body']['value']
elif req['request']['body']['type'] == 'file':
filepath = req['request']['body']['value']['filepath']
preq.files = {filepath: open(filepath, 'rb')}
else:
raise Exception('Payload type unsupported')
sys.exit(1)
rsess = Session()
prepped = preq.prepare()
# for item in req['request']['exclude_headers']:
# if item in prepped.headers.keys():
# del prepped.headers[item]
response = rsess.send(prepped, verify=cert_bundle, proxies=proxies)
return response
def create_request_object(self):
"""
Functionality:
We attempt to create the Request() object and apply the correct data to it.
We also run the validation to make sure that all the data we are applying is correct
"""
request_object = Request()
# Run internal validation to first determine if the body schema and type is correct
self.validate_body_schematic()
self.validate_body_type()
# Method Apply and validation
self.validate_method()
request_object.method = self._request_model.method
# URL Apply and validation
self.validate_endpoint()
request_object.url = self._request_model.endpoint
# Query Apply and validation
self.validate_query_param()
request_object.params = self._request_model.query
# Headers Apply and validation
self.validate_headers()
request_object.headers = self._request_model.headers
# Body Apply and validation
self.validate_body()
request_object.data = self._request_model.body
# Authentication Apply and validation
self.validate_auth()
request_object.auth_data = self._request_model.auth_data
request_object.auth_type = self._request_model.auth_type
return request_object
def lambda_handler(event, context):
pp.pprint(event)
aws_sns_topic_arn = event['sns']
url = event['url']
method = event.get('method', 'GET')
headers = event.get('headers')
body = event.get('body')
session = Session()
request = Request(method, url).prepare()
if headers is not None:
request.headers = headers
if body is not None:
request.body = body
response = session.send(request)
if response.status_code == 200:
content = response.text
pp.pprint(content)
publish_command_to_sns(aws_sns_topic_arn, content)
else:
pp.pprint(response)
def setUp(self):
# mock request object
request = Request()
request.method = 'GET'
request.url = 'http://example.com/'
request.headers = {}
request.params = {}
request.data = {}
request.params_and_data = {}
self.request = request
# mock response object
response = Mock()
response.content = 'access_token=321'
response.headers = {'content-type': 'text/html; charset=UTF-8'}
response.ok = True
response.status_code = 200
response.raise_for_status = lambda: None
self.response = response
# mock raise_for_status with an error
def raise_for_status():
raise Exception('Response not OK!')
self.raise_for_status = raise_for_status
# mock consumer object
consumer = Mock()
consumer.key = '123'
consumer.secret = '456'
self.consumer = consumer
# mock token object
token = Mock()
token.key = '321'
token.secret = '456'
self.token = token
def main():
file = None
with open(
r'C:\Users\Steven Fang\Documents\Tencent Files\1075004549\Image\Group\{SS]6F@`F[F6WY~[%{F`C_N.gif',
'rb') as f:
file = f.read()
fileMd5 = hashlib.md5(file).hexdigest()
date = httpdate_rfc1123()
uri = '/image-upyun-9527/3.webp'
method = 'PUT'
headers = {
'Authorization': sign(key, secret, method, uri, date),
'Date': date,
'Content-Length': str(len(file)),
'x-gmkerl-thumb': '/format/webp/quality/85/progressive/true/strip/true'
}
print(headers)
from requests import Session, Request
s = Session()
prepped = Request(method, 'http://v0.api.upyun.com' + uri).prepare()
prepped.headers = headers
prepped.body = file
r = s.send(prepped)
print(r.status_code, r.text)
def req(endpoint=None, headers=None):
"""Prepares requests.PreparedRequest objects from passed args.
Argument validation is featured in order to minimize the risk of invalid
API calls. While both arguments default to None calling
NetCloudAPI.req with empty arguments will raise an error.
Args:
endpoint (Endpoint): Any one of the NetCloudAPI.endpoints subclasses
headers (dict): The headers dictionary provided by Cradlepoint ECM.
Returns:
A requests.PreparedRequest object if both arguments contain the required elements
Raises:
ValueError: If attributes are None
ValueError: If header 'Content-Type' is not 'application/json'
TypeError: If other invalid input is detected.
"""
ep_req = Request()
ep_attr = [
"uri", "method", "paging", "params", "filters", "fields", "expands",
"body"
]
err = []
ep_params = {}
if endpoint is None or headers is None:
raise ValueError(
"""args are required; endpoint and headers must be passed""")
elif not Endpoint.__valchk__(
headers, REQUIRED_HEADERS, required=REQUIRED_HEADERS):
raise ValueError("""Required header keys are missing. See docs""")
elif isinstance(endpoint, Endpoint) and Endpoint.__valchk__(
headers, REQUIRED_HEADERS, required=REQUIRED_HEADERS):
if headers["Content-Type"] == "application/json":
ep_req.headers = headers
for i in range(len(ep_attr)):
if ep_attr[i] == "uri":
if endpoint.uri is not None:
ep_req.url = BASE_URL + endpoint.uri
else:
err.append(ep_attr[i])
elif ep_attr[i] == "method":
if endpoint.method is not None:
ep_req.method = endpoint.method
else:
err.append(ep_attr[i])
elif ep_attr[i] == "paging":
if endpoint.paging is not None:
ep_params.update(endpoint.paging)
elif ep_attr[i] == "params":
if endpoint.params is not None:
ep_params.update(endpoint.params)
elif ep_attr[i] == "filters":
if endpoint.filters is not None:
for k, v in endpoint.filters.items():
if isinstance(v, list):
ep_params.update(
{k: ",".join([str(j) for j in v])})
else:
ep_params.update({k: v})
elif ep_attr[i] == "fields":
if endpoint.fields is not None:
ep_params.update({
"fields":
",".join([str(j) for j in endpoint.fields])
})
elif ep_attr[i] == "expands":
if endpoint.expands is not None:
ep_params.update({
"expand":
",".join([str(j) for j in endpoint.expands])
})
elif ep_attr[i] == "body":
if endpoint.body is not None:
ep_req.json = endpoint.body
if len(err) > 0:
raise ValueError("Required attributes ({}) are empty".format(
",".join(err)))
else:
ep_req.params = ep_params
else:
raise ValueError("Content-Type must be 'application/json'")
else:
raise TypeError("""Invalid input. See docs.""")
return ep_req.prepare()
