def delete(cls, url, params=None, retries=None, proxies=None, verify=None):
"""
Send a DELETE request.
:param url: The URL to send the DELETE request to.
:type url: str
:param params: The DELETE parameters to send in the request.
:type params: dict
:param retries: Number of retries before stopping.
:type retries: int
:param proxies: proxy info for requests.
:type proxies: dict
:param verify: verify info for requests.
:type verify: bool, str
:returns: dict (using json.loads())
"""
if not params:
params = dict()
if proxies is None:
proxies = get_proxies()
if verify is None:
verify = get_verify()
params[t.ACCESS_TOKEN] = get_access_token()
session = cls.build_session(retries)
resp = session.delete(url,
params=params,
proxies=proxies,
verify=verify)
return cls.handle_results(resp)
def delete(cls, url, params=None, retries=None, headers=None, proxies=None, verify=None):
"""
Send a DELETE request.
:param url: The URL to send the DELETE request to.
:type url: str
:param params: The DELETE parameters to send in the request.
:type params: dict
:param retries: Number of retries before stopping.
:type retries: int
:param headers: header info for requests.
:type headers: dict
:param proxies: proxy info for requests.
:type proxies: dict
:param verify: verify info for requests.
:type verify: bool, str
:returns: dict (using json.loads())
"""
if not params:
params = dict()
if headers is None:
headers = get_headers()
if proxies is None:
proxies = get_proxies()
if verify is None:
verify = get_verify()
params[t.ACCESS_TOKEN] = get_access_token()
session = cls.build_session(retries)
resp = session.delete(url, params=params, headers=headers, proxies=proxies, verify=verify)
return cls.handle_results(resp)
def download_voice(VoiceMsg, filename):
url = 'https://api.weixin.qq.com/cgi-bin/media/get'
token = access_token.get_access_token()
print('MediaId:' + VoiceMsg.MediaId)
params = {'access_token': token, 'media_id': VoiceMsg.MediaId}
r = requests.get(url, params=params)
new_filename = 'SpeakerRecognition/audio/tmp/' + filename + '.amr'
with open(new_filename, 'wb') as file:
file.write(r.content)
return new_filename
def upload_temp_image(filename):
token = access_token.get_access_token()
url = 'https://api.weixin.qq.com/cgi-bin/media/upload'
file = open(filename, 'rb')
params = {'access_token': token, 'type': 'image'}
files = {'media': file}
r = requests.post(url, params=params, files=files)
#print(r.text)
mediaId = json.loads(r.text)['media_id']
return mediaId
def get(cls, url, params=None):
"""
Send a GET request.
:param url: The URL to send the GET request to.
:type url: str
:param params: The GET parameters to send in the request.
:type params: dict
:returns: dict (using json.loads())
"""
if not params:
params = dict()
params[t.ACCESS_TOKEN] = get_access_token()
resp = requests.get(url, params=params)
return cls.handle_results(resp)
def get(cls, url, params=None):
"""
Send a GET request.
:param url: The URL to send the GET request to.
:type url: str
:param params: The GET parameters to send in the request.
:type params: dict
:returns: dict (using json.loads())
"""
if not params:
params = dict()
params[t.ACCESS_TOKEN] = get_access_token()
resp = requests.get(url, params=params)
return cls.handle_results(resp)
def spark_pool_metrics_by_workspace(workspace_config, workspace_context):
if not workspace_config.enable_spark_pools_metadata_metrics:
return
if not workspace_context or time.time() - workspace_context.get(
'spark_pool_metrics_token_refresh_time',
0) >= workspace_config.token_refresh_interval_sec:
try:
print('refreshing token for spark pool metrics...')
bearer_token = access_token.get_access_token(
workspace_config.service_principal_name,
workspace_config.service_principal_password,
workspace_config.tenant_id,
workspace_config.azure_management_resource_uri)
workspace_context['spark_pool_metrics_token_refresh_time'] = int(
time.time())
workspace_context['spark_pool_metrics_bearer_token'] = bearer_token
print('token refreshed for spark pool metrics.')
except:
traceback.print_exc()
bearer_token = workspace_context.get('spark_pool_metrics_bearer_token')
if bearer_token and time.time() - workspace_context.get(
'spark_pool_metrics_time', 0) >= 300:
workspace_context['spark_pool_metrics_time'] = int(time.time())
try:
spark_pools_info = spark_pools.get_spark_pools(
workspace_config.subscription_id,
workspace_config.resource_group,
workspace_config.workspace_name, bearer_token)
for sp in spark_pools_info:
metrics.spark_pool_info.labels(
workspace_name=workspace_config.workspace_name,
spark_pool_name=sp.name,
location=sp.location,
spark_version=sp.spark_version,
node_count=str(sp.node_count),
node_size=str(sp.node_size),
provisioning_state=str(sp.provisioning_state),
auto_scale_enabled=str(sp.auto_scale_enabled),
node_cpu_cores=str(sp.node_cpu_cores),
node_memory_size=str(sp.node_memory_size),
).set(1)
except:
traceback.print_exc()
def get(cls, url, params=None, retries=None):
"""
Send a GET request.
:param url: The URL to send the GET request to.
:type url: str
:param params: The GET parameters to send in the request.
:type params: dict
:param retries: Number of retries before stopping.
:type retries: int
:returns: dict (using json.loads())
"""
if not params:
params = dict()
params[t.ACCESS_TOKEN] = get_access_token()
session = cls.build_session(retries)
resp = session.get(url, params=params)
return cls.handle_results(resp)
def token_refresh_by_workspace(workspace_config, workspace_context):
if not workspace_context or time.time() - workspace_context.get(
'token_refresh_time',
0) >= workspace_config.token_refresh_interval_sec:
metrics.token_refresh_count.labels(
workspace_name=workspace_config.workspace_name).inc()
try:
print('refreshing token...')
bearer_token = access_token.get_access_token(
workspace_config.service_principal_name,
workspace_config.service_principal_password,
workspace_config.tenant_id, workspace_config.resource_uri)
workspace_context['token_refresh_time'] = int(time.time())
workspace_context['bearer_token'] = bearer_token
print('token refreshed.')
metrics.token_refresh_last_time.labels(
workspace_name=workspace_config.workspace_name).set(
int(time.time()))
except:
metrics.token_refresh_failed_count.labels(
workspace_name=workspace_config.workspace_name).inc()
traceback.print_exc()
def get_ocr(img, ci, ck):
try:
url = 'https://aip.baidubce.com/rest/2.0/ocr/v1/general_basic?access_token=' + access_token.get_access_token(ci, ck)
headers = { 'Content-Type': 'application/x-www-form-urlencoded' }
params = {
'image': img,
'language_type': 'CHN_ENG',
'detect_language': 'false',
'probability': 'false'
}
params = urllib.urlencode(params)
request = urllib2.Request(url=url, data=params)
request.add_header('Content-Type', 'application/x-www-form-urlencoded')
response = urllib2.urlopen(request)
content = response.read()
return [True, content]
except Exception as e:
return [False, e]
def get_ocr(img, ci, ck):
try:
url = 'https://aip.baidubce.com/rest/2.0/ocr/v1/general_basic?access_token=' + access_token.get_access_token(
ci, ck)
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
params = {
'image': img,
'language_type': 'CHN_ENG',
'detect_language': 'false',
'probability': 'false'
}
params = urllib.urlencode(params)
request = urllib2.Request(url=url, data=params)
request.add_header('Content-Type', 'application/x-www-form-urlencoded')
response = urllib2.urlopen(request)
content = response.read()
return [True, content]
except Exception as e:
return [False, e]
import requests
from access_token import get_access_token
from config import Config
from encode_pass import get_password
from time_formart import get_time_stamp
BusinessShortCode = Config["BUSINESS_SHORT_CODE"]
shortcode = Config["Lipa Na Mpesa Online Shortcode"]
phone_number = Config["PHONE_NUMBER"]
timestamp = get_time_stamp()
password = get_password(timestamp)
access_token = get_access_token()
def lipa_na_mpesa():
api_url = "https://sandbox.safaricom.co.ke/mpesa/stkpush/v1/processrequest"
headers = {"Authorization": "Bearer %s" % access_token}
request = {
"BusinessShortCode": shortcode,
"Password": password,
"Timestamp": timestamp,
"TransactionType": "CustomerPayBillOnline",
"Amount": 2,
"PartyA": phone_number,
"PartyB": shortcode,
"PhoneNumber": phone_number,
"CallBackURL": "https://pizzaorder.com/callback",
"AccountReference": "01 ",
"TransactionDesc": "orderprize "
}
import sys
import database
from SpeakerRecognition import *
import json
import requests
import access_token
if __name__ == '__main__':
toUser = sys.argv[1]
fromUser = sys.argv[2]
new_filename = sys.argv[3]
token = access_token.get_access_token()
subscription_key = '20f920b168a241b9992fd0b1dc1bf664'
ConvertFileFormat.convert(new_filename)
new_filename = new_filename.split('.')[0] + '.wav'
ids = database.get_voice_ids()
speakerID = IdentifyFile.identify_file(subscription_key, new_filename,
'true', ids)
speaker_name = database.from_voiceid_to_name(speakerID)
url = 'https://api.weixin.qq.com/cgi-bin/message/custom/send'
params = {'access_token': token}
send_json = {
"touser": toUser,
"msgtype": "text",
"text": {
"content": speaker_name
}
def submit(cls,
*args,
**kwargs):
"""
Submit batch request. All non-named args are considered to be
dictionaries containing the following:
type: The request type (GET, POST, etc.).
url: The full or relative URL for the API call.
body: If the type is POST this is the body that will be used.
If you use "method" instead of "type" and/or "relative_urL" instead of
"url" (which is accurate to the Graph API) we will use them
appropriately.
If you pass a named argument, we will consider the name as the name you
wish to include in that specific request. This is useful for referencing
a request in another request in the Batch (see FB documentation).
The following named args are considered to be the options below.
:param include_headers: Include headers in response.
:type include_headers: bool
:param omit_response: Omit response on success.
:type omit_response: bool
:param retries: Number of retries before stopping.
:type retries: int
:param headers: header info for requests.
:type headers: dict
:param proxies: proxy info for requests.
:type proxies: dict
:param verify: verify info for requests.
:type verify: bool, str
:returns: dict (using json.loads())
"""
batch = []
retries = kwargs.get('retries', None)
if retries:
del kwargs['retries']
headers = kwargs.get('headers', None)
if headers:
del kwargs['headers']
proxies = kwargs.get('proxies', None)
if proxies:
del kwargs['proxies']
verify = kwargs.get('verify', None)
if verify:
del kwargs['verify']
include_headers = kwargs.get('include_headers', None)
if include_headers:
del kwargs['include_headers']
include_headers = Broker.sanitize_bool(include_headers)
omit_response = kwargs.get('omit_response', None)
if omit_response:
del kwargs['omit_response']
omit_response = Broker.sanitize_bool(omit_response)
for arg in args:
batch.append(Batch.prepare_single_request(arg))
for key, value in kwargs.iteritems():
batch.append(Batch.prepare_single_request(value, name=key))
params = {t.ACCESS_TOKEN: get_access_token(),
t.BATCH: json.dumps(batch),
t.INCLUDE_HEADERS: include_headers,
t.OMIT_RESPONSE_ON_SUCCESS: omit_response}
try:
return Broker.post(t.URL,
params=params,
retries=retries,
headers=headers,
proxies=proxies,
verify=verify)
except:
raise pytxFetchError('Error with batch request.')
def submit(cls, *args, **kwargs):
"""
Submit batch request. All non-named args are considered to be
dictionaries containing the following:
type: The request type (GET, POST, etc.).
url: The full or relative URL for the API call.
body: If the type is POST this is the body that will be used.
If you use "method" instead of "type" and/or "relative_urL" instead of
"url" (which is accurate to the Graph API) we will use them
appropriately.
If you pass a named argument, we will consider the name as the name you
wish to include in that specific request. This is useful for referencing
a request in another request in the Batch (see FB documentation).
The following named args are considered to be the options below.
:param include_headers: Include headers in response.
:type include_headers: bool
:param omit_response: Omit response on success.
:type omit_response: bool
:param retries: Number of retries before stopping.
:type retries: int
:param headers: header info for requests.
:type headers: dict
:param proxies: proxy info for requests.
:type proxies: dict
:param verify: verify info for requests.
:type verify: bool, str
:returns: dict (using json.loads())
"""
batch = []
retries = kwargs.get('retries', None)
if retries:
del kwargs['retries']
headers = kwargs.get('headers', None)
if headers:
del kwargs['headers']
proxies = kwargs.get('proxies', None)
if proxies:
del kwargs['proxies']
verify = kwargs.get('verify', None)
if verify:
del kwargs['verify']
include_headers = kwargs.get('include_headers', None)
if include_headers:
del kwargs['include_headers']
include_headers = Broker.sanitize_bool(include_headers)
omit_response = kwargs.get('omit_response', None)
if omit_response:
del kwargs['omit_response']
omit_response = Broker.sanitize_bool(omit_response)
for arg in args:
batch.append(Batch.prepare_single_request(arg))
for key, value in kwargs.iteritems():
batch.append(Batch.prepare_single_request(value, name=key))
params = {
t.ACCESS_TOKEN: get_access_token(),
t.BATCH: json.dumps(batch),
t.INCLUDE_HEADERS: include_headers,
t.OMIT_RESPONSE_ON_SUCCESS: omit_response
}
try:
return Broker.post(t.URL,
params=params,
retries=retries,
headers=headers,
proxies=proxies,
verify=verify)
except:
raise pytxFetchError('Error with batch request.')
