def execute(self, message): api = Api() counter = 0 for tweet in api.user_timeline(count=message.args[0]): tweet.destroy() counter = counter + 1 return '%i tweets removed' % counter
def __init__(self, api_key, api_secret, access_token): Api.__init__(self, api_key, api_secret) self.oauth_token = oauth.Token( access_token['oauth_token'], access_token['oauth_token_secret'] ) self.client = oauth.Client(self.consumer, self.oauth_token)
def do_GET(self): try: if urlparse(self.path).query: params = parse_qs(urlparse(self.path).query) family = params.get("family")[0] if params.has_key("family") else "" section = params.get("section")[0] if params.has_key("section") else "" mtype = params.get("type")[0] if params.has_key("type") else "" noteid = params.get("id")[0] if params.has_key("id") else "" txt = params.get("search")[0] if params.has_key("search") else "" year = params.get("year")[0] if params.has_key("year") else "" month = params.get("month")[0] if params.has_key("month") else "" day = params.get("day")[0] if params.has_key("day") else "" detail = params.get("detail")[0] if params.has_key("detail") else "" richness = params.get("richness")[0] if params.has_key("richness") else "" thisapi = Api(family,section,mtype,txt,noteid,year,month,day,detail,richness) #Application/json self.send_response(200) self.send_header('Content-type', 'text/json') self.end_headers() self.wfile.write(thisapi.getResult()) else: thisapi = Api() self.send_response(200) self.send_header('Content-type', 'text/json') self.end_headers() self.wfile.write(thisapi.getResult()) except Exception as e: self.send_error(503,'Servicio No Disponible '+e.__str__())
class SshMonitorPlugin(Plugin, Thread): name = 'ssh monitoring plugin for elmot by Frolov Dmitry' keyword = 'sshmon' controlled = False def __init__(self): Plugin.__init__(self) Thread.__init__(self) self.api = Api() def follow(self, thefile): thefile.seek(0,2) while True: line = thefile.readline() if not line: time.sleep(0.1) continue if ('Failed password' in line): yield line.split(': ')[1].split('port')[0] def run(self): logfile = open('/var/log/auth.log') loglines = self.follow(logfile) for line in loglines: line = line.replace('invalid user ', '', 1) self.api.tweet(line)
def call(self, command): if command[0].lower() == 'exit': exit() if command[0].lower() == 'help': self.reader.printfile('help') return api = Api(self.client) api.call(command)
def test_register_resources(self, m_flask_restful): Api._register_resources(m_flask_restful) call = mock_module.call m_flask_restful.add_resource.assert_has_calls( [call(VolumeList, '/volumes'), call(Volume, '/volumes/<volume_id>')], any_order=True)
def run(path_to_conf='conf.ini', **kwargs): conf = ConfigParser.SafeConfigParser() with io.open(path_to_conf, 'rb') as fd: conf.readfp(fd) params = {} for key, val in conf.items('params'): if key in ['trim_user', 'exclude_replies', 'contributor_details', 'include_rts']: params[key] = int(conf.getboolean('params', key)) else: params[key] = val params.update(kwargs) try: db_url = conf.get('database', 'url') except ConfigParser.NoOptionError: if conf.get('database', 'type') == 'sqlite': db_url = 'sqlite://{0}'.format(conf.get('database', 'name')) else: db_url = '{0}://{1}:{2}@{3}/{4}'.format( conf.get('database', 'type'), conf.get('database', 'user'), conf.get('database', 'password'), conf.get('database', 'host'), conf.get('database', 'name') ) engine = create_engine(db_url) models.Base.metadata.create_all(bind=engine) Session = sessionmaker(bind=engine) session = Session() api = Api(conf.get('api', 'consumer_key'), conf.get('api', 'consumer_secret')) for tl in session.query(models.Timeline): if not tl.last_update or datetime.datetime.now() >= \ tl.last_update + tl.interval: last_tweet = tl.tweets.order_by(models.Tweet.id.desc()).first() if last_tweet: params['since_id'] = last_tweet.id elif 'since_id' in params: del params['since_id'] tweets = api.get_user_timeline(params=params, screen_name=tl.screen_name) for tweet in tweets: if not session.query(models.Tweet).get(tweet['id']): tl.tweets.append(models.Tweet(tweet)) tl.last_update = datetime.datetime.now() session.commit()
def do(config): api = Api(config['api']) ok, status, data = api.post('/Profile/getOwnProfile') text = config['format'] % data['user_info'] params = dict(content=text.encode('UTF-8'), qualifier=':') ok, status, data = api.post('/Timeline/plurkAdd', params) if not ok: logging.error('status: %s' % status) logging.error(data)
class Test: def __init__(self): config = ConfigParser.ConfigParser() # Replace config.conf with your own auth_file name config.read('config.conf') key_id = config.get('api_key_pair','key_id') secret_key = config.get('api_key_pair', 'secret_key') api_hostname = config.get('api_key_pair', 'api_hostname') oauth = APIToken(api_hostname) token = oauth.get_token(key_id, secret_key) self.api = Api(token) return None def test_get(self): resp = self.api.get("v1/servers") if not resp.raise_for_status(): data = resp.json() print data return None def test_post(self): body = { "policy": { "name": "Testing-hlee", "platform": "linux" } } resp = self.api.post("v1/policies", body) if not resp.raise_for_status(): data = resp.json() policy_id = data["policy"]["id"] return policy_id def test_put(self): body = { "policy": { "name": "Update-hlee" } } # got the policy id from test_post. you can definitely add an argument to pass in the policy # instead of hard coded in the below url. resp = self.api.put("v1/policies/15be2cbec3a511e5a01759521d1a9f69", body) resp.raise_for_status() return None def test_delete(self): self.api.delete("v1/policies/15be2cbec3a511e5a01759521d1a9f69") # resp.raise_for_status() return None
class ApiTest(unittest.TestCase): @defer.inlineCallbacks def setUp(self): self.conn = yield txmongo.MongoConnection('127.0.0.1', DB_PORT) self.db = self.conn.test_db self.api = Api(self.db, bcrypt.gensalt()) @defer.inlineCallbacks def tearDown(self): yield self.db.user.drop() yield self.db.firm.drop() yield self.conn.disconnect() @defer.inlineCallbacks def test_user_create(self): name = "user" fullname = "User User" password = "******" yield self.api.create_user(name, fullname, password) [user] = yield self.api.get_user(name) self.assertEqual(user['name'], "user") self.assertEqual(user['fullname'], "User User") self.assertEqual(user['password'], self.api.hash_password("password".encode('utf-8'))) @defer.inlineCallbacks def test_user_already_exists(self): name = "user" fullname = "User User" password = "******" yield self.api.create_user(name, fullname, password) yield self.assertFailure(self.api.create_user(name, fullname, password), UserAlreadyExists) @defer.inlineCallbacks def test_create_firms(self): name= 'My firm' adress = 'Riksdalersgatan 25C' postal_code = '41481' city = 'Gothenburg' yield self.api.create_firm(name, adress, postal_code, city) adress2 = 'Marklandsgatan 67' postal_code2 = '1234' yield self.api.create_firm(name, adress2, postal_code2, city) [firm1, firm2] = yield self.api.get_firms({'name': name}) self.assertEqual(firm1['name'], name) self.assertEqual(firm1['adress'], adress) self.assertEqual(firm1['postal_code'],postal_code) self.assertEqual(firm1['city'],city) self.assertEqual(firm2['adress'],adress2) [firm] = yield self.api.get_firms({'adress':adress2}) self.assertEqual(firm['adress'],adress2)
def draw_snake(self): for i in range(0, self.snake.body.__len__()): x0, y0 = Api.position_to_pix(self.snake.body[i][0], self.snake.body[i][1]) x1 = x0+10 y1 = y0+10 self.canvas.create_rectangle(x0, y0, x1, y1, fill="white", outline=None, width=0) if i != (self.snake.body.__len__()-1): x2, y2 = Api.position_to_pix(self.snake.body[i+1][0], self.snake.body[i+1][1]) x3 = (x0 + x2)/2 y3 = (y0 + y2)/2 x4 = x3+10 y4 = y3+10 self.canvas.create_rectangle(x3, y3, x4, y4, fill="white", outline=None, width=0)
def do_post(config, added, deled): api = Api(config['api']) desc = u'' if added: desc += u'\n'.join(sorted(added)) + u'\nが増えました\n(カルマの状態によっては使えない場合があります)\n\n' if deled: desc += u'\n'.join(sorted(deled)) + u'\nが減りました\n\n' if desc: url = paste(desc) text = u' '.join([u' '.join(sorted(added)), u':', url, u'(details...)']) params = dict(content=text.encode('UTF-8'), qualifier=':') ok, status, data = api.post('/Timeline/plurkAdd', params) if not ok: logging.error('status: %s' % status) logging.error(data)
def run(self): try: # 读取待转换的书籍信息 wait_converts = Tbl_Wait_Converts() wait_converts_info = wait_converts.get(self.convert_id) if not wait_converts_info: raise Exception, '未找到待转换的书籍信息' # 读取书籍所需图片 book_img = Tbl_Book_Img() book_img_info = book_img.get(self.book_id) if book_img_info: # 更新书籍所需图片表信息 book_img.update_local_path(self.book_id, self.book_images_task.get()) # 读取书籍信息 books = Tbl_Books() book_info = books.get_by_book_id(self.book_id) ## 调用转换功能 out_file_path = proc_helper.convert(str(wait_converts_info['book_html_local_path']), self.out_dir, book_info['book_author'], book_info['book_cover_local_path']) if out_file_path == None: # 转换失败 wait_converts.update_status(gk7.STATUS.get('error'), self.convert_id) raise Exception, '转换html to mobi失败' # 转换成功,修改状态,添加书籍输出路径 wait_converts.update_status(gk7.STATUS.get('complete'), self.convert_id, out_file_path) # 修改书籍文件路径 books.update_file_path(self.book_id, out_file_path) wait_email = Tbl_Wait_Emails() # 修改待发送邮件附件信息 wait_email.update_attach_file(self.email_id, out_file_path) # 读取待发送邮件信息 wait_email_info = wait_email.get(self.email_id) if not wait_email_info: raise Exception, '未找到待发送邮件信息,邮件ID:%s' %self.email_id # 发送邮件 Api.send_mail(self.email_id, wait_email_info['email_attach_file'], str(wait_email_info['email_to_user']), str(wait_email_info['email_title']), str(wait_email_info['email_auth'])) # 发送邮件至个人邮箱to_private_email if self.to_private_email: private_email_id = RandomUtil.random32Str() wait_email.add_full(private_email_id, self.to_private_email, str(wait_email_info['email_title']), str(wait_email_info['email_auth']), wait_email_info['email_attach_file']) MailTask.send.delay(private_email_id, wait_email_info['email_attach_file'], self.to_private_email, str(wait_email_info['email_title']), str(wait_email_info['email_auth'])) except Exception, err: logger.error(u'异步线程出错,转换ID:%s,错误信息:%s', self.convert_id, err) exit(-1)
def __init__(self, parent=None): super().__init__(parent) # set app name before mediaObject was created to avoid phonon problem # QCoreApplication.setApplicationName("NetEaseMusic-ThirdParty") self.ui = UiMainWidget() # 那些widget对象都通过self.ui.*.*来访问,感觉也不是很好 self.ui.setup_ui(self) self.player = Player() self.current_playlist_widget = MusicTableWidget() self.lyric_widget = LyricWidget(u'没有正在播放的歌曲') self.status = self.ui.status self.trayicon = TrayIcon(self) self.webview = self.ui.right_widget.webview # 常用的对象复制一下,方便使用 self.progress = self.ui.top_widget.progress_info self.network_manger = NetworkManager() self.search_shortcut = QShortcut(QKeySequence("Ctrl+F"), self) self.play_or_pause_btn = self.ui.top_widget.play_pause_btn self.web = MyWeb() self.api = Api() self.network_queue = Queue() self.init() self.state = {'is_login': False, 'current_mid': 0}
def run(self): debug.message("Starting build of project %s" % self.project["Name"], indent=1) build_result = 0 for solution in self.get_solutions(): build_result += self.run_build(solution) if build_result != 0: Api.update_status(self.commit["ID"], CommitStatus.BuildError) raise Exception("Build of solution %s failed" % solution["name"]) self.publish() debug.message("Build of solution %s succeeded!" % solution["name"], indent=2) Api.update_status(self.commit["ID"], CommitStatus.Build) debug.message("Build of project %s completed" % self.project["Name"], indent=1)
def get_test_cases(self,id=None): if id is not None: response=cherrypy.session.get('project_db_connection').execute_query(sqlquery_get_test_cases_exe_filter.format(folder_name=id)) else: response=cherrypy.session.get('project_db_connection').execute_query(sqlquery_get_test_cases_exe) r=['['] users=Api.get_users() for i, item in enumerate(response): if i!= len(response)-1: r.append('{ "id": "%s", "tc_id": "%s", "name": "%s", "executor": "%s", "type": "%s", "status": "%s", "date": "%s", "time": "%s" }, '%(item[0],item[1],item[2],users[item[3]],item[4],item[5],item[6].strftime("%Y-%m-%d"),item[7])) else: r.append('{ "id": "%s", "tc_id": "%s", "name": "%s", "executor": "%s", "type": "%s", "status": "%s", "date": "%s", "time": "%s" }'%(item[0],item[1],item[2],users[item[3]],item[4],item[5],item[6].strftime("%Y-%m-%d"),item[7])) r.append(']') return ''.join(r) # @cherrypy.expose() # def get_test_cases(self,id=None,_=None): # #http://127.0.0.1:8081/cases/get_test_cases?id=/folder1/subfolder_1/ # response=cherrypy.session.get('project_db_connection').execute_query(sqlquery_get_test_cases.format(id.split("/")[-2])) # r=['{"aaData":['] # users=Api.get_users() # for i, item in enumerate(response): # if i!= len(response)-1: # r.append('{"id":"%s","name":"%s","execution_type":"%s","type":"%s","execution_expected_time":"%s","creation_date":"%s","status":"%s"},'%(item[0],item[5],item[9],item[10],item[3],item[4].strftime("%Y-%m-%d"),item[11])) # else: # r.append('{"id":"%s","name":"%s","execution_type":"%s","type":"%s","execution_expected_time":"%s","creation_date":"%s","status":"%s"}'%(item[0],item[5],item[9],item[10],item[3],item[4].strftime("%Y-%m-%d"),item[11])) # r.append(']}') # return ''.join(r)
def __init__(self, parent=None): super(LoginDialog, self).__init__(parent) self.username_lable = QLabel() self.password_lable = QLabel() self.hint_label = QLabel() self.username_widget = QLineEdit() self.password_widget = QLineEdit() self.login_btn = QPushButton() self.captcha_label = QLabel() self.captcha_lineedit = QLineEdit() self.layout = QVBoxLayout() self.is_remember_chb = QCheckBox(u"记住账号") self.nm = NetworkManager() self.filename = CACHE_PATH + "user.json" self.ne = Api() self.is_autofill = False self.is_need_captcha = False self.captcha_id = 0 self.user_data = 0 self.__set_signal_binding() self.__set_widgets_prop() self.__set_layouts_prop() self.__set_me() self.fill_content()
def get_defect_content(self,def_id): users=Api.get_users() #users=self.get_users() attachments=[] attachments_data=cherrypy.session.get('project_db_connection').execute_query(sqlquery_get_defect_attachments.format(def_id=def_id)) for i, attachment in enumerate(attachments_data): attachments.append([attachment[3],attachment[2],attachment[6]]) comments=[] comments_data=cherrypy.session.get('project_db_connection').execute_query(sqlquery_get_defect_comments.format(def_id=def_id)) for i, comment in enumerate(comments_data): comments.append([comment[0],users[comment[2]],comment[3].strftime("%Y-%m-%d %H:%M"),comment[4]]) linked_test=[] #linked_test_data= ####### TODO! ####### linked_test_data=cherrypy.session.get('project_db_connection').execute_query(sqlquery_get_defect_linked_tests.format(def_id=def_id)) for i, comment in enumerate(linked_test_data): linked_test.append([comment[0],users[comment[2]],comment[3].strftime("%Y-%m-%d"),comment[1]]) response=cherrypy.session.get('project_db_connection').execute_query(sqlquery_get_defect_additional_data.format(def_id=def_id))[0] data={} data['id']=def_id data['name']=response[1] if response[1] is not None else '' data['assign']=users[response[6]] data['assign_id']=response[6] data['status']=response[11] if response[11] is not None else '' data['status_id']=response[5] data['fix']=users[response[7]] data['fix_id']=response[7] data['type']=response[12] if response[12] is not None else '' data['add_date']=response[3].strftime("%Y-%m-%d") data['fix_date']='2012-01-01' data['description']=response[9] if response[9] is not None else '' data['solution']=response[10] if response[10] is not None else '' data['comments']=comments data['linked_test']=linked_test return data
def all_routes(): if request.method == 'OPTIONS': return '' action = (request.json and request.json.pop('action', None)) or ( request.args and request.args.pop('action', None)) if not action: return '<html><body><h1>Hi there!</h1></body></html>' if action == 'tree': return api.tree() elif action == 'get_all': return api.get_all() elif action == 'query': return api.query() elif action == 'update_person': return api.update_person() elif action == 'add_person': return api.add_person() elif action == 'get_role': return Api.get_role() elif action == 'remove_person': return api.remove_person() else: return '<html><body><h1>Unknown action</h1></body></html>', 404
def watch(build_queue): while True: debug.set_prefix("repository_watcher") debug.message("Retrieving projects") try: projects = Api.get_projects() for project in projects: debug.message("Check repository status for project %s" % project["Name"]) repository = Git(get_path(project), get_origin_url(project)) commit_count = handle_incoming_commits(repository.check_for_new_commits_on_origin(), project, repository, build_queue) if commit_count > 0: repository.merge_origin() # Add <initial_nr_commits> commits if this is a new repository if project["Commits"] is None or len(project["Commits"]) == 0: handle_incoming_commits( repository.get_commits(registry.config["repositories"]["initial_nr_commits"]), project, repository, build_queue) except ValueError, e: debug.exception("Error retrieving projects", e) except GitError, e: debug.exception("Error with Git repository", e)
def get_main_content(self): data={} user_name="Test Test" login_time="12:00" #sqlquery_get_login_time logged_time="58" #now() - login_time data['user_name']=user_name data['login_time']=login_time data['logged_time']=logged_time response=cherrypy.session.get('project_db_connection').execute_query(sqlquery_get_project_notes) users=Api.get_users() project_notes = [] for i, item in enumerate(response): temp=[] temp.append(item[0]) temp.append(item[1]) temp.append(item[2]) temp.append(users[item[5]]) project_notes.append(temp) data['project_notes']=project_notes response=cherrypy.session.get('project_db_connection').execute_query(sqlquery_get_user_notes) user_notes = [] for i, item in enumerate(response): temp=[] temp.append(item[0]) temp.append(item[1]) temp.append(item[3]) user_notes.append(temp) data['user_notes']=user_notes return data
def update_defect(self,def_id,params): defects_data={'name':'def_name','assign':'def_assigned_to','status_id':'def_status','fix':'def_fixed_by','type':'def_type','description':'def_description'} for key, value in params.items(): #if key == 'status': # value=Api.get_statuses()[value] if key == 'type': value=Api.get_types()[value] cherrypy.session.get('project_db_connection').execute_query(sqlquery_update_defect.format(position=defects_data[key], value=value, def_id=def_id),select=False)
def handle_incoming_commits(commits, project, repository, build_queue): for commit in commits: debug.message("Add commit %s to database" % commit.oid, indent=2) commit_date = datetime.fromtimestamp(int(commit.commit_time)).strftime('%Y-%m-%d %H:%M:%S') if len(commit.parents) > 0: changes = repository.get_changes(commit, commit.parents[0]) else: changes = repository.get_changes(commit) Api.add_commit(project["ID"], commit.oid, commit_date, commit.message, commit.author.name, changes) project["commit"] = commit.oid build_queue.put(project) return len(commits)
class Thread(QThread): def __init__(self, user, password): QThread.__init__(self) self.api = Api(user, password) self.executable = self.login self.data = None self.folder = '' def run(self): self.executable() self.data = None self.folder = '' def login(self): auth = self.api.login() if auth == 0: self.emit(SIGNAL("loginSuccess()")) elif auth == 1: self.emit(SIGNAL("loginFail()")) else: self.emit(SIGNAL("userUnknown()")) def get_files(self): self.api.get_files() self.emit(SIGNAL("filesList()")) def update_files(self): self.api.get_files() self.emit(SIGNAL("filesUpdated()")) def download_file(self): self.api.download_file(self.data, self.folder) self.emit(SIGNAL("downloadFinished(QString)"), self.data['file-name'])
def new_instance(cls, api=None, events=None): if api is None: api = Api.new_instance() if events is None: events = Events( make_context(get_platform(), settings.wallet), 'not loaded', 'not loaded' ) return cls(api, events, Track())
class ApiTest(unittest.TestCase): def setUp(self): self.Api = Api(source='hacker_news') def test_hacker_news_api(self): self.assertEqual(self.Api.url, 'http://api.ihackernews.com/page') def test_can_retrive_data(self): self.Api.fetch_data() self.assertTrue(self.Api.json_response) def test_to_pass_data_into_processor(self): self.test_can_retrive_data() self.Processor = Processor(self.json_response)
def init_file_server_by_key(key): config = Api(key=key).get_config_by_key().get('data') file_service = FileService(account_name=config.get('account_name'), account_key=config.get('account_key'), endpoint_suffix=config.get('endpoint_suffix')) logging.basicConfig( format='%(asctime)s %(name)-20s %(levelname)-5s %(message)s', level=logging.INFO) logger = logging.getLogger('azure.storage') handler = logging.StreamHandler() formatter = logging.Formatter( '%(asctime)s %(name)-20s %(levelname)-5s %(message)s') handler.setFormatter(formatter) logger.addHandler(handler) logger.setLevel(logging.INFO) return file_service
def main(config, section, out_dir, not_to_disk): base_url = config['nso']['url'] api_user = config['nso']['user'] api_password = config['nso']['password'] api = Api(base_url, api_user, api_password) device_groups = api.get('/devices/device-group?shallow', collection=True) device_groups = { dg['name']: dg['device-name'] for dg in find( 'collection.tailf-ncs:device-group', device_groups, default=[]) } if config.has_section(section): devices = get_devices(config[section], device_groups) logger.debug('Processing %s: %s', section, devices) process_devices(api, out_dir, not_to_disk, devices) else: logger.error('Configuration does not have a %s section', section)
def __init__(self, n, m, depth, save_permission, user_id, team_id, game_id): self.N = n self.M = m self.DEPTH = depth self.SAVE_PERMISSION = save_permission self.SLEEP_TIME = 5 self.G = Game(n, m) self.T = Tree(n, m, depth) self.API = Api(user_id, team_id) self.API.set_game_id(game_id) # load cache self.S = Save(n, m, self.SAVE_PERMISSION) out = self.S.load() if out: print('loaded') self.T.EF.Hash = out
def main(team, password, url): api = Api(url, password, team) board = Board(25, 25) cursor.hide() print("\033[2J") initState(api, board) mainLoop(api, board) exit()
def main(): api = Api() good_consumer(api.get_foo()) print("*** After good consumer ***") print(api.get_foo()) print() api = Api() evil_consumer(api.get_foo()) print("*** After evil consumer ***") print(api.get_foo()) print()
def __init__(self, protocol="http", hostname="", port="", authenticationMethode="basic"): Api.__init__(self) self._protocol = protocol.lower() self._hostname = hostname self._port = port self._rootUrl = self._protocol + "://" + self._hostname + ":" + self._port self.setAuthenticationMethode(authenticationMethode) # Loading configuration file with all the api with open("ambari_api.json") as jsonFile: self._config = json.load(jsonFile) self._clusterNameMask = self._config["clusterNameMask"] self._serviceNameMask = self._config["serviceNameMask"] self._requestIdMask = self._config["requestIdMask"] self._sleepingTimeInSeconds = self._config["sleepingTimeInSeconds"] self._api = self._config["api"]
def new_instance(cls, api=None, events=None): if api is None: api = Api.new_instance() if events is None: events = Events( make_context(get_platform(), conf.settings['wallet']), base58.b58encode(conf.settings.get_lbry_id()), conf.settings.get_session_id(), ) return cls(api, events, Track())
def do(config): api = Api(config['api']) ok, status, data = api.post('/Timeline/getUnreadPlurks') if not ok: logging.error('''api.post('/Timeline/getPlurks')''') logging.error('status: %s' % status) logging.error(data) return interval = config.get('interval', 1) balancer = Balancer() for rec in data.get('plurks', []): if is_god_reading_fortune(rec): balancer.clear() plurk_id = rec.get('plurk_id', 0) content = rec.get('content', u'') do_post(balancer, content) logging.info('plurk: %ld' % plurk_id) ok, status, data = api.post('/Responses/get', dict(plurk_id=plurk_id)) if not ok: logging.error('''api.post('/Responses/get', dict(plurk_id=%s))''' % plurk_id) logging.error('status: %s' % status) logging.error(data) continue for rec in data.get('responses', []): content = rec.get('content', u'') do_post(balancer, content) logging.debug([content, balancer.complement]) complement = balancer.complement if 0 < len(complement): for text in uniquify(split_text(complement)): logging.info(' posting: %s' % text) params = dict(plurk_id=plurk_id, qualifier=':', content=text.encode('UTF-8')) ok, status, data = api.post('/Responses/responseAdd', params) if not ok: logging.error('''api.post('/Responses/responseAdd', dict(content=%s))''' % complement) logging.error('status: %s' % status) logging.error(data) break sleep(interval)
def do(config): api = Api(config["api"]) ok, status, data = api.post("/Timeline/getUnreadPlurks") if not ok: logging.error("""api.post('/Timeline/getPlurks')""") logging.error("status: %s" % status) logging.error(data) return interval = config.get("interval", 1) balancer = Balancer() for rec in data.get("plurks", []): if is_god_reading_fortune(rec): balancer.clear() plurk_id = rec.get("plurk_id", 0) content = rec.get("content", u"") do_post(balancer, content) logging.info("plurk: %ld" % plurk_id) ok, status, data = api.post("/Responses/get", dict(plurk_id=plurk_id)) if not ok: logging.error("""api.post('/Responses/get', dict(plurk_id=%s))""" % plurk_id) logging.error("status: %s" % status) logging.error(data) continue for rec in data.get("responses", []): content = rec.get("content", u"") do_post(balancer, content) logging.debug([content, balancer.complement]) complement = balancer.complement if 0 < len(complement): for text in uniquify(split_text(complement)): logging.info(" posting: %s" % text) params = dict(plurk_id=plurk_id, qualifier=":", content=text.encode("UTF-8")) ok, status, data = api.post("/Responses/responseAdd", params) if not ok: logging.error("""api.post('/Responses/responseAdd', dict(content=%s))""" % complement) logging.error("status: %s" % status) logging.error(data) break sleep(interval)
def testRun(self): """Verify plain RestAPI GET request""" try: json_str = self.setup_class() if json_str['url1']['path']: url = constructURL.constURL( baseurl=json_str['url1']['baseurl'], path=json_str['url1']['path']) else: url = json_str['url1']['baseurl'] req = Api(url=url) resp = req.get() self.assertEqual(200, resp.status_code) response_type = resp.headers["content-type"] if re.search(r'json', response_type): response = resp.json() except Exception as e: print("Exception occurred during test run", e)
class EdgeAI: def __init__(self, app_token=None, app_secret=None): self.app_token = app_token or os.environ.get('EDGE_AI_TOKEN') self.app_secret = app_secret or os.environ.get('EDGE_AI_SECRET') self.api = Api(self.app_secret) def predict(self, features=None): payload = {'features': features or {}, 'app_token': self.app_token} return self.api.post('/predict', payload)
def __init__(self, *args, **kwargs): """ Initialize the Service object. Keyword Arguments: poll_seconds: time between checks for new files """ self.poll_seconds = kwargs.pop('poll_seconds') self.api = Api() self.stop_event = Event()
def get_test_cases(self,_=None): response=cherrypy.session.get('project_db_connection').execute_query(sqlquery_get_test_cases_for_iterations) r=['['] users=Api.get_users() for i, item in enumerate(response): if i!= len(response)-1: r.append('{ "id": "%s", "name": "%s", "designer": "%s", "execution_expected_time": "%s" }, '%(item[0],item[1],users[item[2]],item[3])) else: r.append('{ "id": "%s", "name": "%s", "designer": "%s", "execution_expected_time": "%s" } '%(item[0],item[1],users[item[2]],item[3])) r.append(']') return ''.join(r)
def start(self): api = Api() self.window = webview.create_window( "Магазин приложений", "../front/dist/index.html", js_api=api, width=self.width, height=self.height, resizable=self.resizable, ) webview.start(gui='cef', http_server=False, debug=True)
def put(put_request: PutRequest) -> Verdict: api = Api(put_request.hostname) try: username, password, bark = get_random_str(), get_random_str(), get_random_text() r = api.sing_up(username, password, get_random_str(), get_random_str()) r = api.add_bark(username, bark, is_private=True) bark_id = int(r.text.split(bark)[0].split("/get_bark/")[1][0:-3]) api.comment_bark(bark_id, put_request.flag, is_private=True) token = api.generate_token() api.logout() return Verdict.OK(f"{username}:{password}:{bark_id}") except RequestException as e: print(f"can't connect due to {e}") return Verdict.DOWN("can't connect to host") except Exception as e: print(e) return Verdict.MUMBLE("bad proto")
def main_function(): uid = login_from_cli() running = True # There's no do-while loop in Python, so we use this instead print_help() api = Api() while running: cmd = [i.strip() for i in input(">").strip().split(" ")] print(cmd) if cmd[0] == "quit" or cmd[0] == "exit": exit(1) elif cmd[0] == "list" and cmd[1] == "item": items = api.get_items_by_category(uid, cmd[2]) for item_id in items: print(api.get_item_info(item_id)) elif cmd[0] == "add": print(api.add_item_to_cart(uid, cmd[1], cmd[2])) elif cmd[0] == "list" and cmd[1] == "cart": print(api.get_cart_by_id(uid)) elif cmd[0] == "remove" and cmd[1] == "item": print(api.remove_item_from_cart(uid, cmd[2], cmd[3])) elif cmd[0] == "checkout": pass elif cmd[0] == "edit" and cmd[1] == "address": read = "" name = input("shipping name > ") line1 = input("address line 1 > ") line2 = input("address line 2 > ") city = input("city > ") state = input("state > ") zip = input("zip > ") while True: read = input( f"Does the following look correct?\n{name}\n{line1}\n{line2}\n{city}, {state}\n{zip}\ny/n" ) if read.lower().strip() == "y": print( api.edit_address(name=name, line1=line1, line2=line2, city=city, state=state, zip=zip)) if read.lower().strip() == "n": continue print(api.edit_address())
def get(self, *args, **kwargs): """Handles ALL requests. Figures out the user and then delegates to more purpose-specific methods.""" # Some poorly-behaved libraries screw with the default logging level, # killing our 'info' and 'warning' logs. Make sure it's set correctly # for our code. util.allow_all_logging() # Mark the start time of the request. You can add events to this # profiler in any request handler like this: # util.profiler.add_event("this is my event") util.profiler.clear() util.profiler.add_event('START') # create and sign in as a god user under certain conditions self.immaculately_conceive() # Running this ensures that cached users (e.g. self._user) are # correctly synched with the session ids. self.clean_up_users('user') self.clean_up_users('impersonated_user') # Deal with impersonation options if self.request.get('escape_impersonation') in config.true_strings: # Allow calls to escape impersonation, i.e. treat the call as if # the true user (not the impersonated user) was making it. # Should have no effect when no impersonation is happening. self._impersonated_user = None self.api = Api(self.get_current_user(method='normal')) elif self.request.get('impersonate'): # If allowed, impersonate the provided user for just this call target_user = User.get_by_id(self.request.get('impersonate')) normal_user = self.get_current_user(method='normal') if normal_user.can_impersonate(target_user): self._impersonated_user = target_user self.api = Api(target_user) else: logging.info('Impersonation denied. ' '{} is not allowed to impersonate {}.'.format( normal_user.id, target_user.id)) if not hasattr(self, 'api'): # Instantiate an api class that knows about the current user and # their permissions. Will default to the permissions of the # impersonated user if there is one, or the public user if no one # is signed in. self.api = Api(self.get_current_user()) # Also create an internal API that has god-like powers, only to be used # by interal platform code, never exposed through URLs. self.internal_api = Api(User.create(user_type='god')) # We are in the "grandparent" function; do_wrapper() is the "parent", # defined in either ApiHandler or ViewHandler; in turn, the "child" # function do() will be called. self.do_wrapper(*args, **kwargs)
class Poloniex: def __init__(self, currency_pair, period): self.currency_pair = currency_pair self.period = period self._api = Api(self.currency_pair, self.period) def _list_currencies(self): return self._api.currencies() def valids_currencies(self): if self.currency_pair in self._list_currencies(): return True return False def get_response(self): if self._api.get_status_code() == 200: return self._api.response() raise ConnectionError('Could not possible return the response') def get_chart_data(self): try: for currency in self.get_response().items(): if currency[0] == self.currency_pair: currency[1].pop('lowestAsk', None) currency[1].pop('highestBid', None) currency[1].pop('percentChange', None) currency[1].pop('baseVolume', None) currency[1].pop('quoteVolume', None) currency[1].pop('isFrozen', None) return currency[1] return None except IndexError: raise IndexError('List out of range') def get_field(self, name): items = self.get_chart_data().items() if items is not None: for key, value in items: if key == name: return value return None
class ApiTestCase(unittest.TestCase): def setUp(self): self.api = Api('BTC_BTS', 60) def test_instance(self): self.assertIsInstance(self.api, Api) def test_get_status_code(self): self.assertEqual(self.api.get_status_code(), 200) def test_response(self): self.assertIsNotNone(self.api.response()) def test_currencies(self): data = self.api._connection.json().keys() self.assertEqual(self.api.currencies(), data) def test_raise_currencies(self): data = self.api._connection.json() self.assertRaises(TypeError, self.api.currencies(), type(data) != dict(), data.keys())
def get_api(): api = Api( config.API_BASE_URL, basic_auth=( u'{0}@{1}'.format( config.ORIGIN_ADMIN_USERNAME, config.ORIGIN_TENANT_NAME, ), config.ORIGIN_ADMIN_PASSWORD, ), ) return api
def get(get_request: GetRequest) -> Verdict: api = Api() try: addr, secret = get_request.flag_id.strip().split(":") try: resulting_info = api.basement_info(get_request.hostname, addr, secret) if get_request.flag in resulting_info: return Verdict.OK() else: print(resulting_info, get_request.flag) return Verdict.CORRUPT("bad flag") except Exception as e: print(f"bad access {e}") return Verdict.CORRUPT("can't reach flag") except RequestException as e: print(e) return Verdict.DOWN("seems to be down") except Exception as e: print(f"ex {e}") return Verdict.MUMBLE("bad proto")
async def read_messages_from_admin_scenario(chats): for chat in chats: user = User() chat_id = chat['id'] async with Api(url) as api: await api.register(user.get_register_data()) await api.login(user.username, user.password) await api.join(chat_id, chat_id) resp = await api.read_messages(chat_id) if len(resp['messages']) > 0: print(resp['messages']) yield [x['text'] for x in resp['messages']]
def __init__(self): # Api calls self.api = Api() # Save temporary data for quick opening (open <index> command) self.current_threads = {'board': None, 'list': []} # JSON data self.boards_json = None self.threads_json = None self.thread_json = None self.archive_json = None
def get(get_request: GetRequest) -> Verdict: api = Api(get_request.hostname) try: username, password = get_request.flag_id.split(":") r = api.login(username, password) if r.status_code != 200: return Verdict.MUMBLE("can't login") if get_request.flag in r.text: return Verdict.OK() else: print(f"Can't find flag {get_request.flag} in {r.text}") return Verdict.CORRUPT("flag not found") except RequestException as e: print(f"can't connect due to {e}") return Verdict.DOWN("can't connect to host") except Exception as e: print(e) return Verdict.MUMBLE("bad proto")
def setup_services(self): """A method to prepare the possible services that Cobalt can have.""" self._service_endpoints = { 'engine': Engine(self.etcd, self.volume_manager, self.machine_manager, self.config['engine']), 'api': Api(self.volume_manager, self.config['api']), 'agent': Agent(self.machine_manager, self.volume_manager, self.config['agent']) }
def init_context(self): # public api self.p_api = Api(User(user_type='public')) # This closely follows the pattern of the populate script in god.html self.researcher = User(user_type='researcher') self.researcher.put() self.r_api = Api(self.researcher) self.teacher = User.create(user_type='teacher') self.teacher.put() self.t_api = Api(self.teacher) self.school = self.r_api.create('school', {'name': 'DGN'}) self.program = self.r_api.create('program', { 'name': 'Test Program', 'abbreviation': 'TP1', }) self.bad_program = self.r_api.create('program', { 'name': 'Bad Program', 'abbreviation': 'TP2', }) self.cohort = self.r_api.create( 'cohort', { 'name': 'DGN 2014', 'code': 'trout viper', 'program': self.program.id, 'school': self.school.id, }) self.bad_cohort = self.r_api.create( 'cohort', { 'name': 'bad cohort', 'code': 'king dolphin', 'program': self.bad_program.id, 'school': self.school.id, }) self.r_api.associate('associate', self.teacher, self.cohort) self.classroom = self.t_api.create( 'classroom', { 'name': "English 101", 'user': self.teacher.id, 'program': self.program.id, 'cohort': self.cohort.id, }) # the researcher has to create this one, since the teacher is only # associated with the "good" program. self.bad_classroom = self.r_api.create( 'classroom', { 'name': "English 101", 'user': self.teacher.id, 'program': self.bad_program.id, 'cohort': self.bad_cohort.id, }) # Identify a student into a classroom. See # url_handlers._create_student() self.student = self.p_api.create('user', { 'user_type': 'student', 'classroom': self.classroom.id, }) self.student.put()
def check_service(host: str) -> Verdict: try: with build_session() as session: api = Api(host, session) resp = api.register_user(Randomizer.user()) if resp.status_code != 201: return Verdict.MUMBLE("Can't register user", "Can't register user") file_in_zip, *file = create_zip() resp = api.upload_zip(file) if resp.status_code != 202: return Verdict.MUMBLE("Can't upload file", "Can't upload file") resp = api.search_file(file_in_zip) if file_in_zip not in resp.text: return Verdict.MUMBLE("Can't find file from zip", "Can't find file from zip") resp = api.create_note(get_text(), True) if resp.status_code != 201: return Verdict.MUMBLE("Can't create note", "Can't create note") return Verdict.OK() except Exception as e: return Verdict.DOWN("Can't connect to service", str(e))
class Interface(): def __init__(self): self.api = Api() board = self.api.make_board() self.sudoku = Sudoku(board) def validate_input_number(self, number, position_x, position_y): # Funcionalidad: Verifica si el valor ingresado es una letra o un # numero fuera de rango if number.isalpha() or position_x.isalpha() or position_y.isalpha(): raise ValueError() if 1 <= int(number) <= 9 and -1 < int(position_x) < 9 and -1 < int( position_y) < 9: return True raise IncorrectNumber() def play_sudoku(self): print(self.sudoku.print_board()) try: while not self.sudoku.is_over(): self.number = input("Ingrese un numero: ") self.position_x = input("Ingrese la posicion x: ") self.position_y = input("Ingrese la posicion y: ") print("\n") if self.validate_input_number(self.number, self.position_x, self.position_y): self.sudoku.put_number(int(self.position_x), int(self.position_y), int(self.number)) print(self.sudoku.print_board()) print("Felicitaciones ganaste") except InvalidPosition: print("No se puedo colocar el numero, hay un numero fijo") self.play_sudoku() except InvalidRow: print("El numero ya esta en la fila") self.play_sudoku() except InvalidColumn: print("El numero ya esta en la columna") self.play_sudoku() except InvalidRegion: print("El numero ya esta en la region") self.play_sudoku() except IncorrectNumber: print( "Ha ingresado incorrecto, debe ingresar un numero entre 1 y 9") self.play_sudoku() except ValueError: print("Ha ingresado una letra") self.play_sudoku()
def get_games_list(self, event): player_name = event.el.get_value() r = Api.getPlayerInfo(player_name) games_list = [id for id in r["games"]] if r is not None else [] label = thorpy.OneLineText.make("Here's a list of games " + player_name + " is in:") self.gamesListEdit = thorpy.DropDownList.make(games_list, size=(250,150), x=5) self.gamesListEdit.finish() gameSelectReaction = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT, reac_func=self.start_game_join, event_args={"id": thorpy.constants.EVENT_DDL}) self.gamesListEdit.add_reaction(gameSelectReaction) goBackButton = thorpy.make_button("Go Back", func=self.start_menu) self.replace_elements([label, self.gamesListEdit, goBackButton])
def wait_for_tray_event(mygui, server, username, hash_login, hash_msg): """ Check for config modification while waiting for action in systray """ log.debug("Main Loop\n") log.debug(f"{server} - {username} - {hash_login} - {hash_msg}") api = Api(server, username, hash_login, hash_msg) while True: if Config.was_configfile_modified(): log.info("Configfile was modified.") self_restart() event = mygui.tray.read() deal_with_tray_event(mygui, api, event)
def app1_template(): form = Search_form() q = request.args.get('q') # q variable contains a search pattert if form.validate_on_submit(): print('Сработала app1_template POST') url = form.url.data n = form.maxResults.data print(url, n) if 'replice' in request.form: print('replise in request.form') replice = request.form['replice'] api = Api(url, n, replice) comments = api.get_all_comments() total = len(comments) return render_template('app1.html', dash_url=DashApp1.url_base, comments=comments, total=total, form=form) api = Api(url, n) comments = api.get_all_comments() total = len(comments) return render_template('app1.html', dash_url=DashApp1.url_base, comments=comments, total=total, form=form) q_comments = [] if q and hasattr(Api, 'comments') and Api.comments != None: comments = Api.comments for i in comments: if q in i['textDisplay']: q_comments.append(i) total = len(q_comments) return render_template('app1.html', dash_url=DashApp1.url_base, comments=q_comments, total=total, form=form) else: if hasattr(Api, 'comments') and Api.comments != None: print('Сработало else hasattr(Api,"comments"') comments = Api.comments total = len(comments) return render_template('app1.html', dash_url=DashApp1.url_base, comments=comments, total=total, form=form) return render_template('app1.html', dash_url=DashApp1.url_base, form=form)
async def get_flag_from_deleted_messages(request: GetRequest) -> Verdict: admin_username, admin_password, chat_id, message_id = request.flag_id.split( ':') async with Api(f'http://{request.hostname}:3000') as api: try: await api.login(admin_username, admin_password) except InvalidResponseException as e: return Verdict.CORRUPT('Could not login or register', traceback.format_exc()) except: return Verdict.DOWN('Could not connect to service', traceback.format_exc()) try: resp = await api.read_messages(chat_id) except InvalidResponseException: return Verdict.CORRUPT('Invalid response from service', traceback.format_exc()) except: return Verdict.DOWN('Invalid response from service', traceback.format_exc()) try: messages = resp['messages'] message = list( filter(lambda m: int(m['id']) == int(message_id), messages)) if len(message) != 1: return Verdict.CORRUPT('Invalid messages count', f'with id: {message_id}') message_content = message[0]['text'] except: return Verdict.CORRUPT('Invalid response from service', traceback.format_exc()) try: resp = await api.get_chats() if 'chats' not in resp: return Verdict.MUMBLE('Invalid contract in chats listing', 'invalid data') chats = resp['chats'] if not chat_in_chats(chats, chat_id): return Verdict.MUMBLE('Can not find chat in chats', 'invalid /chats') except: return Verdict.DOWN('Invalid response from service', traceback.format_exc()) if message_content != request.flag: return Verdict.CORRUPT( 'Invalid flag', f'{request.flag}, message content: {message_content}') return Verdict.OK()
def upload_file_to_step(api: Api, run_id: int, file_path: str) -> bool: """ Finds a run by the provided run ID and uploads the provided file to the first step of that run. Args: api (Api): API instance to send authenticated requests file_path (str): The path of the file to upload to the step Returns: bool: True if the upload succeeded """ # Get the run you want to upload to, so we can find the step to upload to r = api.request({ 'query': queries.GET_RUN, 'variables': {'id': run_id} }) run = r['data']['run'] first_step = run['steps'][0] # Get the target URL we can upload our file to by using the # createFileAttachment API mutation. We are making the request against # the step's entityId, which is how files are associated to objects in ion attachment_data = { 'input': { 'entityId': first_step['entityId'], 'filename': os.path.basename(file_path) } } upload_request = api.request({ 'query': queries.CREATE_FILE_ATTACHMENT, 'variables': attachment_data }) url = upload_request['uploadUrl'] # Now, let's upload the file! r = requests.put(url, data=open(file_path, 'rb')) return r.ok
def sploit2(hostname: str) -> list: api = Api(hostname) username = get_random_string() api.sing_up(username, get_random_string(), get_random_string(), get_random_string()) token = api.generate_token() flags = [] for page_n in range(0, 5): users_list = api.api_get_users(token, page_n) for user in users_list: api.add_friend(user["username"]) r = api.get_user_barks(user["username"]) if r: flags += get_flags(r.text) if not users_list: break return flags