def test_authenticate_created_account():
# there is a user device
device_id = fake(schema.string.non_empty)
# with this device user creates an account and receives token
create_account_response = API().create_account(device_id=device_id)
assert create_account_response.status_code == 200
created_account = create_account_response.json()
created_account_token = created_account['token']
# with received token user authenticates an account
authenticate_account_response = API(
created_account_token).authenticaticate_account(
username=fake(schema.string.non_empty),
password=fake(schema.string.non_empty),
device_id=device_id)
assert authenticate_account_response.status_code == 200
authenticated_account = authenticate_account_response.json()
decoded_auth_token = decode_token(authenticated_account['token'])
# profileId from a decoded authentication token matches profileId from a created account
assert decoded_auth_token['profileId'] == created_account['profileId']
# and an account state is not automatically approved
assert decoded_auth_token['accountState'] == 'pending_approval'
def index():
"""
Main add-on popup
:return:
"""
api = API()
# check if current window is arwork or intro:
window_id = getCurrentWindowDialogId()
window = WindowDialog(window_id)
if isinstance(window, IntroWindow) or isinstance(window, ArtworkWindow):
log('Either IntroWindow or ArtworkWindow are already open')
else:
intro_window = IntroWindow(api)
intro_window.doModal()
section_id = intro_window.getProperty('section')
if section_id:
section_id = int(section_id)
category_id = int(intro_window.getProperty('category'))
del intro_window
if section_id == 1: # channels
show_channels(
section_id,
category_id) if section_id != 99 else show_favorites()
elif section_id == 3: # atmospheres
show_categories(section_id)
else:
show_favorites() # favorites
else:
del intro_window
def onStart(self):
self.debugging = Parameters["Mode6"]
if self.debugging == "Verbose":
Domoticz.Debugging(2 + 4 + 8 + 16 + 64)
if self.debugging == "Debug":
Domoticz.Debugging(2)
DumpConfigToLog()
Domoticz.Log("Chirpstack2Domoticz Plugin started")
#App ID Base TOPIC
if (Parameters["Mode1"].strip() != ""):
self.base_topic = "application/" + Parameters["Mode1"].strip()
else:
Domoticz.Log(
"Warning : No Application ID submitted. It will subscribe to all application topics"
)
self.base_topic = "application"
self.subscribed_for_devices = False
self.create_new_devices = Parameters["Mode2"].strip()
mqtt_server_address = Parameters["Address"].strip()
mqtt_server_port = Parameters["Port"].strip()
mqtt_client_id = Parameters["Mode3"].strip()
self.mqttClient = MqttClient(mqtt_server_address, mqtt_server_port,
mqtt_client_id, self.onMQTTConnected,
self.onMQTTDisconnected,
self.onMQTTPublish, self.onMQTTSubscribed)
self.api = API(Devices, self.publishToMqtt)
def mouseDoubleClickEvent(self, QMouseEvent):
api = API(self.session, self.token)
response = api.wall.delete(post_id=self.post_id)
if response['response'] == 1:
self.deleteLater()
print('Response by delete post', response)
def test_create_and_compose():
api = API('http://pythoncanarias.es/api/v1')
assert isinstance(api, API)
assert isinstance(api.status, API)
assert len(api.status.path) == 1
assert api.status.path == ['status']
assert api.status.get_url() == 'http://pythoncanarias.es/api/v1/status'
def __init__(self, consumer_key, consumer_secret, connection_params=None):
self.scheme = 'http'
self.host = 'localhost'
#self.host = 'indivo.genepartnership.org'
#self.host = 'indivo-staging.informedcohort.org'
#self.host = 'indivobig.genepartnership.org'
#self.host = 'x-staging.indivo.org'
self.port = '8000'
if connection_params:
if connection_params.has_key('scheme'):
self.scheme = connection_params['scheme']
if connection_params.has_key('host'):
self.host = connection_params['host']
if connection_params.has_key('port'):
self.port = connection_params['port']
if self.scheme and self.host and self.port:
self.utils_obj = IUtils(self.scheme, self.host, self.port)
else:
raise APIConnectorError("Scheme, host, port needed")
self.api = API(self.utils_obj)
self.ds = DataStore()
self.ds.reset()
self.ds.app_info['consumer_key'] = consumer_key
self.ds.app_info['consumer_secret'] = consumer_secret
self.count = 0
def __init__(self, parent=None, session=None, token=None):
QWidget.__init__(self, parent)
self.pixmap = QtGui.QPixmap()
self.api = API(session, token)
self.nameLayout = QHBoxLayout()
self.icon = QLabel()
self.name = QLabel()
self.id = 0
self.deletGroup = QPushButton('Del')
self.nameLayout.addWidget(self.icon, 0)
self.nameLayout.addWidget(self.name, 1)
self.nameLayout.addWidget(self.deletGroup, 2, QtCore.Qt.AlignRight)
self.frame = QFrame()
self.frame.setFrameShape(QFrame.Panel)
self.frame.setFrameShadow(QFrame.Raised)
self.frame.setLayout(self.nameLayout)
self.mainLayout = QVBoxLayout()
self.mainLayout.addWidget(self.frame)
self.setLayout(self.mainLayout)
self.name.setStyleSheet('''color: rgb(60, 50, 130);''')
self.frame.setStyleSheet('''background-color:rgb(255, 255, 255);''')
self.deletGroup.clicked.connect(self.delete)
def do_POST(self):
self.send_response(200)
self.send_header('Content-type', 'text-html')
self.end_headers()
length = int(self.headers['Content-Length'])
post_body = self.rfile.read(length).decode('utf-8')
post_body = json.loads(post_body)
req_id = post_body['request_id']
audio_name = req_id
resp = post_body['response']
if self.path.startswith('/denoise/emotion'):
my_api = API(API_KEY, URL)
filename = self.__denoise(audio_name, resp)
my_api.get_emotion(filename)
self.wfile.write(json.dumps(post_body).encode())
elif self.path.startswith('/denoise'):
self.__denoise(audio_name, resp)
self.wfile.write(json.dumps(post_body).encode())
elif self.path.startswith('/emotion'):
emotions, sorted_emotions = self.__emotion(resp)
print('emotion from audio:', audio_name)
for item in sorted_emotions:
print(item[0] + ':', item[1])
self.wfile.write(json.dumps(post_body).encode())
else:
self.wfile.write(bytes("oi", "utf8"))
return
async def check_service(request: CheckRequest) -> Verdict:
async with API(request.hostname) as api:
try:
creds = get_reg_creds()
status = await api.registration(creds)
if status != 302:
print(f'REGISTRATION: Wait 302, but return {status}')
return Verdict.MUMBLE("Registration error")
status = await api.update_user({
"login": creds['login'],
"additionalInfo": grs(25)
})
if status != 200:
print(f'UPDATE USER: Wait 200, but return {status}')
return Verdict.MUMBLE("Can't update user")
status, res_json = await api.create_planner(get_planner())
if status != 201 and len(res_json) != 0:
print(
f'CREATE PANNER: Wait 201 with not empty json, but return {status} with {res_json}'
)
return Verdict.MUMBLE("Can't create planner")
planner_id = res_json['id']
status = await api.create_task(planner_id, get_task())
if status != 201:
print(f'CREATE TASK: Wait 201, but return {status}')
Verdict.MUMBLE("Can't create task")
except Exception as ex:
print(traceback.format_exc())
return Verdict.DOWN('DOWN')
return Verdict.OK()
async def put_second_flag_into_the_service(request: PutRequest) -> Verdict:
async with API(request.hostname) as api:
try:
creds = get_reg_creds()
status = await api.registration(creds)
if status != 302:
print(f'ON PUT 2 REGISTRATION: Wait 302, but return {status}')
return Verdict.MUMBLE("Registration error")
planner = get_planner()
status, planner = await api.create_planner(planner)
if status != 201 or len(planner) == 0:
print(f'ON GET 2 GET PLANNER: Wait 201, but return {status}')
return Verdict.MUMBLE("Can't create planner")
status, text = await api.get_planners()
planner_id = planner["id"]
if status != 200 or len(text.split(f'<tr id="{planner_id}">')) < 1:
print(f'ON GET 2 GET PLANNERS: Wait 200, but return {status}')
return Verdict.MUMBLE("Can't get planner")
task = get_task()
task['description'] = request.flag
status = await api.create_task(planner_id, task)
if status != 201:
print(f'ON GET 2 CREATE TASK: Wait 201, but return {status}')
Verdict.MUMBLE("Can't create task")
except Exception as ex:
print(traceback.format_exc())
return Verdict.DOWN('DOWN')
return Verdict.OK(f"{creds['login']}:{creds['password']}:{planner['id']}")
async def exploit():
login = os.urandom(5).hex()
flag = os.urandom(10).hex() + '=='
async with API(HOSTNAME) as api:
pub_key = await get_pub_key(api, login)
s, h = await put_flag(api, login, flag)
print('Real signature:', s.hex())
print('Flag:', flag)
parts = list(split_message(h, 8, 18))
signature = split_signature(s, 16 * 2)
fake_signature = []
for i in range(len(parts) - 2):
test_flag = await brute(i, parts)
test_s, test_h = await put_flag(api, login, test_flag)
fake_signature.append(split_signature(test_s, 16 * 2)[i])
fake_signature.extend(split_signature(test_s, 16 * 2)[-2:])
fake_signature = b''.join(fake_signature)
print('Fake signature:', fake_signature.hex())
print('Recovered?', fake_signature == s)
recovered_flag = await get_flag(api, login, fake_signature.hex(),
h.hex())
print('Flag from service:', recovered_flag)
async def get_flag(request: GetRequest) -> Verdict:
fuel_id = request.flag_id
meat = flag_meat()
index = randint(0, len(meat) - 1)
payload = meat[:index] + request.flag + meat[index:]
result = f'{request.flag} ({index} -> {index + len(request.flag) - 1})'
async with API(request.hostname) as api:
try:
status, fuel_ids = await api.list_fuel()
except Exception as ex:
return Verdict.DOWN('Connection error', traceback.format_exc())
if status != 200 or fuel_id not in fuel_ids:
return Verdict.CORRUPT('Can\'t find fuel', f'Status: {status}')
try:
status, response = await api.check_fuel_property(fuel_id, payload)
except Exception as ex:
return Verdict.DOWN('Connection error', traceback.format_exc())
if status != 200 or response != result:
return Verdict.CORRUPT('Can\'t check property',
f'Status: {status}')
return Verdict.OK()
def do_GET(self):
path = self.path
api = API(path, self.headers)
options = api.options
params = api.params
try:
processed_params = api.preprocess_params(params, **options)
result = api.execute_request(path, **processed_params)
result = api.postprocess_result(result, **options)
response = api.generate_response(result, path, **processed_params)
except OptionsException as options_exception:
return self.yell(body=bytes(options_exception))
except PermissionsException:
return self.do_AUTHHEAD()
except ExecutionException as execution_exception:
return self.yell(
status_code=execution_exception.status_code,
body=bytes(execution_exception)
)
return self.respond(body=bytes(response))
def main():
uvicorn.run(
app=API(),
host=config.HOST,
port=config.PORT,
log_level=config.LOG_LEVEL
)
def show_categories(section_id):
"""
Categories page
:param section_id: Selected section ID
:return:
"""
api = API()
for item in api.get_categories(int(section_id)):
# list item:
li = ListItem(
item['name'].capitalize(),
iconImage='{0}/{1}'.format(config['urls']['calm_arts_host'],
item['image']),
thumbnailImage='{0}/{1}'.format(config['urls']['calm_arts_host'],
item['image']))
li.setArt({
'fanart':
'{0}{1}'.format(config['urls']['calm_blurred_arts_host'],
item['image'])
})
# directory item:
addDirectoryItem(
PLUGIN.handle,
PLUGIN.url_for(show_channels,
section_id=section_id,
category_id=item['id']), li, True)
# end of directory:
endOfDirectory(PLUGIN.handle)
executebuiltin('Container.SetViewMode({0})'.format(
config['viewmodes']['thumbnail'][getSkinDir() if getSkinDir(
) in config['viewmodes']['thumbnail'] else 'skin.confluence']))
def save_macaddress():
mac_local = RpiDatabase().get_all_mac()
mac_server = API().get_server(api['Macaddress'])
lcd_.teks(text1='MENGAMBIL', text2='DATA', text3='MACADDRESS')
time.sleep(1.2)
if mac_server is 'ServerConnectionError' or mac_server is None:
#tampilkan bahwa koneksi error
lcd_.teks(text1='GAGAL', text2='MENGAMBIL', text3='DATA MACADDRESS')
time.sleep(1.2)
else:
for progress, mac_server_ in enumerate(mac_server):
lcd_.progress_bar(progress + 1,
len(mac_server),
text="CHECKING MAC")
lcd_.disp.image(lcd_.image)
lcd_.disp.display()
#check_macaddress_exists
if RpiDatabase().is_macaddress_registered(
mac_server_['macaddress']):
# print 'mac terdaftar'
continue
else:
# print 'mendaftarkan'+mac_server_['macaddress']
RpiDatabase().insert('macaddress', 'mac_',
mac_server_['macaddress'])
def __init__(self, wrapper):
self.wrapper = wrapper
self.api = API(wrapper, "Web", internal=True)
self.log = log.PluginLog(self.wrapper.log, "Web")
self.config = wrapper.config
self.socket = False
self.data = storage.Storage("web", self.log)
if "keys" not in self.data: self.data["keys"] = []
#if not self.config["Web"]["web-password"] == None:
# self.log.info("Changing web-mode password because web-password was changed in wrapper.properties")
# self.data["password"] = md5.md5(self.config["Web"]["web-password"]).hexdigest()
# self.config["Web"]["web-password"] = None
# self.wrapper.configManager.save()
self.api.registerEvent("server.consoleMessage", self.onServerConsole)
self.api.registerEvent("player.message", self.onPlayerMessage)
self.api.registerEvent("player.join", self.onPlayerJoin)
self.api.registerEvent("player.leave", self.onPlayerLeave)
self.api.registerEvent("irc.message", self.onChannelMessage)
self.consoleScrollback = []
self.chatScrollback = []
self.memoryGraph = []
self.loginAttempts = 0
self.lastAttempt = 0
self.disableLogins = 0
def task1():
email = EMail()
body = """
<h1>测试图片</h1>
<img src="cid:image1"/> # 引用图片
"""
try:
driver = webdriver.Remote('http://localhost:4723/wd/hub', desired_caps1)
driver.implicitly_wait(10)
api = API(driver)
element = api.isElement(By.ID, 'et_pwd_login')
if element:
driver.find_element(by=By.ID, value='et_pwd_login').send_keys('lihang1988')
driver.find_element(by=By.ID, value='btn_next').click()
time.sleep(3)
driver.save_screenshot('UEUNW17221002815.png')
email.send_mail('打卡成功', content='打卡截图', image_body=body, image='UEUNW17221002815.png')
except:
email.send_mail('打开失败了，赶紧找人吧！')
time.sleep(2)
driver.quit()
def all(cls, project_id, language, flags):
api = API(project_id, language, flags)
accounts = api.accounts()
num_accounts = len(accounts)
ac_ctr = 1
for account in accounts:
logging.info("Processing account {} of {}...".format(
ac_ctr, num_accounts))
account_name = account.get("name")
locations = api.locations(account_name)
num_locations = len(locations)
loc_ctr = 1
for location in locations:
logging.info("Processing location {} of {}...".format(
loc_ctr, num_locations))
location_name = location.get("name")
if flags[INSIGHTS]:
api.insights(location_name)
if flags[DIRECTIONS]:
api.directions(location_name)
if flags[HOURLY_CALLS]:
api.hourly_calls(location_name)
if flags[REVIEWS]:
api.reviews(location_name)
loc_ctr = loc_ctr + 1
ac_ctr = ac_ctr + 1
if flags[SENTIMENT]:
api.sentiments()
def task2():
email = EMail()
body = """
<h1>测试图片</h1>
<img src="cid:image1"/> # 引用图片
"""
try:
driver = webdriver.Remote('http://*****:*****@qq.com', image_body=body, image='64de8478.png')
except:
email.send_mail('打开失败了，赶紧找人吧！')
time.sleep(2)
driver.quit()
def __init__(self, parent=None, session=None, token=None):
super().__init__(parent, Qt.Window)
self.sizeMonitor = QApplication.desktop().availableGeometry()
self.setGeometry(self.sizeMonitor.width() / 6, 0,
(2 * self.sizeMonitor.width()) / 3,
self.sizeMonitor.height())
myForm = QFormLayout()
# Create scroll and put in general layout
scrollWidget = QWidget()
scrollWidget.setLayout(myForm)
scroll = QScrollArea()
scroll.setWidget(scrollWidget)
scroll.setWidgetResizable(True)
layout = QVBoxLayout(self)
layout.addWidget(scroll)
downloader = DownloadDecorator(session)
api = API(session, token)
groups = api.groups.get(extended=1)
for group in groups['response']['items']:
downloader(group["photo_100"], 'None', 'group', group['name'],
group['id'])
download = downloader.download()
for item in download:
g = Group(session=session, token=token)
g.setGroup(item[0].content, item[3][0], item[3][1])
myForm.addWidget(g)
self.show()
def validar(self):
clear = lambda: os.system('cls')
clear()
self.list.delete(0, END)
self.w.delete("all")
self.dibujar()
eng = pyttsx3.init()
voices = eng.getProperty('voices') #para reproducir la voz
eng.setProperty('voice', voices[1].id)
eng.setProperty('rate', 118)
try:
if len(self.palabra.get())%2 == 0:
automata = APP("ab", self)
aux = automata.crear_matriz()
self.isPalindromePar(aux, "ab", self.palabra.get())
else:
automata = API("ab", "c", self)
aux = automata.crear_matriz()
self.isPalindromeImpar(self.palabra.get(), aux, "ab")
self.list.insert(END, "Palabra Aceptada")
eng.say("palabra aceptada")
eng.runAndWait()
except:
self.list.insert(END, "Palabra No Aceptada")
print(False)
eng.say("palabra no aceptada")
eng.runAndWait()
def run_server(self):
app = web.Application(middlewares=[])
self.api = API(self.network_id, self.tx_storage)
routes = {
'/api/v1/leaderboard': self.api.handler_leaderboard,
'/api/v1/progress': self.api.handler_sync_progress
}
for route, handler in routes.items():
app.add_routes([web.get(route, handler)])
# run bg tasks
cfg = self.cfg.get('thorchain')
app.on_startup.append(self.init_db)
if bool(cfg.get('scanner.tx.enabled', True)):
app.on_startup.append(self.run_scanner)
else:
logging.info('Scanner is disabled by Config')
if bool(cfg.get('value_filler.enabled', True)):
app.on_startup.append(self.run_fill_job)
else:
logging.info('Value filler is disabled by Config')
api_port = int(self.cfg.get('api.port', 5000))
web.run_app(app, port=api_port)
def push_all_jobs(sample_order):
"""get jobs for all cities, then push to download queue."""
job_api = API()
ok, summaries = job_api.summary()
if not ok:
return [0]
return [push_city_jobs(s['city'], sample_order) for s in summaries]
def populateAPIs(self, count=10):
"""
"apiDefinition": "{ \"paths\": { \"/*\": { \"get\": { \"description\": \"Global Get\" } } }, \"swagger\": \"2.0\" }",
"cacheTimeout": 10,
"transport": ["https"],
"policies": ["Unlimited"],
"visibility": "PUBLIC",
"businessInformation": {},
"corsConfiguration": {}
:param count:
:return:
"""
template = {
"name": None,
"context": None,
"version": "1.0.0",
"service_url": "http://sample.knnect.com/api/endpoint",
"description": "",
"wsdlUri": "http://www.webservicex.com/globalweather.asmx?wsdl",
"isDefaultVersion": True,
"responseCaching": "Disabled",
"cacheTimeout": 300,
"destinationStatsEnabled": "Disabled",
"businessInformation": {
"businessOwner": "Kasun Thennakoon",
"businessOwnerEmail": "*****@*****.**",
"technicalOwner": "Knnect",
"technicalOwnerEmail": "*****@*****.**"
},
"tags": [
"test_tag1",
"fintech"
],
"transport": [
"http",
"https"
],
"visibility": "PUBLIC",
"securityScheme": [
"string"
],
"scopes": [
"string"
],
}
policies = ["Gold", "Silver", "Bronze"]
apis = []
for index in range(count):
random_char = random.choice(
string.ascii_lowercase) + random.choice(string.ascii_lowercase)
name_context = "{}_sample_{}".format(random_char, index)
template['name'] = name_context
template['description'] = "A Sample API for testing APIM 3.0 " + name_context
template['context'] = "/" + name_context
api = API(**template)
api.set_rest_client(self.client)
api.save()
api.set_policies(policies)
apis.append(api)
return apis
async def check_service(request: CheckRequest) -> Verdict:
async with API(request.hostname) as api:
try:
await api.health_check()
except Exception as ex:
return Verdict.DOWN('', traceback.format_exc())
return Verdict.OK()
def main():
os.listdir(os.getenv('BASEPATH_DATA'))
# db
db = MONGODB[os.getenv('MONGODB_DATABASE')]
db.command('ping')
# api
api = API(**settings.API)
# parse
WpPreparator.process('/data/wp_sample.xml', db)
# import
images = importer.ImageImporter(db, api)
failed_images = images.upload_all()
print(len(failed_images))
authors = importer.AuthorsImporter(db, api)
failed_authors = authors.upload_all()
print(len(failed_authors))
sections = importer.SectionsImporter(db, api)
failed_sections = sections.upload_all()
print(len(failed_sections))
posts = importer.PostsImporter(db, api)
failed_posts = posts.upload_all()
print(len(failed_posts))
async def get_flag_lwe(request: GetRequest) -> Verdict:
login, note_hash, signature = request.flag_id.split(':')
algo = 'lwe'
async with API(request.hostname) as api:
try:
users = await api.get_users()
if login not in users['users']:
return Verdict.MUMBLE('No user', 'No user')
except Exception as e:
return Verdict.MUMBLE("Can't get users", traceback.format_exc())
try:
notes = await api.get_notes(algo, login)
if note_hash not in notes['notes']:
return Verdict.MUMBLE('No note', 'No note')
except Exception as e:
return Verdict.MUMBLE("Can't get notes", traceback.format_exc())
try:
pub_key = await api.get_pub_key(algo, login, note_hash)
pub_key = list(list(map(int, x.split(','))) for x in b64decode(pub_key['pub_key']).decode().split(';'))
except Exception as e:
return Verdict.MUMBLE("No public key", traceback.format_exc())
try:
verified = await api.verify(algo, login, signature, note_hash)
flag = verified['data']
except Exception as e:
return Verdict.MUMBLE("Can't validate", traceback.format_exc())
if flag != request.flag:
return Verdict.MUMBLE('Wrong data')
return Verdict.OK()
def set_access_token(self, access_token, expires):
'''
set access_token and expires time to this instance
'''
self.access_token = access_token
self.expires = float(expires)
self.api = API(access_token, self.client_secret)
def process(self, url):
""" Downloads all requested files from specified server """
self.ignored = 0
self.not_selected = 0
self.processed = 0
api = API(url, self.user, self.password)
if self.recording_id:
recording = api.get(self.recording_id).get("recording")
self._download(recording, api, Path(self.out_folder))
return
print("Querying server {0}".format(url))
print("Limit is {0}".format(self.limit))
print("Tag mode {0}".format(self.tag_mode))
print("Dates are {0} - {1}".format(self.start_date, self.end_date))
print("Required tags are {0}".format(self.only_tags))
print("Ignore tags are {0}".format(self.ignore_tags))
rows = api.query(
limit=self.limit,
startDate=self.start_date,
endDate=self.end_date,
tagmode=self.tag_mode,
tags=self.only_tags,
)
if self.auto_delete:
self.update_file_locations()
pool = Pool(self.workers, self._downloader, api, Path(self.out_folder))
for row in rows:
pool.put(row)
pool.stop()
