def doCreateProject(argv, arglist):
g_param = parse_global_arg(argv)
if "help" in argv:
show_help("CreateProject", g_param[OptionsDefine.Version])
return
param = {
"ProjectName": argv.get("--ProjectName"),
"ProjectOrg": argv.get("--ProjectOrg"),
"ProjectBudget": argv.get("--ProjectBudget"),
"ProjectIntroduction": argv.get("--ProjectIntroduction"),
"ProjectOrgId": argv.get("--ProjectOrgId"),
}
cred = credential.Credential(g_param[OptionsDefine.SecretId],
g_param[OptionsDefine.SecretKey])
http_profile = HttpProfile(
reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(
g_param[OptionsDefine.Timeout]),
reqMethod="POST",
endpoint=g_param[OptionsDefine.Endpoint])
profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
client = mod.SolarClient(cred, g_param[OptionsDefine.Region], profile)
client._sdkVersion += ("_CLI_" + __version__)
models = MODELS_MAP[g_param[OptionsDefine.Version]]
model = models.CreateProjectRequest()
model.from_json_string(json.dumps(param))
rsp = client.CreateProject(model)
result = rsp.to_json_string()
jsonobj = None
try:
jsonobj = json.loads(result)
except TypeError as e:
jsonobj = json.loads(result.decode('utf-8')) # python3.3
FormatOutput.output("action", jsonobj, g_param[OptionsDefine.Output],
g_param[OptionsDefine.Filter])
def doDescribeKeys(argv, arglist):
g_param = parse_global_arg(argv)
if "help" in argv:
show_help("DescribeKeys", g_param[OptionsDefine.Version])
return
param = {
"DrmType": Utils.try_to_json(argv, "--DrmType"),
"Tracks": Utils.try_to_json(argv, "--Tracks"),
"ContentType": Utils.try_to_json(argv, "--ContentType"),
"RsaPublicKey": Utils.try_to_json(argv, "--RsaPublicKey"),
"ContentId": Utils.try_to_json(argv, "--ContentId"),
}
cred = credential.Credential(g_param[OptionsDefine.SecretId],
g_param[OptionsDefine.SecretKey])
http_profile = HttpProfile(
reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(
g_param[OptionsDefine.Timeout]),
reqMethod="POST",
endpoint=g_param[OptionsDefine.Endpoint])
profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
client = mod.DrmClient(cred, g_param[OptionsDefine.Region], profile)
client._sdkVersion += ("_CLI_" + __version__)
models = MODELS_MAP[g_param[OptionsDefine.Version]]
model = models.DescribeKeysRequest()
model.from_json_string(json.dumps(param))
rsp = client.DescribeKeys(model)
result = rsp.to_json_string()
jsonobj = None
try:
jsonobj = json.loads(result)
except TypeError as e:
jsonobj = json.loads(result.decode('utf-8')) # python3.3
FormatOutput.output("action", jsonobj, g_param[OptionsDefine.Output],
g_param[OptionsDefine.Filter])
def check_accesstoken(cfg, args):
cred = credential.Credential(cfg.sys.ai.access_token.secret_id,
cfg.sys.ai.access_token.secret_key)
f_httpProfile = HttpProfile()
f_httpProfile.endpoint = cfg.sys.ai.face_search.endpoint
f_clientProfile = ClientProfile()
f_clientProfile.httpProfile = f_httpProfile
f_client = iai_client.IaiClient(cred, "ap-shanghai", f_clientProfile)
cfg.sys.ai.face_client = f_client
l_httpProfile = HttpProfile()
l_httpProfile.endpoint = cfg.sys.ai.license_plate.endpoint
l_clientProfile = ClientProfile()
l_clientProfile.httpProfile = l_httpProfile
l_client = ocr_client.OcrClient(cred, "ap-shanghai", l_clientProfile)
cfg.sys.ai.license_client = l_client
try:
# 实例化一个认证对象，入参需要传入腾讯云账户secretId，secretKey
cred = credential.Credential("", "")
# cred = credential.Credential(
# os.environ.get("TENCENTCLOUD_SECRET_ID"),
# os.environ.get("TENCENTCLOUD_SECRET_KEY"))
# 实例化一个http选项，可选的，没有特殊需求可以跳过。
httpProfile = HttpProfile()
httpProfile.reqMethod = "POST" # post请求(默认为post请求)
httpProfile.reqTimeout = 30 # 请求超时时间，单位为秒(默认60秒)
httpProfile.endpoint = "tci.tencentcloudapi.com" # 指定接入地域域名(默认就近接入)
httpProfile.keepAlive = True
# 实例化一个client选项，可选的，没有特殊需求可以跳过。
clientProfile = ClientProfile()
clientProfile.signMethod = "TC3-HMAC-SHA256" # 指定签名算法(默认为HmacSHA256)
clientProfile.unsignedPayload = True
clientProfile.httpProfile = httpProfile
client = tci_client.TciClient(cred, "", clientProfile)
req = models.CreateFaceRequest()
req.LibraryId = "tci_library_156403897035611372834"
req.PersonId = "tci_person_1564039695429032573626"
req.urls = ["https://img-blog.csdn.net/20161128171723259"]
resp = client.CreateFace(req)
# 输出json格式的字符串回包
print("%s" % resp.to_json_string())
except TencentCloudSDKException as err:
from tencentcloud.common.exception.tencent_cloud_sdk_exception import TencentCloudSDKException
from tencentcloud.asr.v20190614 import asr_client, models
import base64
import io
import sys
if sys.version_info[0] == 3:
sys.stdout = io.TextIOWrapper(sys.stdout.buffer,encoding='utf-8')
#本地文件方式请求
try:
#重要，此处<Your SecretId><Your SecretKey>需要替换成客户自己的账号信息，获取方法：
#https://cloud.tencent.com/product/asr/getting-started
cred = credential.Credential("AKIDX1GGzR5U9avzoPSmfKl79uNaaQ17nK2T", "IJ9l1D9oBH7oHWhbEaeS6VK4XjdKkz0t")
httpProfile = HttpProfile()
httpProfile.endpoint = "asr.tencentcloudapi.com"
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
clientProfile.signMethod = "TC3-HMAC-SHA256"
client = asr_client.AsrClient(cred, "ap-shanghai", clientProfile)
#读取文件以及 base64
#此处可以下载测试音频 https://asr-audio-1300466766.cos.ap-nanjing.myqcloud.com/test16k.wav
with open('./12.mp3', "rb") as f:
if sys.version_info[0] == 2:
content = base64.b64encode(f.read())
else:
content = base64.b64encode(f.read()).decode('utf-8')
#发送请求
req = models.SentenceRecognitionRequest()
params = {"ProjectId":0,"SubServiceType":2,"SourceType":1,"UsrAudioKey":"session-123", "RequestId": '1c8400f1-913f-4938-a45f-0421b08782ad' }
req._deserialize(params)
req.DataLen = len(content)
def main_handler(event, context):
logger.info("start main handler")
if "requestContext" not in event.keys():
return {"code": 410, "errorMsg": "event is not come from api gateway"}
if "body" not in event.keys():
return {
"isBase64Encoded": False,
"statusCode": 200,
"headers": {
"Content-Type": "text",
"Access-Control-Allow-Origin": "*"
},
"body": "there is no file from api gateway"
}
# save api gateway file to local temp file
logger.info("Start to download images from APIGW")
time = datetime.datetime.now()
file_name = '{}'.format(time) + "-test.jpg"
logger.info("file_name is : %s" % file_name)
local_path = u'/tmp/{}'.format(file_name)
logger.info("local_path is : %s" % local_path)
with open(local_path, 'w') as wfile:
wfile.write(base64.b64decode(event['body']))
# start to upload to cos
secret_id = os.environ.get('TENCENTCLOUD_SECRETID') # 使用环境变量中的 secretId
secret_key = os.environ.get('TENCENTCLOUD_SECRETKEY') # 使用环境变量中的 secretKey
token = os.environ.get('TENCENTCLOUD_SESSIONTOKEN')
config = CosConfig(
Region=bucket_region,
SecretId=secret_id,
SecretKey=secret_key,
Token=token,
)
cos_client = CosS3Client(config)
logger.info("Start to upload images to cos")
res_cos = cos_client.put_object_from_local_file(Bucket=bucket_upload,
LocalFilePath=local_path,
Key='{}'.format(file_name))
logger.info("upload to cos result is : %s" % res_cos)
# start to detection
logger.info("Start to detection")
try:
cred = credential.Credential(secret_id, secret_key, token)
httpProfile = HttpProfile()
httpProfile.endpoint = "ocr.tencentcloudapi.com"
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
client = ocr_client.OcrClient(cred, "ap-beijing", clientProfile)
req = models.GeneralBasicOCRRequest()
params = '{"ImageBase64":"%s"}' % event['body']
req.from_json_string(params)
resp = client.GeneralBasicOCR(req)
res_ai = json.loads(resp.to_json_string())
res_text = " "
print len(res_ai["TextDetections"])
for i in range(len(res_ai["TextDetections"])):
res_text = res_text + str(
res_ai["TextDetections"][i]["DetectedText"].encode('utf-8'))
except TencentCloudSDKException as err:
print(err)
delete_local_file(local_path)
response = {
"isBase64Encoded": False,
"statusCode": 200,
"headers": {
"Content-Type": "text",
"Access-Control-Allow-Origin": "*"
},
"body": res_text
}
return response
def login(self):
"""登录"""
print('正在登录…')
self.driver.get(self.kanaLink)
self.del_element(self.driver.find_element_by_class_name('redirect'))
usernameBox = self.driver.find_element_by_name('username')
passwordBox = self.driver.find_element_by_name('pwd')
ac = ActionChains(self.driver)
ac.send_keys_to_element(usernameBox, self.username)
ac.send_keys_to_element(passwordBox, self.password).perform()
cap_correction = {'丫': 'Y', '了': '3', '尺': 'R'} # 手动纠错
while True:
if self.driver.current_url == self.kanaLink:
break
self.driver.execute_script(
'document.getElementById("submitButton").style.display = "none"'
)
self.driver.execute_script(
'document.getElementById("cap").childNodes[1].style.width="150%"'
)
frame = self.driver.find_element_by_xpath(
'/html/body/div[2]/div/form/div[1]/object')
self.driver.switch_to.frame(frame)
try:
a = self.driver.find_element_by_css_selector('[fill="none"]')
self.del_element(a)
except:
sleep(1)
continue
self.driver.switch_to.default_content()
cap = -1
self.driver.get_screenshot_as_file('a.png')
try:
cred = credential.Credential(self.secretId, self.secretKey)
http_profile = HttpProfile()
http_profile.endpoint = 'ocr.tencentcloudapi.com'
client_profile = ClientProfile()
client_profile.httpProfile = http_profile
client = ocr_client.OcrClient(cred, 'ap-shanghai',
client_profile)
req = models.GeneralBasicOCRRequest()
params = {
'ImageBase64':
base64.b64encode(open('a.png', 'rb').read()).decode()
}
req.from_json_string(json.dumps(params))
resp = client.GeneralBasicOCR(req)
a = json.loads(resp.to_json_string())
except TencentCloudSDKException as err:
print(err)
self.driver.execute_script(
'document.getElementById("cap").childNodes[1].style.width="100%"'
)
for i in a['TextDetections']:
tmp = i['DetectedText']
s = ''
for j in tmp:
if j != '(' and j != ')': # 去除诡异括号
s += j
if j in cap_correction:
s += cap_correction[j]
tmp = s
if re.match(r'\w\w\w\w', tmp) and len(tmp) == 4:
cap = tmp
break
print(cap)
ac = ActionChains(self.driver)
ac.send_keys_to_element(self.driver.find_element_by_name("cap"),
cap).perform()
self.driver.execute_script(
'document.getElementById("submitButton").style.display = ""')
self.driver.find_element_by_id("submitButton").click()
try:
WebDriverWait(self.driver,
10).until(EC.url_to_be(self.kanaLink))
break
except TimeoutException:
pass
print("登录成功！")
return
def getresult(file):
data = []
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
try:
cred = credential.Credential("AKIDhCSKyOceP5TUIFfh2Bdsrc7fzFybI2tV", "e3B0bx3siJdkaBauxFI6dugoeBUmsinf")
httpProfile = HttpProfile()
httpProfile.endpoint = "ocr.tencentcloudapi.com"
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
client = ocr_client.OcrClient(cred, "ap-shanghai", clientProfile)
req = models.VatInvoiceOCRRequest()
with open("image/"+file, "rb") as f:
filedate = base64.b64encode(f.read())
params = {
"ImageBase64": str(filedate,'utf-8')
}
req.from_json_string(json.dumps(params))
resp = client.VatInvoiceOCR(req)
result = resp.to_json_string()
result = json.loads(result)
for msg in result['VatInvoiceInfos']:
if msg["Name"]=='打印发票号码':
num = msg["Value"][2:]
if num[0]=="0":
num = "'"+num
data.insert(0,num)
if msg["Name"]=='销售方名称':
data.insert(1,msg["Value"])
if msg["Name"]=='备注':
data.insert(2,msg["Value"])
if msg["Name"]=='合计金额':
data.insert(3,msg["Value"])
if msg["Name"]=='合计税额':
data.insert(4,msg["Value"])
if msg["Name"]=='小写金额':
if msg["Value"][-2:] == "00":
data.insert(5, msg["Value"][:-3])
else:
data.insert(5,msg["Value"])
if msg["Name"]=='购买方名称':
name = msg["Name"]
if msg["Value"]=="上海晓篪信息技术有限公司":
name = "Xiaochi"
elif msg["Value"]=="上海兢展电子科技有限公司":
name = "Jingzhan"
elif msg["Value"]== "上海巢威计算机科技有限公司":
name = "Chaowei"
elif msg["Value"]== "上海楷晟信息技术有限公司":
name = "Kaisheng"
elif msg["Value"]== "上海翊瑄电子科技有限公司":
name = "Yixuan"
data.insert(6,name)
print("正在处理发票"+file)
os.remove("image/"+file)
except TencentCloudSDKException as err:
print(err)
print("未识别"+file)
return data
def SetClientProfile(self, clientProfile: ClientProfile, httpProfile: HttpProfile) -> None:
clientProfile.signMethod = "TC3-HMAC-SHA256" # 指定签名算法
clientProfile.language = "en-US" # 指定展示英文（默认为中文）
clientProfile.httpProfile = httpProfile
return
def __init__(self,secretid=settings.SECRETID,secretkey=settings.SECRETKEY):
self.secretid= secretid
self.secretkey = secretkey
self.hp = HttpProfile()
self.cp = ClientProfile()
def ip(ins_type):
# 查询所有账户
all_info = Account.objects.all().values_list('account_name', 'account_id',
'account_key')
# 查询实例表中所有ip,放在ip_info列表中
available_ip = []
# 遍历账户查询结果
for info in all_info:
try:
# 密钥
cred = credential.Credential(info[1], info[2])
httpProfile = HttpProfile()
httpProfile.endpoint = "cvm.tencentcloudapi.com"
region_code, region_name = real_time_region.search(
info[1], info[2])
# 服务器所在大区
for region in region_code:
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
client = cvm_client.CvmClient(cred, region, clientProfile)
# 向腾讯云发送实例列表描述请求
req = models.DescribeInstancesRequest()
params = '{}'
req.from_json_string(params)
# 腾讯云应当包
resp = client.DescribeInstances(req)
# 转换为python字典
res = json.loads(resp.to_json_string())
# 实例集合
for ins_set in res['InstanceSet']:
ins_cpu = ins_set['CPU']
ins_memory = ins_set['Memory']
ins_id = ins_set['InstanceId']
disk_size = ins_set['SystemDisk']['DiskSize']
req = models.DescribeInstanceInternetBandwidthConfigsRequest(
)
params = '{"InstanceId":"%s"}' % ins_id
req.from_json_string(params)
# 查询实例带宽配置
resp = client.DescribeInstanceInternetBandwidthConfigs(req)
# 转成python字典
res = json.loads(resp.to_json_string())
internet_width = res['InternetBandwidthConfigSet'][0][
'InternetAccessible']['InternetMaxBandwidthOut']
# 组合cpu/memory/disk_size/internet_width信息
merge = str(ins_cpu) + '核/' + str(ins_memory) + 'G/' + str(internet_width) + 'Mbps/' +\
str(disk_size) + 'G'
# 插入数据库, 部署后改为内网
# str_ip = str(ins_set['PrivateIpAddresses']).replace('[', '').replace(']', '').replace("'", "")
str_ip = str(ins_set['PrivateIpAddresses']).replace(
'[', '').replace(']', '').replace("'", "")
# 如果要开设的服务器的实例类型和该实例一样，则加入可开设服务器的ip列表
if ins_type == merge:
available_ip.append(str_ip)
# 查看ip是否已经存在，不存在则插入，存在则更新
ins_type_save = InsType(ins_type=merge,
ip=str_ip,
account_name=info[0])
ins_type_save.save()
except TencentCloudSDKException as err:
print(err)
raise err
return available_ip
def __init__(self, secret_id, secret_key):
self.cred = credential.Credential(secret_id, secret_key)
self.httpProfile = HttpProfile()
self.httpProfile.endpoint = "cvm.tencentcloudapi.com"
self.clientProfile = ClientProfile()
self.clientProfile.httpProfile = self.httpProfile
def video_to_text(video_url, video_id):
"""
input:
video_url
video_id
output:
results
format: [{time_start:xxx,time_end:xxx,text:xxx,vid:xxx},...]
"""
from tencentcloud.common import credential
from tencentcloud.common.profile.client_profile import ClientProfile
from tencentcloud.common.profile.http_profile import HttpProfile
from tencentcloud.common.exception.tencent_cloud_sdk_exception import TencentCloudSDKException
from tencentcloud.asr.v20190614 import asr_client, models
import base64
import io
import time
import sys
if sys.version_info[0] == 3:
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
# post the audio to tencent cloud platform
try:
# <Your SecretId><Your SecretKey> of tencent cloud
cred = credential.Credential(
"AKID1w0sUvY1A4nQyJC5O1PXP43qMimcZNCY", "LWSHzeGgrmQNBk4MOiqiRu40at7TYNJg")
# set http request
httpProfile = HttpProfile()
httpProfile.endpoint = "asr.tencentcloudapi.com"
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
clientProfile.signMethod = "TC3-HMAC-SHA256"
client = asr_client.AsrClient(cred, "ap-beijing", clientProfile)
# set params and create recognition task
req = models.CreateRecTaskRequest()
params = {"ChannelNum": 1, "ResTextFormat": 0, "SourceType": 0}
req._deserialize(params)
req.EngineModelType = "16k_en"
req.Url = video_url
resp = client.CreateRecTask(req)
# set result query
req = models.DescribeTaskStatusRequest()
params = '{"TaskId":%s}' % resp.Data.TaskId
req.from_json_string(params)
# polling
resp = client.DescribeTaskStatus(req)
while resp.Data.Status != 2:
print(111)
if 'faild' in resp.Data.StatusStr:
break
print(222)
print("video ID: " + str(video_id) + " is " +
resp.Data.StatusStr, flush=True)
time.sleep(1)
resp = client.DescribeTaskStatus(req)
# process the result
print("video ID: " + str(video_id) + " is " +
resp.Data.StatusStr, flush=True)
results = []
lines = resp.Data.Result.split('\n')
for line in lines:
if len(line) < 1:
continue
time, text = line.split(']')[0][1:], line.split(']')[1][2:-1]
result_dict = {}
result_dict["time_start"], result_dict[
"time_end"] = time.split(',')[0], time.split(',')[1]
result_dict["text"] = text
result_dict["vid"] = video_id
results.append(result_dict)
return results
except TencentCloudSDKException as err:
print(err)
def tencent(sentence, secret_id, secret_key, logger):
result = ""
# 如果未注册
if (not secret_id) or (not secret_key):
return "私人腾讯: 还未注册私人腾讯API, 不可使用"
try:
cred = credential.Credential(secret_id, secret_key)
httpProfile = HttpProfile()
httpProfile.endpoint = "tmt.tencentcloudapi.com"
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
client = tmt_client.TmtClient(cred, "ap-guangzhou", clientProfile)
req = models.TextTranslateRequest()
sentence = sentence.replace('"', "'")
params = '''{"SourceText":"%s","Source":"auto","Target":"zh","ProjectId":0}''' % (
sentence)
params = params.replace('\r', '\\r').replace('\n', '\\n')
req.from_json_string(params)
resp = client.TextTranslate(req)
result = re.findall(r'"TargetText": "(.+?)"', resp.to_json_string())[0]
result = result.replace('\\r', '\r').replace('\\n', '\n')
except TencentCloudSDKException as err:
try:
err = str(err)
code = re.findall(r'code:(.*?) message', err)[0]
error = re.findall(r'message:(.+?) requestId', err)[0]
except Exception:
logger.error(format_exc())
result = "私人腾讯：我抽风啦!"
else:
if code == "MissingParameter":
pass
elif code == "FailedOperation.NoFreeAmount":
result = "私人腾讯：本月免费额度已经用完"
elif code == "FailedOperation.ServiceIsolate":
result = "私人腾讯：账号欠费停止服务"
elif code == "FailedOperation.UserNotRegistered":
result = "私人腾讯：还没有开通机器翻译服务"
elif code == "InternalError":
result = "私人腾讯：内部错误"
elif code == "InternalError.BackendTimeout":
result = "私人腾讯：后台服务超时，请稍后重试"
elif code == "InternalError.ErrorUnknown":
result = "私人腾讯：未知错误"
elif code == "LimitExceeded":
result = "私人腾讯：超过配额限制"
elif code == "UnsupportedOperation":
result = "私人腾讯：操作不支持"
elif code == "InvalidCredential":
result = "私人腾讯：secretId或secretKey错误"
elif code == "AuthFailure.SignatureFailure":
result = "私人腾讯：secretKey错误"
elif code == "AuthFailure.SecretIdNotFound":
result = "私人腾讯：secretId错误"
elif code == "AuthFailure.SignatureExpire":
result = "私人腾讯：签名过期，请将电脑系统时间调整至准确的时间后重试"
else:
result = "私人腾讯: %s, %s" % (code, error)
except Exception:
logger.error(format_exc())
result = "私人腾讯：我抽风啦!"
return result
def server_status():
# 休眠5秒，等待所有服务器信息全部传过来
time.sleep(5)
region = []
data = Account.objects.values_list('account_name', 'account_id',
'account_key')
for info in data:
try:
# 密钥
cred = credential.Credential(info[1], info[2])
httpProfile = HttpProfile()
httpProfile.endpoint = "cvm.tencentcloudapi.com"
# clientProfile = ClientProfile()
# clientProfile.httpProfile = httpProfile
# client = cvm_client.CvmClient(cred, "", clientProfile)
#
# # 所有可用地域，
# req = models.DescribeRegionsRequest()
# params = '{}'
# req.from_json_string(params)
#
# # 结果转成字典类型
# resp = client.DescribeRegions(req)
# # print(resp.to_json_string())
# res = json.loads(resp.to_json_string())
#
# for i in range(res['TotalCount']):
# region.append(res['RegionSet'][i]['Region'])
# 账户已经配置（可能购买过服务器）的地区
region_name = ServerAccountZone.objects.filter(
account_name=info[0]).values_list('zone', flat=True)
for r_name in region_name:
region.append(ZoneCode.objects.get(zone=r_name).code)
for reg in region:
# 服务器所在大区
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
client = cvm_client.CvmClient(cred, reg, clientProfile)
# 向腾讯云发送实例列表描述请求
req = models.DescribeInstancesRequest()
params = '{}'
req.from_json_string(params)
# 腾讯云应当包
resp = client.DescribeInstances(req)
# 腾讯云应答包，json串,string
# print(resp.to_json_string())
# 转换为python字典
res = json.loads(resp.to_json_string())
# 该账户下总的实例个数
total = res['TotalCount']
# 一个账户下多个实例,根据内网ip进行通信，做好对等连接
for i in range(total):
pub_ip = res['InstanceSet'][i]['PrivateIpAddresses']
# PriIp = res['InstanceSet'][i]['PrivateIpAddresses']
# print(PriIp)
# 根据公网Ip获得一个实例上所有游戏服务器的名称,人数，繁忙服务器台数，空闲服务器台数
instance_insert_mysql(''.join(pub_ip), 'root',
res['InstanceSet'][i]['InstanceId'],
info[0])
# os.system("echo '%s' /home/tt.txt" % PriIp)
# instance_insert_mysql(''.join(PriIp), 'root', res['InstanceSet'][i]['InstanceId'], info[1])
except TencentCloudSDKException as err:
print(err)
def excelFromPictures(path,picture):
SecretId = ""
SecretKey = ""
with open(picture,"rb") as f:
img_data = f.read()
img_base64 = b64encode(img_data)
cred = credential.Credential(SecretId, SecretKey) #ID和Secret从腾讯云申请
httpProfile = HttpProfile()
httpProfile.endpoint = "ocr.tencentcloudapi.com"
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
client = ocr_client.OcrClient(cred, "ap-shanghai", clientProfile)
req = models.TableOCRRequest()
params = '{"ImageBase64":"' + str(img_base64, 'utf-8') + '"}'
req.from_json_string(params)
# false=0
try:
resp = client.TableOCR(req)
# print(resp.to_json_string())
except TencentCloudSDKException as err:
print("错误[",err,"]\n可重试")
##提取识别出的数据，并且生成json
result1 = loads(resp.to_json_string())
#RowTl表示数据所有行索引,ColTl表示数据所在列索引,Text为数据
rowIndex = []
colIndex = []
content = []
for item in result1['TextDetections']:
rowIndex.append(item['RowTl'])
colIndex.append(item['ColTl'])
content.append(item['Text'])
##导出Excel
##ExcelWriter方案
rowIndex = Series(rowIndex)
colIndex = Series(colIndex)
index = rowIndex.unique()
index.sort()
columns = colIndex.unique()
columns.sort()
data = DataFrame(index = index, columns = columns)
for i in range(len(rowIndex)):
data.loc[rowIndex[i],colIndex[i]] = re.sub(" ","",content[i])
writer = ExcelWriter(path+"/tables/" +re.match(".*\.",f.name).group()+"xlsx", engine='xlsxwriter')
data.to_excel(writer,sheet_name = 'Sheet1', index=False,header = False)
writer.save()
print("已经完成" + f.name + "的提取")
def invoke(self,
function_name,
namespace="default",
log_type="None",
qualifier="$LATEST",
invocation_type="RequestResponse",
data=None):
self.region = self.region if self.region is not None \
else os.environ.get("TENCENTCLOUD_REGION", "ap-guangzhou")
self.secret_id = self.secret_id if self.secret_id is not None \
else os.environ.get("TENCENTCLOUD_SECRETID", None)
self.secret_key = self.secret_key if self.secret_key is not None \
else os.environ.get("TENCENTCLOUD_SECRETKEY", None)
self.token = self.token if self.token is not None \
else os.environ.get("TENCENTCLOUD_SESSIONTOKEN", None)
self.env = os.environ.get("TENCENTCLOUD_RUNENV", None)
self.endpoint = "scf.internal.tencentcloudapi.com" if self.env == "SCF" \
else "scf.tencentcloudapi.com"
cred = credential.Credential(self.secret_id, self.secret_key,
self.token)
self.profile = ClientProfile(httpProfile=HttpProfile(
endpoint=self.endpoint, reqTimeout=300, keepAlive=True))
self.client = scf_client.ScfClient(cred,
self.region,
profile=self.profile)
client_context = None
if data:
client_context = json.dumps(data)
action_params = {
"Namespace": namespace,
"LogType": log_type,
"ClientContext": client_context,
"Qualifier": qualifier,
"InvocationType": invocation_type,
"FunctionName": function_name,
}
res = json.loads(self.client.call("Invoke", action_params))
if "Error" in res["Response"]:
raise TencentCloudSDKException(
code=res["Response"]["Error"]["Code"],
message=res["Response"]["Error"]["Message"],
requestId=res["Response"]["RequestId"])
elif "InvokeResult" in res["Response"]["Result"]:
if res["Response"]["Result"]["InvokeResult"] == 1:
exceptions = json.loads(res["Response"]["Result"]["RetMsg"])
stack_trace = exceptions[
"stackTrace"] if "stackTrace" in exceptions else ""
raise TencentServerlessSDKException(
code=exceptions["errorCode"],
message=exceptions["errorMessage"],
response=res,
stack_trace=stack_trace,
request_id=res["Response"]['RequestId'])
elif res["Response"]["Result"]["InvokeResult"] == -1:
raise TencentServerlessSDKException(
code=-1,
message=res["Response"]["Result"]["RetMsg"],
response=res,
request_id=res["Response"]['RequestId'])
else:
return res["Response"]["Result"]["RetMsg"]
else:
raise TencentServerlessSDKException(
code=-1,
message='Internal server error',
response=res,
request_id=res["Response"]['RequestId'])
def send_sms(phone_number, code, minute):
try:
# 必要步骤：
# 实例化一个认证对象，入参需要传入腾讯云账户密钥对secretId，secretKey。
# 这里采用的是从环境变量读取的方式，需要在环境变量中先设置这两个值。
# 你也可以直接在代码中写死密钥对，但是小心不要将代码复制、上传或者分享给他人，
# 以免泄露密钥对危及你的财产安全。
# CAM密匙查询: https://console.cloud.tencent.com/cam/capi
cred = credential.Credential(secret_id, secret_key)
# cred = credential.Credential(
# os.environ.get(""),
# os.environ.get("")
# )
# 实例化一个http选项，可选的，没有特殊需求可以跳过。
httpProfile = HttpProfile()
httpProfile.reqMethod = "POST" # post请求(默认为post请求)
httpProfile.reqTimeout = 30 # 请求超时时间，单位为秒(默认60秒)
httpProfile.endpoint = "sms.tencentcloudapi.com" # 指定接入地域域名(默认就近接入)
# 非必要步骤:
# 实例化一个客户端配置对象，可以指定超时时间等配置
clientProfile = ClientProfile()
clientProfile.signMethod = "TC3-HMAC-SHA256" # 指定签名算法
clientProfile.language = "en-US"
clientProfile.httpProfile = httpProfile
# 实例化要请求产品(以sms为例)的client对象
# 第二个参数是地域信息，可以直接填写字符串ap-guangzhou，或者引用预设的常量
client = sms_client.SmsClient(cred, "ap-guangzhou", clientProfile)
# 实例化一个请求对象，根据调用的接口和实际情况，可以进一步设置请求参数
# 你可以直接查询SDK源码确定SendSmsRequest有哪些属性可以设置
# 属性可能是基本类型，也可能引用了另一个数据结构
# 推荐使用IDE进行开发，可以方便的跳转查阅各个接口和数据结构的文档说明
req = models.SendSmsRequest()
# 基本类型的设置:
# SDK采用的是指针风格指定参数，即使对于基本类型你也需要用指针来对参数赋值。
# SDK提供对基本类型的指针引用封装函数
# 帮助链接：
# 短信控制台: https://console.cloud.tencent.com/sms/smslist
# sms helper: https://cloud.tencent.com/document/product/382/3773
# 以下信息根据需要进行更改
# 短信应用ID: 短信SdkAppid在 [短信控制台] 添加应用后生成的实际SdkAppid，示例如1400006666
req.SmsSdkAppid = SmsSdkAppid
# 短信签名内容: 使用 UTF-8 编码，必须填写已审核通过的签名，签名信息可登录 [短信控制台] 查看
req.Sign = SmsSign
# 短信码号扩展号: 默认未开通，如需开通请联系 [sms helper]
req.ExtendCode = ""
# 用户的 session 内容: 可以携带用户侧 ID 等上下文信息，server 会原样返回
req.SessionContext = "123456"
# 国际/港澳台短信 senderid: 国内短信填空，默认未开通，如需开通请联系 [sms helper]
req.SenderId = ""
# 下发手机号码，采用 e.164 标准，+[国家或地区码][手机号]
# 示例如：+8613711112222， 其中前面有一个+号 ，86为国家码，13711112222为手机号，最多不要超过200个手机号
phone_number = "+86" + str(phone_number)
req.PhoneNumberSet = [phone_number]
# 模板 ID: 必须填写已审核通过的模板 ID。模板ID可登录 [短信控制台] 查看
req.TemplateID = SmsTemplateID
# 模板参数: 若无模板参数，则设置为空 验证码 验证时间
req.TemplateParamSet = [str(code), str(minute)]
# 通过client对象调用DescribeInstances方法发起请求。注意请求方法名与请求对象是对应的。
# 返回的resp是一个DescribeInstancesResponse类的实例，与请求对象对应。
resp = client.SendSms(req)
# 输出json格式的字符串回包
# print(resp.to_json_string(indent=2).get("SendStatusSet").get("Code"))
"""
{'SendStatusSet': [{'SerialNo': '2019:2486505420595011479', 'PhoneNumber': '+86135555555', 'Fee': 1, 'SessionContext': '123456', 'Code': 'Ok', 'Message': 'send success'}], 'RequestId': '21a4489f-f873-4115-bc08-1aaa5c8aa91c'}
"""
code = json.loads(resp.to_json_string(indent=2))
data = code.get("SendStatusSet")[0].get("Code")
return data
except TencentCloudSDKException as err:
print(err)
return "Error"
def insert_ins_type():
# 连接数据库，创建游标
# conn = pymysql.connect("localhost", "root", "P@ssw0rd1", "zero_server")
# cursor = conn.cursor()
# sql查询语句执行,查询所有账户
# sql = "select account_name,account_id,account_key from zero_cloud_user;"
# cursor.execute(sql)
# # 查询结果
# all_info = cursor.fetchall()
all_info = Account.objects.all().values_list('account_name', 'account_id',
'account_key')
# 查询实例表中所有ip,放在ip_info列表中
# sql2 = "select ip from zero_ins_type;"
# cursor.execute(sql2)
# ip_data = cursor.fetchall()
ip_info = InsType.objects.all().values_list('ip', flat=True)
# ip_info = []
# for i in ip_data:
# ip_info.append(i[0])
# 遍历账户查询结果
for info in all_info:
try:
# 根据账户名称查询区域region
# sql_region = "select region from zero_account_zone where account_name='%s';" % info[0]
# cursor.execute(sql_region)
# region_name = cursor.fetchone()
region_name = AccountZone.objects.get(account_name=info[0]).region
# 将region_name这个大字符串变成列表,并去掉字符串中的空格
region_name = [x.strip() for x in region_name[0].split(',')]
# 密钥
cred = credential.Credential(info[1], info[2])
httpProfile = HttpProfile()
httpProfile.endpoint = "cvm.tencentcloudapi.com"
# 服务器所在大区
for region in region_name:
# 根据region中文名在zero_zone_code表中查询中对应代号,code[0](code是数据库查询返回的元组)
# sql_code = "select code from zero_zone_code where zone='%s';" % region
# cursor.execute(sql_code)
# code = cursor.fetchone()
code = ZoneCode.objects.get(zone=region).code
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
client = cvm_client.CvmClient(cred, code[0], clientProfile)
# 向腾讯云发送实例列表描述请求
req = models.DescribeInstancesRequest()
params = '{}'
req.from_json_string(params)
# 腾讯云应当包
resp = client.DescribeInstances(req)
# 转换为python字典
res = json.loads(resp.to_json_string())
# 实例集合
for ins_set in res['InstanceSet']:
ins_cpu = ins_set['CPU']
ins_memory = ins_set['Memory']
ins_id = ins_set['InstanceId']
disk_size = ins_set['SystemDisk']['DiskSize']
req = models.DescribeInstanceInternetBandwidthConfigsRequest(
)
params = '{"InstanceId":"%s"}' % ins_id
req.from_json_string(params)
# 查询实例带宽配置
resp = client.DescribeInstanceInternetBandwidthConfigs(req)
# 转成python字典
res = json.loads(resp.to_json_string())
internet_width = res['InternetBandwidthConfigSet'][0][
'InternetAccessible']['InternetMaxBandwidthOut']
# 组合cpu/memory/disksize/bandwidth信息
merge = str(ins_cpu) + '核/' + str(ins_memory) + 'G/' \
+ str(internet_width) + 'Mbps' + str(disk_size) + 'G/'
# 插入数据库
str_ip = str(ins_set['PrivateIpAddressed']).replace(
'[', '').replace(']', '').replace("'", "")
# 查看ip是否已经存在，不存在则插入，存在则更新
if str_ip not in ip_info:
# insert_sql = "insert into zero_ins_type(ins_type,ip,account_name) values('%s','%s','%s')" \
# % (merge, str_ip, info[0])
# cursor.execute(insert_sql)
ins_type = InsType(ins_type=merge,
ip=str_ip,
account_name=info[0])
ins_type.save(force_insert=True)
else:
# update_sql = "update zero_ins_type set ins_type='%s' where ip='%s';" % (merge, str_ip)
# cursor.execute(update_sql)
InsType.objects.filter(ip=str_ip).update(
ins_type=merge)
# conn.commit()
except TencentCloudSDKException as err:
print(err)
raise err
from tencentcloud.soe.v20180724 import soe_client, models
import uuid
try:
# 实例化一个认证对象，入参需要传入腾讯云账户secretId，secretKey
cred = credential.Credential("secretId", "secretKey")
# 实例化一个http选项，可选的，没有特殊需求可以跳过。
httpProfile = HttpProfile()
httpProfile.reqMethod = "POST" # post请求(默认为post请求)
httpProfile.reqTimeout = 30 # 请求超时时间，单位为秒(默认60秒)
httpProfile.endpoint = "soe.tencentcloudapi.com" # 指定接入地域域名(默认就近接入)
httpProfile.keepAlive = True # 保持活动状态
# 实例化一个client选项，可选的，没有特殊需求可以跳过。
clientProfile = ClientProfile() # 客户端配置文件
clientProfile.signMethod = "TC3-HMAC-SHA256" # 指定签名算法(默认为HmacSHA256)
clientProfile.unsignedPayload = True # 未签署的有效负载
clientProfile.httpProfile = httpProfile # http选项
client = soe_client.SoeClient(cred, "", clientProfile) # 连接soe的连接
# 请求参数赋值
req = models.InitOralProcessRequest() # 连接soe的评测初始化模块
req.SessionId = str(uuid.uuid1()) # 语音段唯一标识，一段语音一个SessionId
req.RefText = "red" # 评测文本
req.WorkMode = 1 # 语音输入模式，0：流式分片，1：非流式一次性评估
req.EvalMode = 1 # 评估模式，0：词模式（中文评测模式下为文字模式），1：句子模式，2：段落模式，3：自由说模式，当为词模式评估时，能够提供每个音节的评估信息，当为句子模式时，能够提供完整度和流利度信息。4: 英文单词音素诊断评测模式，针对一个单词音素诊断评测。
req.ScoreCoeff = 1 # 评价苛刻指数，取值为[1.0 - 4.0]范围内的浮点数，用于平滑不同年龄段的分数，1.0为小年龄段，4.0为最高年龄段
# req.SoeAppId = "123456" # 业务应用ID，与账号应用APPID无关，是用来方便客户管理服务的参数，新的 SoeAppId 可以在[控制台](https://console.cloud.tencent.com/soe)【应用管理】下新建。
# req.IsLongLifeSession = 0 # 长效session标识，当该参数为1时，session的持续时间为300s，但会一定程度上影响第一个数据包的返回速度，且TransmitOralProcess必须同时为1才可生效。
req.StorageMode = 0 # 音频存储模式，0：不存储，1：存储到公共对象存储，输出结果为该会话最后一个分片TransmitOralProcess 返回结果 AudioUrl 字段，2：永久存储音频，需要提工单申请，会产生一定存储费用，3：自定义存储，将音频存储到自定义的腾讯云[对象存储](https://cloud.tencent.com/product/cos)中，需要提工单登记存储信息。
def tencent_send(phone_num):
try:
# 必要步骤：
# 实例化一个认证对象，入参需要传入腾讯云账户密钥对 secretId 和 secretKey
# 本示例采用从环境变量读取的方式，需要预先在环境变量中设置这两个值
# 您也可以直接在代码中写入密钥对，但需谨防泄露，不要将代码复制、上传或者分享给他人
# CAM 密钥查询：https://console.cloud.tencent.com/cam/capi
# cred = credential.Credential("secretId","secretKey")
cred = credential.Credential(os.environ.get("secretId"),
os.environ.get("secretKey"))
# print(os.environ.get("secretId"))
verify_code = str(int((random.uniform(0, 1) * 9 + 1) * 100000))
phone = '+86' + phone_num
# 实例化一个 http 选项，可选，无特殊需求时可以跳过
httpProfile = HttpProfile()
httpProfile.reqMethod = "POST" # POST 请求（默认为 POST 请求）
httpProfile.reqTimeout = 30 # 请求超时时间，单位为秒（默认60秒）
httpProfile.endpoint = "sms.tencentcloudapi.com" # 指定接入地域域名（默认就近接入）
# 非必要步骤:
# 实例化一个客户端配置对象，可以指定超时时间等配置
clientProfile = ClientProfile()
clientProfile.signMethod = "TC3-HMAC-SHA256" # 指定签名算法
clientProfile.language = "en-US"
clientProfile.httpProfile = httpProfile
# 实例化 SMS 的 client 对象
# 第二个参数是地域信息，可以直接填写字符串 ap-guangzhou，或者引用预设的常量
client = sms_client.SmsClient(cred, "ap-guangzhou", clientProfile)
# 实例化一个请求对象，根据调用的接口和实际情况，可以进一步设置请求参数
# 您可以直接查询 SDK 源码确定 SendSmsRequest 有哪些属性可以设置
# 属性可能是基本类型，也可能引用了另一个数据结构
# 推荐使用 IDE 进行开发，可以方便的跳转查阅各个接口和数据结构的文档说明
req = models.SendSmsRequest()
# 基本类型的设置:
# SDK 采用的是指针风格指定参数，即使对于基本类型也需要用指针来对参数赋值
# SDK 提供对基本类型的指针引用封装函数
# 帮助链接：
# 短信控制台：https://console.cloud.tencent.com/smsv2
# sms helper：https://cloud.tencent.com/document/product/382/3773
# 短信应用 ID: 在 [短信控制台] 添加应用后生成的实际 SDKAppID，例如1400006666
req.SmsSdkAppid = "1400401547"
# 短信签名内容: 使用 UTF-8 编码，必须填写已审核通过的签名，可登录 [短信控制台] 查看签名信息
req.Sign = "瑞选网"
# 短信码号扩展号: 默认未开通，如需开通请联系 [sms helper]
req.ExtendCode = ""
# 用户的 session 内容: 可以携带用户侧 ID 等上下文信息，server 会原样返回
req.SessionContext = "xxx"
# 国际/港澳台短信 senderid: 国内短信填空，默认未开通，如需开通请联系 [sms helper]
req.SenderId = ""
# 下发手机号码，采用 e.164 标准，+[国家或地区码][手机号]
# 例如+8613711112222， 其中前面有一个+号 ，86为国家码，13711112222为手机号，最多不要超过200个手机号
req.PhoneNumberSet = [
phone,
]
# 模板 ID: 必须填写已审核通过的模板 ID，可登录 [短信控制台] 查看模板 ID
req.TemplateID = "665620"
# 模板参数: 若无模板参数，则设置为空
req.TemplateParamSet = [
verify_code,
]
# 通过 client 对象调用 SendSms 方法发起请求。注意请求方法名与请求对象是对应的
resp = client.SendSms(req)
# 输出 JSON 格式的字符串回包
re_data = json.loads(resp.to_json_string(indent=2))
print(re_data)
if resp and re_data.get('SendStatusSet')[0].get('Code') == 'Ok':
return verify_code
else:
return None
# if re_data.get('code') == 2:
# return verify_code
# else:
# return None
except TencentCloudSDKException as err:
print(err)
def profile(service="cvm"):
httpProfile = HttpProfile()
httpProfile.endpoint = service + ".tencentcloudapi.com"
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
return clientProfile
# 导入可选配置类
from tencentcloud.common.profile.client_profile import ClientProfile
from tencentcloud.common.profile.http_profile import HttpProfile
try:
# 实例化一个认证对象，入参需要传入腾讯云账户secretId，secretKey
cred = credential.Credential(os.environ.get("TENCENTCLOUD_SECRET_ID"),
os.environ.get("TENCENTCLOUD_SECRET_KEY"))
# 实例化一个http选项，可选的，没有特殊需求可以跳过。
httpProfile = HttpProfile()
httpProfile.reqMethod = "GET" # post请求(默认为post请求)
httpProfile.reqTimeout = 30 # 请求超时时间，单位为秒(默认60秒)
httpProfile.endpoint = "cvm.ap-shanghai.tencentcloudapi.com" # 指定接入地域域名(默认就近接入)
# 实例化一个client选项，可选的，没有特殊需求可以跳过。
clientProfile = ClientProfile()
clientProfile.signMethod = "TC3-HMAC-SHA256" # 指定签名算法
clientProfile.language = "en-US"
clientProfile.httpProfile = httpProfile
# 实例化要请求产品(以cvm为例)的client对象，clientProfile是可选的。
client = cvm_client.CvmClient(cred, "ap-shanghai", clientProfile)
# 实例化一个cvm实例信息查询请求对象,每个接口都会对应一个request对象。
req = models.DescribeInstancesRequest()
# 填充请求参数,这里request对象的成员变量即对应接口的入参。
# 你可以通过官网接口文档或跳转到request对象的定义处查看请求参数的定义。
respFilter = models.Filter() # 创建Filter对象, 以zone的维度来查询cvm实例。
respFilter.Name = "zone"
respFilter.Values = ["ap-shanghai-1", "ap-shanghai-2"]
def doCreateLaunchConfiguration(argv, arglist):
g_param = parse_global_arg(argv)
if "help" in argv:
show_help("CreateLaunchConfiguration", g_param[OptionsDefine.Version])
return
param = {
"LaunchConfigurationName":
Utils.try_to_json(argv, "--LaunchConfigurationName"),
"ImageId":
Utils.try_to_json(argv, "--ImageId"),
"ProjectId":
Utils.try_to_json(argv, "--ProjectId"),
"InstanceType":
Utils.try_to_json(argv, "--InstanceType"),
"SystemDisk":
Utils.try_to_json(argv, "--SystemDisk"),
"DataDisks":
Utils.try_to_json(argv, "--DataDisks"),
"InternetAccessible":
Utils.try_to_json(argv, "--InternetAccessible"),
"LoginSettings":
Utils.try_to_json(argv, "--LoginSettings"),
"SecurityGroupIds":
Utils.try_to_json(argv, "--SecurityGroupIds"),
"EnhancedService":
Utils.try_to_json(argv, "--EnhancedService"),
"UserData":
Utils.try_to_json(argv, "--UserData"),
"InstanceChargeType":
Utils.try_to_json(argv, "--InstanceChargeType"),
"InstanceMarketOptions":
Utils.try_to_json(argv, "--InstanceMarketOptions"),
"InstanceTypes":
Utils.try_to_json(argv, "--InstanceTypes"),
"InstanceTypesCheckPolicy":
Utils.try_to_json(argv, "--InstanceTypesCheckPolicy"),
}
cred = credential.Credential(g_param[OptionsDefine.SecretId],
g_param[OptionsDefine.SecretKey])
http_profile = HttpProfile(
reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(
g_param[OptionsDefine.Timeout]),
reqMethod="POST",
endpoint=g_param[OptionsDefine.Endpoint])
profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
client = mod.AutoscalingClient(cred, g_param[OptionsDefine.Region],
profile)
client._sdkVersion += ("_CLI_" + __version__)
models = MODELS_MAP[g_param[OptionsDefine.Version]]
model = models.CreateLaunchConfigurationRequest()
model.from_json_string(json.dumps(param))
rsp = client.CreateLaunchConfiguration(model)
result = rsp.to_json_string()
jsonobj = None
try:
jsonobj = json.loads(result)
except TypeError as e:
jsonobj = json.loads(result.decode('utf-8')) # python3.3
FormatOutput.output("action", jsonobj, g_param[OptionsDefine.Output],
g_param[OptionsDefine.Filter])
def send_vcode_sms(tel, code):
try:
# 必要步骤：
# 实例化一个认证对象，入参需要传入腾讯云账户密钥对secretId，secretKey。
# 这里采用的是从环境变量读取的方式，需要在环境变量中先设置这两个值。
# 你也可以直接在代码中写死密钥对，但是小心不要将代码复制、上传或者分享给他人，
# 以免泄露密钥对危及你的财产安全。
# CAM密匙查询: https://console.cloud.tencent.com/cam/capi
cred = credential.Credential(TencentCloud_SecretId,
TencentCloud_SecretKey)
# cred = credential.Credential(
# os.environ.get(""),
# os.environ.get("")
# )
# 实例化一个http选项，可选的，没有特殊需求可以跳过。
httpProfile = HttpProfile()
httpProfile.reqMethod = "POST" # post请求(默认为post请求)
httpProfile.reqTimeout = 30 # 请求超时时间，单位为秒(默认60秒)
httpProfile.endpoint = "sms.tencentcloudapi.com" # 指定接入地域域名(默认就近接入)
# 非必要步骤:
# 实例化一个客户端配置对象，可以指定超时时间等配置
clientProfile = ClientProfile()
clientProfile.signMethod = "TC3-HMAC-SHA256" # 指定签名算法
clientProfile.language = "en-US"
clientProfile.httpProfile = httpProfile
# 实例化要请求产品(以sms为例)的client对象
# 第二个参数是地域信息，可以直接填写字符串ap-guangzhou，或者引用预设的常量
client = sms_client.SmsClient(cred, "ap-guangzhou", clientProfile)
# 实例化一个请求对象，根据调用的接口和实际情况，可以进一步设置请求参数
# 你可以直接查询SDK源码确定SendSmsRequest有哪些属性可以设置
# 属性可能是基本类型，也可能引用了另一个数据结构
# 推荐使用IDE进行开发，可以方便的跳转查阅各个接口和数据结构的文档说明
req = models.SendSmsRequest()
# 基本类型的设置:
# SDK采用的是指针风格指定参数，即使对于基本类型你也需要用指针来对参数赋值。
# SDK提供对基本类型的指针引用封装函数
# 帮助链接：
# 短信控制台: https://console.cloud.tencent.com/sms/smslist
# sms helper: https://cloud.tencent.com/document/product/382/3773
# 短信应用ID: 短信SdkAppid在 [短信控制台] 添加应用后生成的实际SdkAppid，示例如1400006666
req.SmsSdkAppid = SMS_SmsSdkAppid
# 短信签名内容: 使用 UTF-8 编码，必须填写已审核通过的签名，签名信息可登录 [短信控制台] 查看
req.Sign = "王冬代码练习"
# 短信码号扩展号: 默认未开通，如需开通请联系 [sms helper]
req.ExtendCode = ""
# 用户的 session 内容: 可以携带用户侧 ID 等上下文信息，server 会原样返回
req.SessionContext = ""
# 国际/港澳台短信 senderid: 国内短信填空，默认未开通，如需开通请联系 [sms helper]
req.SenderId = ""
# 下发手机号码，采用 e.164 标准，+[国家或地区码][手机号]
# 示例如：+8613711112222， 其中前面有一个+号 ，86为国家码，13711112222为手机号，最多不要超过200个手机号
req.PhoneNumberSet = ["+86%s" % tel]
# 模板 ID: 必须填写已审核通过的模板 ID。模板ID可登录 [短信控制台] 查看
req.TemplateID = SMS_TemplateID
# 模板参数: 若无模板参数，则设置为空
req.TemplateParamSet = [code, variable.VERIFY_CODE_EXPIRE_TIME_CN]
# 通过client对象调用DescribeInstances方法发起请求。注意请求方法名与请求对象是对应的。
# 返回的resp是一个DescribeInstancesResponse类的实例，与请求对象对应。
resp = client.SendSms(req)
# 输出json格式的字符串回包
print(resp.to_json_string())
if resp.SendStatusSet[0].Code == "Ok" and resp.SendStatusSet[
0].Message == "send success":
return True
else:
# 发送失败，则打日志
logger.warning(
"tel:%s || vote:%s || RequestId:%s" %
(tel, resp.SendStatusSet[0].Message, resp.RequestId))
return resp.SendStatusSet[0].Message
except TencentCloudSDKException as err:
# 报错，则打日志
logger.error("tel:%s || vote:%s" % (tel, str(err)))
print(err)
# 示例正常的返回值 res 的值
"""
{
"SendStatusSet": [
{
"SerialNo": "2019:538884*********",
"PhoneNumber": "+86182********",
"Fee": 1,
"SessionContext": "",
"Code": "Ok",
"Message": "send success"
}
],
"RequestId": "bf0d639e-9956-4366-be0f-a23001900ce0"
}
"""
return '发送失败，未知原因'
def __init__(self, id: str, key: str):
self.client = ssl_client.SslClient(
credential=credential.Credential(id, key),
region='',
profile=ClientProfile(httpProfile=HttpProfile(endpoint='ssl.tencentcloudapi.com'))
)
compressType = "xxx" # 压缩方式, 目前只支持lz4, 客户根据需要填写(空字符串意味不压缩)
region = "xxxx" # 需要根据客户的实际地域自行填写
topicId = "xxxxxx-xxxxxx-xxxxxx-xxxxxx" # 这里需要使用客户实际的topicId，不能输入topicname
hashKey = "" # 可选参数，具体参考官方文档：https://cloud.tencent.com/document/product/614/59470
credential = credential.Credential(os.Getenv("TENCENTCLOUD_SECRET_ID"),
os.Getenv("TENCENTCLOUD_SECRET_KEY"))
# 实例化一个http选项，可选的，没有特殊需求可以跳过。
httpProfile = HttpProfile()
httpProfile.reqMethod = "POST" # post请求(默认为post请求)
httpProfile.reqTimeout = 30 # 请求超时时间，单位为秒(默认60秒)
httpProfile.endpoint = "cls.tencentcloudapi.com" # 指定接入地域域名(默认就近接入)
httpProfile.keepAlive = True
# 实例化一个client选项，可选的，没有特殊需求可以跳过。
clientProfile = ClientProfile()
clientProfile.signMethod = "TC3-HMAC-SHA256" # 指定签名算法(默认为HmacSHA256)
clientProfile.httpProfile = httpProfile
client = common_client.CommonClient("cls", '2020-10-16', cred, region,
clientProfile)
body = pb.pb_gen(1, 1)
if compressType == "lz4":
if lz4 is None or body == "":
print("lz4 exception")
exit(1)
else:
body = lz_compresss(body)
headers = {
"X-CLS-TopicId": topicId,
def OCR_Core(Image, **kwargs):
#: PIL.Image
with open("./important/setting.json", 'r+') as f:
setting = json.load(f)
global GALMode, ResultJson # 为了文字处理使用
global LastImageValue, OCRText, OCRResultSetting
if kwargs.get("EXTRA"):
SelectOCR = OcrAll[OCRResultSetting.get()]
else:
SelectOCR = OcrAll[OcrSetting.get()]
#写入内存，太慢，更换保存本地方式
Image.save('important/LastImage.jpg')
with open('important/LastImage.jpg', 'rb+') as f:
LastImageValue = f.read()
OCRText = ""
if SelectOCR == "bd_normal" or SelectOCR == "bd_accurate":
AppID = setting["userInfo"]["bd_info"]["AppID"]
APIKey = setting["userInfo"]["bd_info"]["APIKey"]
SecretKey = setting["userInfo"]["bd_info"]["SecretKey"]
BDOcr = AipOcr(AppID, APIKey, SecretKey)
if not GALMode: #在gal模式下获取下拉框内容
if SelectOCR == "bd_normal":
OCRLanguage = setting["defaultOCRLanguage"]
ResultJson = BDOcr.basicGeneral(
LastImageValue, {"language_type": OCRLanguage}) #格式错误
else:
ResultJson = BDOcr.basicAccurate(LastImageValue)
else:
GALLanguage = setting["defaultGALLanguage"]
ResultJson = BDOcr.basicGeneral(
LastImageValue, {"language_type": GALLanguage}) # 格式错误
if not (ResultJson["words_result_num"]): # 没有结果
if GALMode:
return ""
else:
messagebox.showinfo(u"识别错误", u"未识别到文字")
if ResultJson.get("words_result"): #能获取结果
# 文本处理
for i in ResultJson["words_result"]:
OCRText += i['words'] + "\n"
return OCRText
elif ResultJson.get('error_code') == 14: #证书失效,检查用户信息
messagebox.showerror(title="Error",
message=u"检查APPID,APIKEY,以及SECRET_KEY,程序退出")
sys.exit()
elif ResultJson.get('error_code') == 17: #今天超额
messagebox.showerror(title="Error", message=u"今日次数超额")
sys.exit()
else:
messagebox.showerror(title="Error",
message=u"错误代码:" + str(ResultJson))
sys.exit()
else: #腾讯OCR
TX_INFO = setting["userInfo"]["tx_info"]
SecretId = TX_INFO["SecretId"]
SecretKey = TX_INFO["SecretKey"]
try:
cred = credential.Credential(SecretId, SecretKey)
httpProfile = HttpProfile()
httpProfile.endpoint = "ocr.tencentcloudapi.com"
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
# zh\auto\jap\kor
client = ocr_client.OcrClient(cred, "ap-guangzhou", clientProfile)
params = '{"ImageBase64":"' + str(
bytes.decode(
base64.b64encode(LastImageValue),
encoding='utf-8')) + '","LanguageType":"auto"}' #生成传输参数
# 可修改
# GeneralFasterOCR == 通用印刷体识别高速版，没有语言选项，有方位
# GeneralBasicOCR == 通用印刷体识别，有语言选项，有方位
# GeneralAccurateOCR == 通用印刷体高精度版，没有语言选项，有方位
if SelectOCR == "tx_normal":
req = models.GeneralBasicOCRRequest()
req.from_json_string(params)
resp = client.GeneralBasicOCR(req)
elif SelectOCR == "tx_quick":
req = models.GeneralFastOCRRequest()
req.from_json_string(params)
resp = client.GeneralFastOCR(req)
else:
req = models.GeneralAccurateOCRRequest()
req.from_json_string(params)
resp = client.GeneralAccurateOCR(req)
ResultJson = json.loads(resp.to_json_string()) # 获取结果json
OCRText = "" # 纯文本
for i in ResultJson["TextDetections"]:
OCRText += i["DetectedText"] + "\n"
return OCRText
except TencentCloudSDKException as err:
if err.get_code() == "FailedOperation.ImageNoText":
if not GALMode:
messagebox.showinfo("识别失败", "没有识别到文字")
return False
from tencentcloud.common import credential
from tencentcloud.common.profile.client_profile import ClientProfile
from tencentcloud.common.profile.http_profile import HttpProfile
from tencentcloud.common.exception.tencent_cloud_sdk_exception import TencentCloudSDKException
from tencentcloud.nlp.v20190408 import nlp_client, models
try:
cred = credential.Credential("qqq", "xxx")
httpProfile = HttpProfile()
httpProfile.endpoint = "nlp.tencentcloudapi.com"
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
client = nlp_client.NlpClient(cred, "ap-guangzhou", clientProfile)
req = models.KeywordsExtractionRequest()
params = '{"Text":"被问及法国为什么不采取意大利式的封锁，法国政府发言人 NDIAYE 公开蔑视意大利政府的措施：在欧洲，他们第一个中断中国的航班，第一个在机场测温，第一个禁止其他国家国民入境，第一个封城 ... 但是，这并没有阻挡疫情爆发... 这些法国都没有做，因为法国政府听取（国际）医疗界的专"}'
req.from_json_string(params)
resp = client.KeywordsExtraction(req)
print(resp.to_json_string())
except TencentCloudSDKException as err:
print(err)
def dofetch(id, key, region):
# print(id, ",", key)
# 以下不用管
cred = credential.Credential(id, key)
httpProfile = HttpProfile()
httpProfile.endpoint = "lighthouse.tencentcloudapi.com"
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
client = lighthouse_client.LighthouseClient(cred, region, clientProfile)
# 获取实例列表
req_instances = models.DescribeInstancesRequest()
params = {}
req_instances.from_json_string(json.dumps(params))
resp_instances = client.DescribeInstances(req_instances)
s1 = json.loads(resp_instances.to_json_string())['InstanceSet']
for j in range(len(s1)):
params.setdefault("InstanceIds",
[]).append(s1[j]['InstanceId']) # 获取实例ID
# 获取实例流量
req = models.DescribeInstancesTrafficPackagesRequest()
req.from_json_string(json.dumps(params))
resp = client.DescribeInstancesTrafficPackages(req)
s2 = json.loads(resp.to_json_string())["InstanceTrafficPackageSet"]
GB = 1024 * 1024 * 1024
for i in range(len(s2)):
InstanceId = s2[i]['InstanceId']
s3 = s2[i]['TrafficPackageSet'][0]
InstanceState = s1[i]["InstanceState"]
TrafficPackageTotal = round(s3['TrafficPackageTotal'] / GB, 2)
TrafficUsed = round(s3['TrafficUsed'] / GB, 2)
TrafficPackageRemaining = str(
round(s3['TrafficPackageRemaining'] / GB, 2))
# 获取实例状态
print(i + 1, "：", InstanceId, ":", "已使用：", TrafficUsed, "总流量：",
TrafficPackageTotal, "剩余：", TrafficPackageRemaining)
if (InstanceState == "RUNNING"):
print("运行中")
# 实例流量超出限制自动关闭
if (TrafficUsed / TrafficPackageTotal < percent):
print("剩余流量充足")
else:
print(InstanceId, ":", "流量超出限制，自动关闭")
req_Stop = models.StopInstancesRequest()
params_Stop = {}
params_Stop.setdefault("InstanceIds", []).append(InstanceId)
req_Stop.from_json_string(json.dumps(params_Stop))
resp_Stop = client.StopInstances(req_Stop)
print(resp_Stop.to_json_string())
# 添加TG酱通知
msgContent = InstanceId + " ：流量超出限制，即将自动关机。" + "剩余流量：" + TrafficPackageRemaining + "GB"
# msgUrl = tgBotUrl + tgToken + "/" + msgContent
# response = requests.get(url=msgUrl).text
# print(response)
print(msgContent)
else:
print("已关机")
# 添加时间戳
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
print("--------------------")
