class Adapter:
def __init__(self, input):
self.id = input.get('id', '1')
self.bridge = Bridge()
self.create_request()
def create_request(self):
try:
data = SpaceX().get_launch_info()
self.result_success(data)
except Exception as e:
self.result_error(e)
finally:
self.bridge.close()
def result_success(self, data):
self.result = {
'jobRunID': self.id,
'data': data,
'result': data["launch_time"],
'statusCode': 200,
}
def result_error(self, error):
self.result = {
'jobRunID': self.id,
'status': 'errored',
'error': f'There was an error: {error}',
'statusCode': 500,
}
class Adapter:
base_url = 'https://hcaptcha.com/siteverify'
token = None
secret_key = None
def __init__(self, input, secret_key: str = None):
self.id = input.get('id', '1')
self.secret_key = secret_key
self.request_data = input.get('data')
if self.validate_request_data() and self.secret_key:
self.bridge = Bridge()
self.set_params()
self.create_request()
else:
self.result_error(
'No data or API secret key provided for the adapter')
def validate_request_data(self):
if self.request_data is None:
return False
if self.request_data == {}:
return False
return True
def set_params(self):
self.token = self.request_data.get('token')
def create_request(self):
try:
data = f'response={self.token}&secret={self.secret_key}'
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
response = self.bridge.post_request(self.base_url,
data=data,
headers=headers)
data = response.json()
print('Response: ', data)
self.result = data['success']
data['result'] = self.result
self.result_success(data)
except Exception as e:
self.result_error(e)
finally:
self.bridge.close()
def result_success(self, data):
self.result = {
'jobRunID': self.id,
'data': data,
'result': self.result,
'statusCode': 200,
}
def result_error(self, error):
self.result = {
'jobRunID': self.id,
'status': 'errored',
'error': f'There was an error: {error}',
'statusCode': 500,
}
class Adapter:
base_url = 'https://sandbox.swift.com/swift-apitracker/v4/payments' # '/{uetr}/status' needs to be appended
from_params = ['ID', 'UETR', 'transaction']
action_params = ['cancellation', 'status', 'transactions']
oauth_token = ['oauth', 'token', 'oauth_token']
def __init__(self, input):
self.id = input.get('id', '1')
self.request_data = input.get('data')
self.result_json = "N/A"
if self.validate_request_data():
self.bridge = Bridge()
self.set_params()
self.create_request()
else:
self.result_error('No data provided')
def validate_request_data(self):
if self.request_data is None:
return False
if self.request_data == {}:
return False
return True
def set_params(self):
for param in self.from_params:
self.from_param = self.request_data.get(param)
if self.from_param is not None:
break
for param in self.action_params:
self.to_param = self.request_data.get(param)
if self.to_param is not None:
break
for param in self.oauth_token:
self.oauth = self.request_data.get(param)
if self.oauth is not None:
break
def create_request(self):
try:
headers = {"Authorization": "Basic "+self.oauth}
self.base_url += "/"+self.from_param+"/"+self.to_param
response = self.bridge.request(self.base_url, headers)
data = response.json()
self.result_json = data
switcher = {
"transactions": "transaction_status",
"cancellation": "cancellation_reason_information",
"status": "transaction_status"
}
print("switch case: "+switcher.get(self.to_param, ""))
self.result = data[switcher.get(self.to_param, "")]
data['result'] = self.result
self.result_success(data)
except Exception as e:
self.result_error(e)
finally:
self.bridge.close()
def result_success(self, data):
self.result = {
'jobRunID': self.id,
'data': data,
'result': self.result,
'statusCode': 200,
}
def result_error(self, error):
self.result = {
'jobRunID': self.id,
'status': 'errored',
'error': f'There was an error: {error}',
'data': self.result_json,
'statusCode': 500,
}
class Adapter:
base_url = 'https://min-api.cryptocompare.com/data/price'
from_params = ['base', 'from', 'coin']
to_params = ['quote', 'to', 'market']
def __init__(self, input):
self.id = input.get('id', '1')
self.request_data = input.get('data')
if self.validate_request_data():
self.bridge = Bridge()
self.set_params()
self.create_request()
else:
self.result_error('No data provided')
def validate_request_data(self):
if self.request_data is None:
return False
if self.request_data == {}:
return False
return True
def set_params(self):
for param in self.from_params:
self.from_param = self.request_data.get(param)
if self.from_param is not None:
break
for param in self.to_params:
self.to_param = self.request_data.get(param)
if self.to_param is not None:
break
def create_request(self):
try:
params = {
'fsym': self.from_param,
'tsyms': self.to_param,
}
response = self.bridge.request(self.base_url, params)
data = response.json()
self.result = data[self.to_param]
data['result'] = self.result
self.result_success(data)
except Exception as e:
self.result_error(e)
finally:
self.bridge.close()
def result_success(self, data):
self.result = {
'jobRunID': self.id,
'data': data,
'result': self.result,
'statusCode': 200,
}
def result_error(self, error):
self.result = {
'jobRunID': self.id,
'status': 'errored',
'error': f'There was an error: {error}',
'statusCode': 500,
}
class Adapter:
def __init__(self, input):
self.base_url = "https://api.openai.com/v1/engines/davinci/completions"
self.id = input.get('id', '1')
self.request_data = input.get('data')
if self.validate_request_data():
self.bridge = Bridge()
self.set_params()
self.create_request()
else:
self.result_error('No data provided')
def validate_request_data(self):
if self.request_data is None:
return False
if self.request_data == {}:
return False
return True
def set_params(self):
self.prompt = self.request_data.get("prompt")
def create_request(self):
print(pre_prompt + self.prompt)
try:
headers={
"Authorization": f"Bearer {config.API_KEY}",
"Content-Type": 'application/json'
}
json={
"prompt": pre_prompt + self.prompt,
"max_tokens": 40,
"temperature": 0.5,
"top_p": 1,
"n": 1,
"stop": ["#"]
}
response = self.bridge.request(self.base_url, json=json, headers=headers)
data = response.json()['choices'][0]['text']
if ':' in data:
data = data.split(':')[1][1:]
hex_data = binascii.hexlify(data.encode('utf8'))
bytes_data = '0x' + str(hex_data)[2:-1]
self.result = bytes_data
self.result_success(bytes_data)
except Exception as e:
self.result_error(e)
finally:
self.bridge.close()
def result_success(self, data):
self.result = {
'jobRunID': self.id,
'data': data,
'result': self.result,
'statusCode': 200,
}
def result_error(self, error):
self.result = {
'jobRunID': self.id,
'status': 'errored',
'error': f'There was an error: {error}',
'statusCode': 500,
}
class Adapter:
base_url = 'http://kibana.log4analytics.com:9080/1.0/identifiers/'
from_params = ['DID_userid']
to_params = ['quote', 'to', 'market']
def __init__(self, input):
self.id = input.get('id', '1')
self.request_data = input.get('data')
if self.validate_request_data():
self.bridge = Bridge()
self.set_params()
self.create_request()
else:
self.result_error('No data provided')
def validate_request_data(self):
if self.request_data is None:
return False
if self.request_data == {}:
return False
return True
def set_params(self):
for param in self.from_params:
self.from_param = self.request_data.get(param)
if self.from_param is not None:
break
for param in self.to_params:
self.to_param = self.request_data.get(param)
if self.to_param is not None:
break
def create_request(self):
try:
params = {
'fsym': self.from_param,
'tsyms': self.to_param,
}
print(self.from_param)
self.base_url = self.base_url + self.from_param
print(self.base_url)
response = self.bridge.request(self.base_url, params)
data = response.json()
self.result = data['didDocument']['id']
data['result'] = self.result
self.result_success(data)
except Exception as e:
self.result_error(e)
finally:
self.bridge.close()
def result_success(self, data):
self.result = {
'jobRunID': self.id,
'data': data,
'result': self.result,
'statusCode': 200,
}
def result_error(self, error):
self.result = {
'jobRunID': self.id,
'status': 'errored',
'error': f'There was an error: {error}',
'statusCode': 500,
}
class Adapter:
base_url = FRAXSES_API_GATEWAY
def __init__(self, input):
self.id = input.get('id', '1')
self.request_data = input.get('data')
if self.validate_request_data():
self.bridge = Bridge()
self.set_params()
self.create_request()
else:
self.result_error('No data provided')
def validate_request_data(self):
if self.request_data is None:
return False
if self.request_data == {}:
return False
if self.request_data.get('action') is None:
return False
return True
def set_params(self):
self.param = {}
self.action = self.request_data.get('action')
self.params = {
k: v
for k, v in self.request_data.items() if k != 'action'
}
for key, value in self.params.items():
self.param[value] = self.request_data.get(key)
if self.param is None:
break
def create_request(self):
try:
token = usr_aut(gateway=FRAXSES_API_GATEWAY,
username=FRAXSES_USERNAME,
password=FRAXSES_PASSWORD)
logging.info('Token success, token is ' + str(token))
if token:
token = token['records'][0]['tok']
params = {
"token": token,
"action": self.action,
"parameters": self.params
}
response = self.bridge.request(self.base_url, params)
logging.info(params)
data = response.json()
logging.info(data)
self.result = data['result'][0]['serviceresult']['id']
self.result_success(
data=data['result'][0]['serviceresult']['response'],
job_run_id=data['result'][0]['serviceresult']['id'])
else:
self.result_error(
'Fraxses gateway failed to authenticate, token is ' +
str(token))
except Exception as e:
self.result_error(e)
finally:
self.bridge.close()
def result_success(self, data, job_run_id):
self.result = {
'jobRunID': self.id,
'data': data,
'result': self.result,
'statusCode': 200,
}
def result_error(self, error):
self.result = {
'jobRunID': 1,
'status': 'errored',
'error': f'There was an error: {error}',
'statusCode': 500,
}
class Adapter:
id_params = ['id', 'nft', '_id']
def __init__(self, input, image_checker, image_manager):
self.image_cheker = image_checker
self.image_manager = image_manager
self.id = input.get('id', '1')
self.result = "" #kostil
self.request_data = input.get('data')
if self.validate_request_data():
self.bridge = Bridge()
self.set_params()
self.create_request()
else:
self.result_error('No data provided')
def validate_request_data(self):
if self.request_data is None:
return False
if self.request_data == {}:
return False
return True
def set_params(self):
for param in self.id_params:
self.id_params = self.request_data.get(param)
if self.id_params is not None:
break
def create_request(self):
try:
#params = {
# 'fsym': self.from_param,
# 'tsyms': self.to_param,
#}
#response = self.bridge.request(self.base_url, params)
nftID = int(self.id_params)
contract = get_contract()
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
data_ipfs_url = contract.functions.uri(nftID).call()
task = asyncio.gather(
download_image_data(data_ipfs_url, nftID, save_to_disk=False))
loop.run_until_complete(task)
task_result = task.result()
image_string, description = task_result[0]
nparr = np.fromstring(image_string, np.uint8)
img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
img = Image.fromarray(img)
self.image_manager.register_new_images()
scores, descriptions = self.image_cheker.find_most_simular_images(
img)
if int(descriptions[0]) == nftID:
score = scores[1]
else:
score = scores[0]
score = int(score * 100)
#data = response.json()
#self.result = data[self.to_param]
data = {
'score': score,
'detailed information': {
'scores': [*scores],
'descriptions': [*descriptions]
}
}
self.result_success(data)
except Exception as e:
self.result_error(e)
finally:
self.bridge.close()
def result_success(self, data):
self.result = {
'jobRunID': self.id,
'data': data,
'result': self.result,
'statusCode': 200,
}
def result_error(self, error):
self.result = {
'jobRunID': self.id,
'status': 'errored',
'error': f'There was an error: {error}',
'statusCode': 500,
}
class Adapter:
base_url = 'https://api.twitter.com/1.1/search/tweets.json'
def __init__(self, input):
self.id = input.get('id', '1')
self.request_data = input.get('data')
if self.validate_request_data():
self.bridge = Bridge()
self.hashtag = self.request_data.get('hashtag', '')
self.username = self.request_data.get('username', '')
self.create_request()
else:
self.result_error('No data provided')
def validate_request_data(self):
if self.request_data is None:
return False
if self.request_data == {}:
return False
return True
def create_request(self):
try:
if not self.hashtag:
raise Exception('No hashtag provided')
params = {
'q': '#' + self.hashtag,
}
headers = {
"Authorization": "Bearer " + os.environ.get('BEARER_TOKEN')
}
response = self.bridge.request(self.base_url,
params,
headers=headers)
data = response.json()
self.result = ''
if self.username:
for status in data['statuses']:
if status['user']['screen_name'] == self.username:
self.result = self.username
break
elif data['statuses']:
self.result = data['statuses'][0]['user']['screen_name']
data['result'] = self.result
self.result_success(data)
except Exception as e:
self.result_error(e)
finally:
self.bridge.close()
def result_success(self, data):
self.result = {
'jobRunID': self.id,
'data': data,
'result': self.result,
'statusCode': 200,
}
def result_error(self, error):
self.result = {
'jobRunID': self.id,
'status': 'errored',
'error': f'There was an error: {error}',
'statusCode': 500,
}
