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))