def get_push_api(self):
root_url = self.config.get("root_url")
timeout = self.config.get('timeout')
api = API(api_root_url=root_url, timeout=timeout, append_slash=False)
api.add_resource(resource_name='push',
resource_class=PushServiceResource)
return api
def __init__(self):
self.api = API(api_root_url=API_ROOT_URL,
params={},
headers={},
timeout=2,
append_slash=False,
json_encode_body=True)
def __init__(self, wallet_state, keosd_dir, unlockTimeout=120):
self.wallet_state = wallet_state
self.wallet_dir = join(os.path.expanduser('~'), 'telos-wallet')
self.keosd_dir = keosd_dir
self.unlockTimeout = unlockTimeout
self.api = API(
api_root_url='http://127.0.0.1:8999/v1/wallet',
params={},
headers={
'Accept': 'application/json',
'Content-Type': 'application/json'
},
timeout=2,
append_slash=False,
json_encode_body=True,
)
self.api.add_resource(resource_name='wallet',
resource_class=WalletResource)
self.pid = -1
if not self.is_running():
print('Creating new instance of tkeosd')
self.start_wallet()
if not self.wallet_exists('default'):
print('Default wallet not found, creating new default wallet')
self.create('default')
def initialize(self):
"""Initialization; inject our calendar names"""
self.calendars = []
# Iterate through the whole set of calendars
if 'token' in self.config['secret']:
self.token = self.config['secret']['token']
elif 'HASSIO_TOKEN' in environ:
self.token = environ['HASSIO_TOKEN']
if 'url' in self.config['secret']:
self.url = self.config['secret']['url']
elif self.token is not None and 'HASSIO_TOKEN' in environ:
self.url = 'http://hassio/homeassistant/api'
self.api = API(api_root_url = self.url,
params = {},
headers={ 'Authorization': "Bearer {}".format(self.token),
'Content-Type': 'application/json' },
timeout=30,
append_slash=False,
json_encode_body=True
)
self.api.add_resource(resource_name='calendars', resource_class=CalendarResource)
self._get_calendars()
self.inject_calendar_names()
def test_api_headers():
api = API(api_root_url="http://localhost:0/api/")
assert api.headers == {}
json_api = API(api_root_url="http://localhost:0/api/",
json_encode_body=True)
assert json_api.headers == {"Content-Type": "application/json"}
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--object", help="object")
parser.add_argument("--image", help="image file")
parser.add_argument("--path", help="image path")
args = parser.parse_args()
# Metadata.objects.create(
# image_name = args.i,
# image_path = args.p,
# object = args.object
# )
api = API(
api_root_url='http://localhost:8000',
json_encode_body=True,
append_slash=True,
)
print(args.image)
print(args.path)
print(args.object)
api.add_resource(resource_name='pipeline')
api.pipeline.create(
body = {
'image_name': args.image,
'image_path': args.path,
'object': args.object
}
)
def call_api_sharpe_ratio(tickers):
api = API(api_root_url='http://128.199.65.170:5000', timeout=60)
api.add_resource(resource_name='entropy2019')
api.entropy2019.actions
response = api.entropy2019.list(
body=None,
params={'tickers': ','.join([ticker.lower() for ticker in tickers])},
headers={})
return response.body['sharpe_ratio']
def __init__(self):
self.api = API(
api_root_url=APIROOTURL,
params={},
headers={'Cookie': TWISTEDCOOKIES},
timeout=2,
append_slash=False,
json_encode_body=True,
)
def create_api():
api = API(api_root_url='http://127.0.0.1:8000/api/',
params={},
headers={},
timeout=2,
append_slash=True,
json_encode_body=True)
api.add_resource(resource_name='product')
return api
def __init__(self, api_root_url, **kwargs):
self.email_api = API(api_root_url=api_root_url,
headers={"Content-Type": "application/json"},
json_encode_body=True,
**kwargs)
self.email_api.add_resource(resource_name="message",
resource_class=MessageResource)
self.email_api.add_resource(resource_name="template",
resource_class=TemplateResource)
self.email_api.add_resource(resource_name="unsubscribe",
resource_class=UnsubscribeResource)
def __init__(self, host, personal_token=None, oauth_token=None):
super().__init__(host)
self.api = API(api_root_url=self.host+'api/v4',
headers={'Private-Token':personal_token} if personal_token is not None else
{'Authorization':'Bearer '+oauth_token} if oauth_token is not None else None,
timeout=60,
json_encode_body=True,
append_slash=False)
self.api.add_resource(resource_name='projects')
self.api.add_resource(resource_name='hooks', resource_class=HookRessource)
self.api.add_resource(resource_name='groups', resource_class=GroupRessource)
def __init__(self, host, api_key, personal_token):
super().__init__(host)
self.api = API(api_root_url=self.host + 'api/v1',
params={'token': api_key},
headers={'Content-Type':'application/json'},
timeout=60,
json_encode_body=True,
append_slash=False)
self.personal_token = personal_token
self.api.add_resource(resource_name='repos', resource_class=ReposRessource)
self.api.add_resource(resource_name='orgs', resource_class=OrgRessource)
self.api.add_resource(resource_name='user', resource_class=MeRessource)
async def init_api(self, timeout=60):
await self.get_credentials()
self.api = API(api_root_url=self.api_url,
headers={
'X-Auth-Token': self.session.token,
'Accept': 'application/json',
'Content-Type': 'application/json'
},
json_encode_body=True,
timeout=timeout)
for resource in self.resources:
self.api.add_resource(resource_name=resource,
resource_class=AsyncResource)
def __init__(self, host):
self.api = API(
api_root_url='%s/v1/chain' % host,
params={},
headers={
'Accept': 'application/json',
'Content-Type': 'application/json'
},
timeout=2,
append_slash=False,
json_encode_body=True,
)
self.api.add_resource(resource_name='chain', resource_class=ChainResource)
def get(domain_name):
default_params = {}
rwhois_api = API(api_root_url=RwhoisRequest.api_url,
params=default_params,
json_encode_body=True)
rwhois_api.add_resource(resource_name='domain',
resource_class=WhoisResource)
rwhois_response = rwhois_api.domain.v1(domain_name,
body=None,
params={},
headers={})
return rwhois_response
def __init__(self, url, ssl_verify=True, token=None):
self.api_url = urljoin(url, "_api")
self.token = token
if self.token:
headers = {"Authorization": f"Token {self.token}"}
else:
headers = {}
self.faraday_api = API(api_root_url=self.api_url,
params={},
headers=headers,
timeout=DEFAULT_TIMEOUT,
append_slash=False,
json_encode_body=True,
ssl_verify=ssl_verify)
self._build_resources()
def __init__(self, root_url, email, password):
self.account = email
self.password = password
self.access_token = ''
self.login_point = -1
self.point = -1
self.chat_id = -1
self.logger = likeyoubot_logger.LYBLogger.getLogger()
self.token = ''
self.last_id = -1
self.rest = API(
api_root_url=root_url,
timeout=2000,
json_encode_body=True,
)
self.rest.add_resource(resource_name='api')
self.adjustTime = 32400
def _init_python_osdf_api(onap_ip):
api = API(
api_root_url="https://{}:30248/api/oof/v1/".format(onap_ip),
params={},
headers={
'Authorization': encode("test", "testpwd"),
'X-FromAppId': 'SCRIPT',
'Accept': 'application/json',
'Content-Type': 'application/json',
'X-TransactionId': str(uuid.uuid4()),
},
timeout=30,
append_slash=False,
json_encode_body=True # encode body as json
)
api.add_resource(resource_name='osdf', resource_class=OSDFApiResource)
return api
def translate(text, langin, langout, key, model):
# set default params
default_params = {'key': key, 'format': "text"}
# create api instance
translate_api = API(api_root_url='https://translation.googleapis.com',
params=default_params,
json_encode_body=True)
translate_api.add_resource(resource_name="translate",
resource_class=TranslateResource)
output = translate_api.translate.translate(params={
'source': langin,
'target': langout,
'q': text,
'model': model
}).body
return output['data']['translations'][0]['translatedText']
def __init__(self, api_url, access_token):
self.api = API(
api_root_url=api_url,
headers={
'Accept': 'application/json',
'Content-Type': 'application/json',
'Authorization': 'Bearer {}'.format(access_token),
},
timeout=10,
json_encode_body=True,
)
def __init__(self, org_url, api_key, api_type='api'):
self.api = API(
api_root_url='{}/{}/v1'.format(org_url, api_type),
headers={
'Accept': 'application/json',
'Content-Type': 'application/json',
'Authorization': 'SSWS {}'.format(api_key),
},
timeout=10,
json_encode_body=True,
)
def _init_python_appc_lcm_api(onap_ip):
api = API(
api_root_url="https://{}:30230/restconf/operations/".format(onap_ip),
params={},
headers={
'Authorization':
encode("admin", "Kp8bJ4SXszM0WXlhak3eHlcse2gAw84vaoGGmJvUy2U"),
'X-FromAppId':
'SCRIPT',
'Accept':
'application/json',
'Content-Type':
'application/json',
},
timeout=300,
append_slash=False,
json_encode_body=True # encode body as json
)
api.add_resource(resource_name='lcm', resource_class=APPCLcmApiResource)
return api
def _rest(self):
api = API(
api_root_url=self._root_url, # base api url
headers={ # default headers
"Content-Type": "application/json"
},
timeout=2, # default timeout in seconds
append_slash=True, # append slash to final url
json_encode_body=True, # encode body as json
)
for name, cls in self._api.items():
api.add_resource(resource_name=name, resource_class=cls)
_api = {}
for resource in api.get_resource_list():
res = getattr(api, resource)
_api[resource] = FrozenDict(
{act: getattr(res, act)
for act in res.actions})
return FrozenDict(_api)
def __init__(self,
address,
port=8080,
address2=None,
port2=8081,
logger=None):
self.logger = logger or logging.getLogger(__name__)
self.query_api = SimpleAPI(
api_root_url='http://{}:{}/api/v1/'.format(address,
port), # base api url
params={}, # default params
headers={}, # default headers
timeout=2, # default timeout in seconds
append_slash=False, # append slash to final url
json_encode_body=True, # encode body as json
)
self.sync_api = SimpleAPI(
api_root_url='http://{}:{}/api/v1/'.format(address2 or address,
port2),
params={},
headers={},
timeout=2,
append_slash=False,
json_encode_body=True,
)
self.query_api.add_resource(resource_name='actions',
resource_class=QueryApiActions)
self.sync_api.add_resource(resource_name='actions',
resource_class=SyncApiActions)
for action in QueryApiActions.actions:
setattr(self, action,
self._wrap_action(self.query_api.actions, action))
for action in SyncApiActions.actions:
setattr(self, action,
self._wrap_action(self.sync_api.actions, action))
setattr(self, 'all_actions', self.query_api.actions.actions)
setattr(self, 'all_sync_actions', self.sync_api.actions.actions)
def index(request):
if request.method == 'POST':
body_unicode = request.body.decode('utf-8')
body = json.loads(body_unicode)
Metadata.objects.get(image_name=body['image_name']).update(object=body)
api = API(
api_root_url='http://localhost:8000',
json_encode_body=True,
append_slash=True,
)
api.add_resource(resource_name='alphanumeric')
api.object.create(
body = {
'image_name': body['image_name'],
'image_path': body['image_path']
}
)
api.add_resource(resource_name='color')
api.object.create(
body = {
'image_name': body['image_name'],
'image_path': body['image_path']
}
)
return HttpResponse("Hello, world.")
def build_tele2_api():
tele2api = API(api_root_url='http://tele2-hackday-2017.herokuapp.com/api/',
params={},
headers={},
timeout=2,
append_slash=False,
json_encode_body=True)
tele2api.add_resource(resource_name='services', resource_class=Services)
tele2api.add_resource(resource_name='subscribers',
resource_class=Subscribers)
tele2api.add_resource(resource_name='tariffs', resource_class=Tariffs)
return tele2api
def list(request):
api = API(api_root_url='http://127.0.0.1:8005/api/',
params={},
headers={},
timeout=2,
append_slash=True,
json_encode_body=True)
api.add_resource(resource_name='product')
result = ''
try:
response = api.product.list(body=None, params={}, headers={})
for product in response.body['objects']:
product = Product(product)
print(product)
result += str(product) + '<br>'
except Exception as ex:
print(ex)
return HttpResponse('Produkty:<br>' + result)
def get_api_instance(token="", timeout=None):
headers = {
"Authorization": "Bearer {}".format(token),
"Content-Type": "application/json",
}
api_root_url = "https://sentry.io/api/0/"
api = API(
api_root_url=api_root_url,
headers=headers,
json_encode_body=True,
timeout=timeout,
)
api.add_resource(resource_name="issues", resource_class=resource.Issues)
api.add_resource(resource_name="project_events",
resource_class=resource.ProjectEvents)
api.add_resource(resource_name="project_issues",
resource_class=resource.ProjectIssues)
api.add_resource(resource_name="projects",
resource_class=resource.Projects)
return api
class Client(object):
"""docstring for Client"""
def __init__(self):
self.api = API(api_root_url=API_ROOT_URL,
params={},
headers={},
timeout=2,
append_slash=False,
json_encode_body=True)
def request(self):
return self
def test(self):
self.api.add_resource(resource_name='auth',
resource_class=AuthResource)
response = self.api.auth.login(body={
'username': '******',
'password': '******'
})
print('***RESPONSE***')
if response.status_code == 200:
print(response.body['data'])
return response.body
class BaseClient(object):
"""Base class for resources operations."""
def __init__(self):
self.api = API(
api_root_url=APIROOTURL,
params={},
headers={'Cookie': TWISTEDCOOKIES},
timeout=2,
append_slash=False,
json_encode_body=True,
)
# Add resource
def add_resource(self, resource, resource_class=None):
if resource_class:
self.api.add_resource(resource_name=resource,
resource_class=resource_class)
else:
self.api.add_resource(resource_name=resource)
try:
getattr(self.api, resource).list()
except ClientError as e:
print("[!] Error please make sure the resource exists")
raise e
from simple_rest_client.api import API
from simple_rest_client.resource import Resource
import progressbar
class MovieResource(Resource):
actions = {
'list': {'method': 'GET', 'url': 'list_movies.json'},
}
def good(movie):
return movie['rating'] >= 7.5
api = API(api_root_url='https://yts.am/api/v2')
api.add_resource(resource_name='movies', resource_class=MovieResource)
max_movies = 20
with progressbar.ProgressBar(max_value=max_movies) as bar:
page = 0
movies = []
while len(movies) < max_movies and page < 20:
page += 1
movies_new = api.movies.list(params={'limit': 50, 'page': page}).body['data']['movies']
movies_new = [movie for movie in movies_new if good(movie)]
movies += movies_new
bar.update(min(max_movies, len(movies)))
for movie in sorted(movies, key=lambda m: m['rating'], reverse=True):
print('{rating:3.1f} {title}\n {url}'.format(**movie))
