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 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 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 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 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 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_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_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 index(request):
if request.method == 'POST':
body_unicode = request.body.decode('utf-8')
body = json.loads(body_unicode)
Metadata.objects.create(
image_name=body['image_name'],
image_path=body['image_path'],
object=body['object']
# alphanumeric = body['alphanumeric'],
# alphanumeric_color = body['alphanumeric_color'],
# shape_color = body['shape_color'],
)
# resize to 299x299 image, send off to color and alpha!!
print('RESIZING IMAGE: ' + body['image_name'])
os.system(
f'magick mogrify -resize 299!x299! C:\watcher_directory\output\{body["image_name"]}'
)
api = API(
api_root_url='http://localhost:8000',
json_encode_body=True,
append_slash=True,
)
api.add_resource(resource_name='alphanumeric')
api.alphanumeric.create(body={
'image_name': body['image_name'],
'image_path': body['image_path']
})
api.add_resource(resource_name='color')
api.color.create(body={
'image_name': body['image_name'],
'image_path': body['image_path']
})
return HttpResponse("Written")
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 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)
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
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 GitlabAPI(ServerAPI):
host = ""
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)
# print(self.api.groups.actions)
def create_hook(self, project_id, webhook_url):
self.api.hooks.create(project_id,
body=GitlabProjectHook(id=project_id,
url=webhook_url,
token=''))
def get_hooks(self, project_id: int) -> List[GitlabProjectHook]:
try:
response = self.api.hooks.list(project_id)
return get_list(response, GitlabProjectHook)
except AuthError as e:
logger.exception("Erreur d'accès à la ressource")
return []
def get_repos(self) -> List[GitlabProject]:
response = self.api.projects.list()
# print(response.headers)
repos = get_list(response, GitlabProject)
next_page = response.headers['X-Next-Page']
sys.stdout.write("Fetching all Gitlab repos (1/{})".format(
response.headers['X-Total-Pages']))
sys.stdout.flush()
while response.headers['X-Page'] != response.headers['X-Total-Pages']:
response = self.api.projects.list(params={'page': next_page})
next_page = response.headers['X-Next-Page']
sys.stdout.write("\rFetching all Gitlab repos ({}/{})".format(
response.headers['X-Page'], response.headers['X-Total-Pages']))
sys.stdout.flush()
repos += get_list(response, GitlabProject)
print()
return repos
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
class GiteaAPI(ServerAPI):
host = ""
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)
# def search_repo(self, query, mode='mirror', only_me=True, uid=None):
# response = self.api.repos.search(params={'q':query,
# 'uid':uid, #utilisateur
# 'mode':mode, #type de repo : fork, source, mirror, collaborative
# 'exclusive':only_me #uniquement ceux qui appartiennent au user spécifié
# })
def list_repo(self)->List[GiteaRepo]:
response = self.api.user.repos()
return get_list(response, GiteaRepo)
def mirror_repo(self, clone_addr, repo_name, desc="Fork this repo to modify it", username=None, password=None, private=True):
body = {
"auth_password": password,
"auth_username": username,
"clone_addr": clone_addr,
"description": desc,
"mirror": True,
"private": private,
"repo_name": repo_name,
"uid": self.api.user.me().body['id']
}
#print(json.dumps(body))
try:
return self.api.repos.migrate(body=body)
except ServerError:
logger.exception("Remote authentication might be required to clone this repository")
return False
def delete_repo(self, repo_name):
response = self.api.repos.delete(self.api.user.me().body['username'], repo_name)
if response.status_code != 204:
logger.warning("Repo {} might not have been deleted from {}".format(repo_name, self.host))
return False
class Client:
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 __getattr__(self, name):
return getattr(self.email_api, name)
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
def connect(api_root_url: str, token: str, timeout: float = 2.0) -> API:
"""Connects to an Argus API instance.
:returns: A connected simple_rest_client API object
"""
headers = {"Authorization": "Token " + token}
argusapi = API(
api_root_url=api_root_url,
headers=headers,
timeout=timeout,
json_encode_body=True,
append_slash=True,
)
argusapi.add_resource(resource_name="incidents",
resource_class=IncidentResource)
argusapi.add_resource(resource_name="events",
resource_class=IncidentEventResource)
argusapi.add_resource(resource_name="acknowledgements",
resource_class=IncidentAcknowledgementResource)
return argusapi
"public_user_events": {
"method": "GET",
"url": "/users/{}/events/public"
},
"organization_events": {
"method": "GET",
"url": "/users/{}/events/orgs/{}"
},
}
# https://github.com/settings/tokens
default_params = {"access_token": "valid-token"}
github_api = API(api_root_url="https://api.github.com",
params=default_params,
json_encode_body=True)
github_api.add_resource(resource_name="events", resource_class=EventResource)
async def main():
print("github_api.events.public_events={!r}".format(
await github_api.events.public_events()))
print("github_api.events.repository_events={!r}".format(
await
github_api.events.repository_events("allisson",
"python-simple-rest-client")))
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
"url": "users/{}/media/recent"
},
"retrieve_likes": {
"method": "GET",
"url": "users/self/media/recent"
},
}
# https://www.slickremix.com/docs/how-to-create-instagram-access-token/
# get token with public_content scope
default_params = {"access_token": "valid-token"}
instagram_api = API(api_root_url="https://api.instagram.com/v1/",
params=default_params,
json_encode_body=True)
instagram_api.add_resource(resource_name="users", resource_class=UserResource)
async def main():
users_search = await instagram_api.users.search(
params={"q": "allissonazevedo"})
users_retrieve = await instagram_api.users.retrieve("self")
users_retrieve_media = await instagram_api.users.retrieve_media("self")
users_retrieve_likes = await instagram_api.users.retrieve_likes()
print("instagram_api.users.search={!r}".format(users_search.body))
print("instagram_api.users.retrieve={!r}".format(users_retrieve.body))
print("instagram_api.users.retrieve_media={!r}".format(
users_retrieve_media.body))
print("instagram_api.users.retrieve_likes={!r}".format(
users_retrieve_likes.body))
class LYBRest:
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 login(self):
payload = {
'data': {
'category': 'public',
'service': 'Login',
'account': self.account,
'password': self.password,
}
}
try:
res = self.rest.api.create(body=payload)
r = res.body
if 'data' in r:
data = r['data']
self.access_token = data['access_token']
return ''
else:
return json.loads(r)['err']
except:
return '로그인 에러'
def get_public_elem(self, elem):
payload = {
'data': {
'category': 'public',
'service': 'GetElement',
'element': elem,
}
}
try:
res = self.rest.api.create(body=payload)
r = res.body
if 'data' in r:
data = r['data']
return data['value']
else:
return json.loads(r)['err']
except:
return '에러'
def update_chat_id(self, chat_id):
payload = {
'data': {
'category': 'private',
'service': 'UpdateChatId',
'access_token': self.access_token,
'chat_id': str(chat_id),
}
}
try:
res = self.rest.api.create(body=payload)
r = res.body
if 'data' in r:
return ''
else:
return json.loads(r)['err']
except:
return '업데이트 에러'
def get_login_point(self):
if self.login_point >= 0:
return self.login_point
payload = {
'data': {
'category': 'private',
'service': 'GetLoginPoint',
'access_token': self.access_token
}
}
try:
res = self.rest.api.create(body=payload)
r = res.body
if 'data' in r:
data = r['data']
self.login_point = data['point']
return self.login_point
else:
return json.loads(r)['err']
except:
self.logger.error(traceback.format_exc())
def get_point(self):
if self.point >= 0:
return self.point
payload = {
'data': {
'category': 'private',
'service': 'GetPoint',
'access_token': self.access_token
}
}
try:
res = self.rest.api.create(body=payload)
r = res.body
if 'data' in r:
data = r['data']
self.point = data['point']
return self.point
else:
return json.loads(r)['err']
except:
self.logger.error(traceback.format_exc())
def get_chat_id(self):
if self.chat_id > 0:
return self.chat_id
payload = {
'data': {
'category': 'private',
'service': 'GetChatId',
'access_token': self.access_token
}
}
try:
res = self.rest.api.create(body=payload)
r = res.body
if 'data' in r:
data = r['data']
if 'chat_id' in data:
self.chat_id = int(data['chat_id'])
if self.chat_id > 0:
return self.chat_id
except:
return None
return None
def get_version(self):
payload = {
'data': {
'category': 'private',
'service': 'GetVersion',
'access_token': self.access_token
}
}
try:
res = self.rest.api.create(body=payload)
r = res.body
if 'data' in r:
data = r['data']
return data['version']
else:
return json.loads(r)['err']
except:
self.logger.error(traceback.format_exc())
def get_update_file(self):
payload = {
'data': {
'category': 'private',
'service': 'GetUpdateFileList',
'access_token': self.access_token
}
}
try:
res = self.rest.api.create(body=payload)
r = res.body
if 'data' in r:
data = r['data']
return data['update_file_list']
else:
return json.loads(r)['err']
except:
self.logger.error(traceback.format_exc())
def get_elem(self, elem):
payload = {
'data': {
'category': 'private',
'service': 'GetElement',
'access_token': self.access_token,
'element': elem,
}
}
try:
res = self.rest.api.create(body=payload)
r = res.body
if 'data' in r:
data = r['data']
return data['value']
else:
return json.loads(r)['err']
except:
self.logger.error(traceback.format_exc())
def get_token(self):
if len(self.token) == 0:
self.token = self.get_elem('token')
return self.token
def getConnectCount(self):
return ""
def connect_telegram(self, match_string):
try:
last_log = self.getTelegramUpdates(-1, match_string=match_string)
if last_log is not None:
return str(last_log.message.chat.id)
except:
self.logger.error(traceback.format_exc())
return ''
return ''
def long_pooling_telegram(self, chat_id):
try:
m_token = self.get_token()
bot = telegram.Bot(token=m_token)
# last_log = bot.getUpdates(-1)
# self.logger.debug(last_log)
# update_id = 284752270
# last_log = bot.getUpdates(offset=update_id)
last_log = bot.getUpdates()
for each_log in last_log:
self.logger.debug(each_log)
except:
self.logger.error(traceback.format_exc())
return ''
return ''
def send_telegram_message(self, chat_id, message):
if int(chat_id) <= 0:
return
try:
m_token = self.get_token()
bot = telegram.Bot(token=m_token)
bot.sendMessage(chat_id=chat_id, text=message)
except telegram.error.TimedOut:
pass
except telegram.error.NetworkError:
pass
except:
self.logger.error(traceback.format_exc())
return ''
def send_telegram_image(self, chat_id, image_url):
if chat_id <= 0:
return
try:
m_token = self.get_token()
bot = telegram.Bot(token=m_token)
bot.sendPhoto(chat_id=chat_id,
photo=open(image_url, 'rb'),
timeout=60)
except telegram.error.TimedOut:
pass
except telegram.error.NetworkError:
pass
except:
self.logger.error(traceback.format_exc())
def getTelegramUpdates(self, chat_id, match_string=None):
update = None
update_id = 0
try:
m_token = self.get_token()
bot = telegram.Bot(token=m_token)
lUpdateLog = bot.getUpdates(limit=99)
# self.logger.debug(lUpdateLog)
# self.logger.debug('-----------------' + str(len(lUpdateLog)))
for eachLog in lUpdateLog:
# self.logger.debug(eachLog)
# 메세지가 입력된 시간이 10초가 경과한 것들은 다 제거한다.
issue_time = int(time.mktime(eachLog.message.date.timetuple()))
# self.logger.debug(str(int(time.time()) - issue_time - self.adjustTime))
if int(time.time()) - issue_time - self.adjustTime > 10:
if update_id < eachLog.update_id:
update_id = int(eachLog.update_id)
else:
if chat_id <= 0:
self.logger.debug('텔레그램 연동')
if str(eachLog.message.text) == match_string:
if self.last_id != eachLog.update_id:
self.last_id = eachLog.update_id
update = eachLog
break
else:
if str(eachLog.message.chat.id) == str(chat_id):
if self.last_id != eachLog.update_id:
self.last_id = eachLog.update_id
update = eachLog
break
if update_id != 0:
bot.getUpdates(offset=update_id + 1)
except telegram.error.TimedOut:
pass
except telegram.error.NetworkError:
pass
except:
# self.logger.error(traceback.format_exc())
# self.logger.debug(traceback.format_exc())
self.logger.error(
str(sys.exc_info()[0]) + '(' + str(sys.exc_info()[1]) + ')')
return update
return update
from simple_rest_client.api import API
from simple_rest_client.resource import Resource
class BasicAuthResource(Resource):
actions = {"retrieve": {"method": "GET", "url": "basic-auth/{}/{}"}}
# https://httpbin.org/
auth = ("username", "password")
httpbin_api = API(api_root_url="https://httpbin.org/", ssl_verify=False)
httpbin_api.add_resource(resource_name="basic_auth",
resource_class=BasicAuthResource)
print("httpbin_api.basic_auth.retrieve={!r}".format(
httpbin_api.basic_auth.retrieve("username", "password", auth=auth).body))
class FaradayApi:
def __init__(self, url=None, ignore_ssl=False, token=None):
if url:
self.api_url = urljoin(url, "_api")
else:
self.api_url = None
self.token = token
if self.token:
headers = {"Authorization": f"Token {self.token}"}
else:
headers = {}
ssl_verify = not ignore_ssl
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 handle_errors(func):
def hanlde(self, *args, **kwargs):
if not self.token:
raise MissingConfig("Missing Config, run 'faraday-cli auth'")
try:
result = func(self, *args, **kwargs)
except InvalidCredentials:
raise
except AuthError:
raise InvalidCredentials(
"Invalid credentials, run 'faraday-cli auth'")
except ClientConnectionError as e:
raise Exception(f"Connection to error: {e}")
except DuplicatedError as e:
raise Exception(f"{e}")
except NotFoundError:
raise
except ClientError:
raise
except Exception as e:
raise Exception(f"Unknown error: {type(e)} - {e}")
else:
return result
return hanlde
def _build_resources(self):
self.faraday_api.add_resource(resource_name="login",
resource_class=resources.LoginResource)
self.faraday_api.add_resource(resource_name="config",
resource_class=resources.ConfigResource)
self.faraday_api.add_resource(
resource_name="workspace",
resource_class=resources.WorkspaceResource,
)
self.faraday_api.add_resource(
resource_name="bulk_create",
resource_class=resources.BulkCreateResource,
)
self.faraday_api.add_resource(resource_name="host",
resource_class=resources.HostResource)
self.faraday_api.add_resource(resource_name="service",
resource_class=resources.ServiceResource)
self.faraday_api.add_resource(
resource_name="credential",
resource_class=resources.CredentialResource,
)
self.faraday_api.add_resource(resource_name="agent",
resource_class=resources.AgentResource)
self.faraday_api.add_resource(resource_name="vuln",
resource_class=resources.VulnResource)
def login(self, user, password):
body = {"email": user, "password": password}
try:
response = self.faraday_api.login.auth(body=body)
if response.status_code == 202:
return None
except NotFoundError:
raise
except AuthError:
return False
except ClientConnectionError:
raise
else:
return True
def get_token(self, user, password, second_factor=None):
if not self.token:
login_body = {"email": user, "password": password}
try:
self.faraday_api.login.auth(body=login_body)
if second_factor:
second_factor_body = {"secret": second_factor}
try:
self.faraday_api.login.second_factor(
body=second_factor_body)
except AuthError:
raise Invalid2FA("Invalid 2FA")
token_response = self.faraday_api.login.get_token()
except NotFoundError:
# raise Exception(
# f"Invalid url: {self.faraday_api.api_root_url}"
# )
raise
except AuthError:
raise InvalidCredentials()
except ClientConnectionError:
raise
else:
self.token = token_response.body
return self.token
@handle_errors
def is_token_valid(self):
try:
self.faraday_api.login.validate()
except ClientConnectionError as e:
raise click.ClickException(
click.style(f"Connection to error: {e}", fg="red"))
except AuthError:
return False
else:
return True
@handle_errors
def get_version(self):
version_regex = r"(?P<product>\w)?-?(?P<version>\d+\.\d+)"
response = self.faraday_api.config.config()
raw_version = response.body["ver"]
match = re.match(version_regex, raw_version)
products = {"p": "pro", "c": "corp"}
product = products.get(match.group("product"), "community")
version = match.group("version")
return {"product": product, "version": version}
@handle_errors
def get_workspaces(self):
response = self.faraday_api.workspace.list()
return response.body
@handle_errors
def get_workspace(self, workspace_name):
response = self.faraday_api.workspace.get(workspace_name)
return response.body
@handle_errors
def get_hosts(self, workspace_name):
response = self.faraday_api.host.list(workspace_name)
return response.body
@handle_errors
def get_vulns(self, workspace_name):
response = self.faraday_api.vuln.list(workspace_name)
return response.body
@handle_errors
def get_workspace_credentials(self, workspace_name):
response = self.faraday_api.credential.list(workspace_name)
return response.body
@handle_errors
def get_workspace_agents(self, workspace_name):
response = self.faraday_api.agent.list(workspace_name)
return response.body
@handle_errors
def get_agent(self, workspace_name, agent_id):
response = self.faraday_api.agent.get(workspace_name, agent_id)
return response.body
@handle_errors
def run_executor(self, workspace_name, agent_id, executor_name, args):
body = {
"executorData": {
"agent_id": agent_id,
"args": args,
"executor": executor_name,
}
}
response = self.faraday_api.agent.run(workspace_name,
agent_id,
body=body)
return response.body
@handle_errors
def get_host(self, workspace_name, host_id):
response = self.faraday_api.host.get(workspace_name, host_id)
return response.body
@handle_errors
def delete_host(self, workspace_name, host_id):
response = self.faraday_api.host.delete(workspace_name, host_id)
return response.body
@handle_errors
def create_host(self, workspace_name, host_params):
try:
response = self.faraday_api.host.create(workspace_name,
body=host_params)
except ClientError as e:
if e.response.status_code == 409:
raise exceptions.DuplicatedError("Host already exist")
else:
return response.body
@handle_errors
def get_host_services(self, workspace_name, host_id):
response = self.faraday_api.host.get_services(workspace_name, host_id)
return response.body
@handle_errors
def get_host_vulns(self, workspace_name, host_ip):
response = self.faraday_api.host.get_vulns(workspace_name,
params={"target": host_ip})
return response.body
@handle_errors
def bulk_create(self, ws, data):
response = self.faraday_api.bulk_create.create(ws, body=data)
return response.body
@handle_errors
def create_workspace(self, name, description="", users=None):
default_users = ["faraday"]
if users:
if isinstance(users, str):
default_users.append(users)
elif isinstance(users, list):
default_users.extend(users)
data = {
"description": description,
"id": 0,
"name": name,
"public": False,
"readonly": False,
"customer": "",
"users": default_users,
}
try:
response = self.faraday_api.workspace.create(body=data)
except ClientError as e:
if e.response.status_code == 409:
raise exceptions.DuplicatedError("Workspace already exist")
else:
return response.body
@handle_errors
def delete_workspace(self, name):
response = self.faraday_api.workspace.delete(name)
return response
@handle_errors
def is_workspace_valid(self, name):
workspaces = self.get_workspaces()
available_workspaces = [
ws for ws in map(lambda x: x["name"], workspaces)
]
return name in available_workspaces
import datetime
#queues
import requests
from re import compile, MULTILINE
from queue import Queue
from threading import Thread
import time
from simple_rest_client.api import API
import json
api = API(
api_root_url='https://reqres.in/api/pay/',
append_slash=True,
json_encode_body=False,
)
api.add_resource(resource_name='pay')
task_queue = Queue()
tokens = []
class BITCoin():
CHARS = "0123456789abcdefghijklmnopqrstuvwxyz"
COIN_LEN = 6
def __init__(self):
for _ in range(0, 100000):
token = ""
for _ in range(0, self.COIN_LEN):
token += random.choice(self.CHARS)
tokens.append(token)
self._tokens = set(tokens)
def test_api_ssl_verify(ssl_verify, expected_ssl_verify, api, reqres_resource):
api = API(api_root_url="http://localhost:0/api/",
json_encode_body=True,
ssl_verify=ssl_verify)
api.add_resource(resource_name="users")
assert api.ssl_verify == expected_ssl_verify
def get_api(
api_root_url="http://localhost:5000/api/v1/", json_encode_body=True, **kargs
):
api = API(
api_root_url=api_root_url,
json_encode_body=json_encode_body,
timeout=60,
**kargs
)
api.add_resource(resource_name="configs", resource_class=ConfigsResource)
api.add_resource(resource_name="blobs", resource_class=BlobsResource)
api.add_resource(resource_name="documents", resource_class=DocumentsResource)
api.add_resource(resource_name="entries", resource_class=EntriesResource)
api.add_resource(resource_name="db", resource_class=DBResource)
api.add_resource(resource_name="key", resource_class=KeyResource)
api.add_resource(resource_name="tools", resource_class=ToolsResource)
return api
ret = child.find('ja:body', my_namespaces)
if ret != None:
for c in ret.findall('.//ce:sections/ce:section',
my_namespaces):
for sec in c.iter():
if sec.tag.find('section-title') != -1:
#print(sec.text)
rawtext += sec.text + '\n'
if sec.tag.find('para') != -1:
#print(sec.text)
rawtext += sec.text + '\n'
#print(rawtext)
return rawtext
restclient.add_resource(resource_name='thesis')
#text = findText('./elsevier/A quick method for the simultaneous determination of ascorbic acid and sorbic acid in fruit juices by capillary zone el.xml')
#sys.exit(0)
try:
downloader = ArticleDownloader(
els_api_key='e88e30b8118b3ed42ca752c0d6b59686')
#https://api.elsevier.com/content/search/sciencedirect?query=nutrition&APIKey=e88e30b8118b3ed42ca752c0d6b59686
#dois = downloader.get_dois_from_journal_issn('1476-4686', rows=500, pub_after=2000)
filetype = 'xml'
#78 is for elsevier
records = downloader.get_dict_from_search(
'ascorbic acid+extraction+fruit&filter=member:78', 3000)
for i, record in enumerate(records):
print(i)
cur_title = re.sub('[\[\]\'\.\/]', '', str(record['title']))
replaced_doi = re.sub('[\[\]\'\.\/()]', '', str(record['doi']))
from simple_rest_client.api import API
from simple_rest_client.resource import Resource
class FileUploadResource(Resource):
actions = {
'create': {
'method': 'POST',
'url': 'post.php?dir=example'
},
}
# http://blog.henrycipolla.com/2011/12/testing-multipartform-data-uploads-with-post-test-server/
files = {'file': open('github.py', 'rb')}
post_test_server_api = API(api_root_url='http://posttestserver.com/',
timeout=10)
post_test_server_api.add_resource(resource_name='file_upload',
resource_class=FileUploadResource)
print('post_test_server_api.file_upload.create={!r}'.format(
post_test_server_api.file_upload.create(files=files).body))
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))
