def loginfunc(self, key, key2, key3, key4, num):
"""登录成功"""
row1 = num
url = self.obj.get_value(row1,
self.obj.get_host()) + self.obj.get_value(
row1, self.obj.get_urlxpath())
# m = MultipartEncoder(
# fields=eval(self.obj.get_value(row1, self.obj.get_params()))) #
# 获取需要发送的数据
m = MultipartEncoder(fields={key: key2, key3: key4})
response = requests.request(method=self.obj.get_value(
row1, self.obj.get_method()),
url=url,
verify=False,
data=m,
headers={'Content-Type': m.content_type})
assert self.obj.get_value(
row1, self.obj.get_verifyID()) in response.text # 获取预期判断值
def _upload_uniq_images_single_req(self, func_item_to_byte_stream, hashes_items_to_upload):
"""
Upload images (binary data) to server with single request.
Expects unique images that aren't exist at server.
:param func_item_to_byte_stream: converter for "item" to byte stream
:param hashes_items_to_upload: list of pairs (hash, item)
:return: list of hashes for successfully uploaded items
"""
content_dict = {}
for idx, (_, item) in enumerate(hashes_items_to_upload):
content_dict["{}-file".format(idx)] = (str(idx), func_item_to_byte_stream(item), 'image/*')
encoder = MultipartEncoder(fields=content_dict)
resp = self._api.post('images.bulk.upload', encoder)
resp_list = json.loads(resp.text)
remote_hashes = [d['hash'] for d in resp_list if 'hash' in d]
if len(remote_hashes) != len(hashes_items_to_upload):
problem_items = [(hsh, item, resp['errors'])
for (hsh, item), resp in zip(hashes_items_to_upload, resp_list) if resp.get('errors')]
logger.warn('Not all images were uploaded within request.', extra={
'total_cnt': len(hashes_items_to_upload), 'ok_cnt': len(remote_hashes), 'items': problem_items})
return remote_hashes
def request_resumable_upload(filepath, headers, upload_url_base, parent_dir,
is_ajax):
write_file(chunked_part1_path, chunked_part1_content)
write_file(chunked_part2_path, chunked_part2_content)
m = MultipartEncoder(
fields={
'parent_dir':
parent_dir,
'file': (resumable_file_name, open(filepath, 'rb'),
'application/octet-stream')
})
params = {'ret-json': '1'}
headers["Content-type"] = m.content_type
if is_ajax:
response = requests.post(upload_url_base, headers=headers, data=m)
else:
response = requests.post(upload_url_base,
headers=headers,
data=m,
params=params)
return response
def upload_zip_with_progress():
from requests_toolbelt import MultipartEncoder, MultipartEncoderMonitor
global upurl
data = {
'config': json.dumps(config),
'file': (os.path.basename(zippath), open(zippath,
'rb'), 'application/zip')
}
total = os.path.getsize(zippath)
hodel = {
'proc': 0,
'last': 0,
}
def on_progress(monitor):
nproc = min(100, int(monitor.bytes_read * 100 / total) if total else 0)
nlast = time.time()
oproc = hodel['proc']
olast = hodel['last']
if (nproc - oproc) > 5 or (nlast - olast) > 1:
proc = '%s%%' % nproc
hodel['proc'] = nproc
hodel['last'] = nlast
barw = 50
prow = int(barw * nproc / 100)
_print('\ruploading... [%s%s] %s' % ('#' * prow, '-' *
(barw - prow), proc),
end='')
e = MultipartEncoder(fields=data)
m = MultipartEncoderMonitor(e, on_progress)
_print('upload', zippath, '->', upurl)
res = requests.post(upurl,
data=m,
headers={
'Content-Type': m.content_type
}).text
_print()
_print(res)
def upload(self, endpoint, data, callback=None):
if self.bearer is None:
return False
m = MultipartEncoder(fields=data)
if callback is not None:
m = MultipartEncoderMonitor(m, callback)
try:
resp = requests.post(self.url(endpoint),
data=m,
headers={
"Content-Type": m.content_type,
"Accept": "application/json",
"Authorization": "Bearer " + self.bearer
})
return self.response(resp)
except:
self.show_error("Connection error")
return False
def upload_slice(self,
io: IO,
callback: Callable[[MultipartEncoderMonitor],
None] = None):
url = PcsNode.File.url()
params = {
"method": "upload",
"type": "tmpfile",
"BDUSS": self._bduss,
}
m = MultipartEncoder(fields={"file": ("file", io, "")})
monitor = MultipartEncoderMonitor(m, callback=callback)
resp = self._request(
Method.Post,
url,
params=params,
data=monitor,
timeout=(3, 9), # (connect timeout, read timeout)
)
return resp.json()
def post_multipart_data(session,
guid,
file_name,
file_size,
last_modified_date,
file_field,
chunk_field=[]):
fields = [("token", ""), ("guid", guid), ("id", "WU_FILE_0"),
("name", file_name), (
"type",
"application/zip",
), ("lastModifiedDate", last_modified_date), ("size", file_size)]
fields.extend(chunk_field)
fields.append(file_field)
encoder = MultipartEncoder(fields=fields, boundary=get_boundary())
encoder = MultipartEncoderMonitor(encoder, my_callback)
res = session.post(
uri,
headers={
"Accept":
"*/*",
"Accept-Encoding":
"gzip, deflate",
"Accept-Language":
"en-US,en;q=0.5",
'Content-Type':
encoder.content_type,
"Host":
"dlload.com",
"Origin":
"https://dlload.com",
"Referer":
"https://dlload.com/disk",
"User-Agent":
"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:84.0) Gecko/20100101 Firefox/84.0"
},
data=encoder)
print('\n', res.content)
def submit(self):
self.submit_url = self._get_submit_url()
mkzip(os.getcwd(), PRESUBMIT_FILENAME, self.filenames,
self.max_zip_size)
fd = open(PRESUBMIT_FILENAME, "rb")
m = MultipartEncoder(
fields={'zipfile': ('student.zip', fd, 'application/zip')})
monitor = MultipartEncoderMonitor(m, self.upload_progress_callback)
try:
r = self.s.post(self.submit_url,
data=monitor,
headers={'Content-Type': monitor.content_type})
r.raise_for_status()
except requests.exceptions.HTTPError as e:
if r.status_code == 403:
raise ProjectAssistantSubmissionError(
"You don't have access to this project.")
elif r.status_code in [404, 429, 500]:
try:
response_json = r.json()
message = response_json.get(
"message") or "An internal server error occurred."
except:
message = "An unknown error occurred"
raise ProjectAssistantSubmissionError(message)
else:
raise
fd.close()
self.submission = r.json()
shutil.move(PRESUBMIT_FILENAME,
submission_filename(self.project_name(), self.id()))
def uploadCollidingPage(self, code, test, page, version, sname, fname,
md5sum, bundle, bundle_order):
self.SRmutex.acquire()
try:
param = {
"user": self.user,
"token": self.token,
"fileName": sname,
"test": test,
"page": page,
"version": version,
"md5sum": md5sum,
"bundle": bundle,
"bundle_order": bundle_order,
}
mime_type = mimetypes.guess_type(sname)[0]
dat = MultipartEncoder(
fields={
"param": json.dumps(param),
"originalImage": (sname, open(fname, "rb"),
mime_type), # image
})
response = self.session.put(
"https://{}/admin/collidingPages/{}".format(self.server, code),
data=dat,
headers={"Content-Type": dat.content_type},
verify=False,
)
response.raise_for_status()
except requests.HTTPError as e:
if response.status_code == 401:
raise PlomAuthenticationException() from None
else:
raise PlomSeriousException(
"Some other sort of error {}".format(e)) from None
finally:
self.SRmutex.release()
return response.json()
def upload_image(img_path, type):
header = {"Content-Type": "multipart/form-data"}
url = "http://" + configure.host + ":" + configure.port + "/uploadImage"
img = open(img_path, "rb") # 以2进制方式打开图片
imageType = "image/jpeg"
img_name = "temp.jpg"
if img_path.endswith('.png'):
imageType = "image/png"
img_name = "temp.png"
body = MultipartEncoder({
"sessionKey": configure.session,
"img": (img_name, img, imageType),
"type": type
})
#🌿🌿🌿🌿🌿🌿🌿🌿请求头 太尼玛恶心了 这里卡了好几个小时 标记一下 🌿🌿🌿🌿🌿🌿🌿🌿🌿
header['Content-Type'] = body.content_type
response = requests.post(url, data=body, headers=header)
response_json = response.json()
print(response_json)
img.close()
if response_json and len(response_json["url"]) > 0:
return response_json
def create_file(self, file_name: str, parent: str = None) -> dict:
params = {'suppress': 'deduplication'}
basename = os.path.basename(file_name)
metadata = {'kind': 'FILE', 'name': basename}
if parent:
metadata['parents'] = [parent]
mime_type = _get_mimetype(basename)
f = io.BytesIO()
# basename is ignored
m = MultipartEncoder(fields=OrderedDict([('metadata', json.dumps(metadata)),
('content', (quote_plus(basename), f, mime_type))])
)
ok_codes = [http.CREATED]
r = self.BOReq.post(self.content_url + 'nodes', params=params, data=m,
acc_codes=ok_codes, headers={'Content-Type': m.content_type})
if r.status_code not in ok_codes:
raise RequestError(r.status_code, r.text)
return r.json()
def test_basic_multiple():
first = ValueTarget()
second = ValueTarget()
third = ValueTarget()
encoder = MultipartEncoder(
fields={'first': 'foo', 'second': 'bar', 'third': 'baz'}
)
parser = StreamingFormDataParser(
headers={'Content-Type': encoder.content_type}
)
parser.register('first', first)
parser.register('second', second)
parser.register('third', third)
parser.data_received(encoder.to_string())
assert first.value == b'foo'
assert second.value == b'bar'
assert third.value == b'baz'
def uploadFile1(file_dir, file_name, upload_dir, posturl, parent_dir,
set_headers):
print "Uploading: " + str(file_dir + "/" + file_name).replace("//", "/")
e = MultipartEncoder(
fields={
'filename':
file_name,
'file': (file_name, open(file_dir + "/" + file_name, 'rb'),
'text/plain'),
'parent_dir':
parent_dir,
'relative_path':
upload_dir
})
callback = create_callback(e.len)
set_params = MultipartEncoderMonitor(e, callback)
set_headers["Content-type"] = set_params.content_type
r = requests.post(posturl, data=set_params, headers=set_headers)
#data = json.loads(r.content)
callback(-1)
def search_3d(self, url):
try:
if url[:4] == 'http': # 网络url
datas = {"url": url}
res = requests.post(self.url_3d,
data=datas,
**self.requests_kwargs)
else: # 是否是本地文件
m = MultipartEncoder(
fields={
'file': ('filename', open(url, 'rb'),
"type=multipart/form-data")
})
headers = {'Content-Type': m.content_type}
urllib3.disable_warnings()
res = requests.post(self.url_3d,
headers=headers,
**self.requests_kwargs)
if res.status_code == 200:
return IqdbResponse(res.content)
except Exception as e:
logger.error(e)
def login():
"""登录成功"""
obj = HandleExcel()
row1 = 1
url = obj.get_value(row1, obj.get_host()) + obj.get_value(
row1, obj.get_urlxpath())
m = MultipartEncoder(
fields=eval(obj.get_value(row1, obj.get_params())) #获取需要发送的数据
)
response = requests.request(method=obj.get_value(row1, obj.get_method()),
url=url,
verify=False,
data=m,
headers={'Content-Type': m.content_type})
assert obj.get_value(row1, obj.get_verifyID()) in response.text #获取预期判断值
a = requests.utils.dict_from_cookiejar(response.cookies) #获取cookie并返回
return a
def uploadFile(path):
url = settings['upload_url']
params = {"key": settings['key'], "result_as": "json"}
filename = path.split("\\")[-1]
filename = filename.encode("ascii", errors="ignore").decode()
fields = {"file": (filename, open(path, 'rb').read())}
encoder = MultipartEncoder(fields=fields)
encoderMonitor = MultipartEncoderMonitor(encoder, None)
headers = {
"Connection": "Keep-Alive",
"Content-Type": encoderMonitor.content_type,
"Keep-Alive": "timeout=10800"
}
response = requests.post(url,
data=encoderMonitor,
headers=headers,
params=params)
return response.text
def post_files(self, files: FileList, **data: JSON) -> JSON:
# upload files using custom json-data protocol
# build the fields
file_header = {"Content-Encoding": "gzip"}
def mk_file_fields(field_name: str, f: Path):
# compress the file, in-place
# TODO - disable compression where unneeded, e.g. .gz, .zip, .png, etc
with compress_file(f) as f_gz:
return (field_name, (f.name, open(f_gz, "rb"), guess_type(f), file_header))
fields = [mk_file_fields(k, x) for (k, v) in files.items() for x in v]
fields.append(("json_data", json.dumps(data)))
e = MultipartEncoder(fields=fields)
extra_headers = {"Content-Type": f"{e.content_type}; dp-files=True"}
if e.len > 1e6: # 1 MB
log.debug("Using upload monitor")
fill_char = click.style("=", fg="yellow")
with click.progressbar(
length=e.len, width=0, show_eta=True, label="Uploading files", fill_char=fill_char
) as bar:
def f(m: MultipartEncoderMonitor):
# update every 100KB
m.buf_bytes_read += m.bytes_read - m.prev_bytes_read
m.prev_bytes_read = m.bytes_read
if m.buf_bytes_read >= 1e5:
# print(f"{m.buf_bytes_read=}, {m.prev_bytes_read=}")
bar.update(m.buf_bytes_read)
m.buf_bytes_read = 0
m = MultipartEncoderMonitor(e, callback=f)
m.buf_bytes_read = 0
m.prev_bytes_read = 0
r = self.session.post(self.url, data=m, headers=extra_headers, timeout=self.timeout)
else:
r = self.session.post(self.url, data=e, headers=extra_headers, timeout=self.timeout)
return self._process_res(r)
def sendPhoto(self,
chat_id,
photo_id=None,
photo_file=None,
caption=None,
disable_notification=None,
reply_to_message_id=None,
reply_markup=None):
"""
Use this method to send photos.
On success, the sent Message is returned.
For more details read the `Telegram docs <https://core.telegram.org/bots/api#sendphoto>`_.
"""
p = {
'chat_id': chat_id
}
if photo_file is not None:
p['photo'] = self.__input_file_tuple(photo_file)
elif photo_id is not None:
p['photo'] = photo_id
else:
raise ApiRequestError('photo_id and photo_file cannot be both None')
if caption is not None:
p['caption'] = caption
if disable_notification is not None:
p['disable_notification'] = disable_notification
if reply_to_message_id is not None:
p['reply_to_message_id'] = reply_to_message_id
if reply_markup is not None:
p['reply_markup'] = reply_markup.to_json()
r = None
if photo_file is not None:
m = MultipartEncoder(p)
r = requests.post(self.__base_url_for('sendPhoto'), data=m, headers={'Content-Type': m.content_type})
else:
r = requests.get(self.__base_url_for('sendPhoto'), params=p)
return self.__handle_object_response(r, 'sendPhoto', Message)
def upload(abs, fname):
server = random.randint(1, 120)
total = check_size(abs)
url = "https://www{}.zippyshare.com/upload".format(server)
f = open(abs, 'rb')
try:
data = {'file': (fname, f)}
pb = tqdm(total=total, unit='B', unit_scale=True, miniters=1)
multi = MultipartEncoder(fields=data)
monitor = MultipartEncoderMonitor(
multi, lambda multi: pb.update(monitor.bytes_read - pb.n))
if cfg.private:
data['private'] = "true"
else:
data['notprivate'] = "true"
s.headers.update({'Content-type': monitor.content_type})
r = s.post(url, data=monitor)
r.raise_for_status()
finally:
pb.close()
f.close()
return r.text
def sendDocument(self,
chat_id,
document_id=None,
document_file=None,
caption=None,
disable_notification=None,
reply_to_message_id=None,
reply_markup=None):
"""
Use this method to send general files. On success, the sent Message is returned.
Bots can currently send files of any type of up to 50 MB in size, this limit may be changed in the future.
For more details read the `Telegram docs <https://core.telegram.org/bots/api#senddocument>`_.
"""
p = {
'chat_id': chat_id
}
if document_file is not None:
p['document'] = self.__input_file_tuple(document_file)
elif document_id is not None:
p['document'] = document_id
else:
raise ApiRequestError('document_id and document_file cannot be both None')
if caption is not None:
p['caption'] = caption
if disable_notification is not None:
p['disable_notification'] = disable_notification
if reply_to_message_id is not None:
p['reply_to_message_id'] = reply_to_message_id
if reply_markup is not None:
p['reply_markup'] = reply_markup.to_json()
r = None
if document_file is not None:
m = MultipartEncoder(p)
r = requests.post(self.__base_url_for('sendDocument'), data=m, headers={'Content-Type': m.content_type})
else:
r = requests.get(self.__base_url_for('sendDocument'), params=p)
return self.__handle_object_response(r, 'sendDocument', Message)
def upload_UploadFile(self, filePath, folderKey="myfiles", x_filename=""):
self.checkSessionToken()
boundary_value = uuid.uuid4().hex
content_type = mimetypes.guess_type(filePath)
fp = open(filePath, 'rb')
m = MultipartEncoder(fields={
'fileUpload':
(os.path.basename(filePath), fp, 'application/octet-stream')
},
boundary=boundary_value)
query_string_parameters = {
'session_token': self.sessionToken,
'uploadkey': folderKey,
'response_format': self.responseFormat
}
headers = {
'X-Filename': os.path.basename(filePath),
'X-Filesize': os.path.getsize(filePath),
'User-Agent':
'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.22 (KHTML, like Gecko) Chrome/25.0.1364.172 Safari/537.22',
'Content-Type':
'multipart/form-data; boundary=%s' % boundary_value,
'Content-Length': len(m)
}
url = self.FILE_UPLOAD + '?' + urllib.urlencode(
query_string_parameters)
r = requests.post(url, data=m, headers=headers)
js = json.loads(r.text)['response']
if (js['result'] == "Error"):
return js['message']
return js['doupload']['key']
def buildPayload(self, message):
print('{} [post] building formdata payload...'.format(time()))
formdata = {}
formdata['topic'] = self._id
formdata['subject'] = 'RE:' + \
self.title.encode('unicode-escape').decode('latin-1')
formdata['icon'] = 'xx'
formdata['message'] = message.encode('unicode-escape').decode(
'latin-1')
formdata['notify'] = '0'
formdata['do_watch'] = '0'
formdata['goback'] = '1'
formdata['post'] = 'Post'
formdata['num_replies'] = str(self.n_replies)
formdata['seqnum'] = str(self.seqnum)
formdata['sc'] = str(self.sc)
payload = MultipartEncoder(fields=formdata)
print('{} [post] formdata payload encoded.'.format(time()))
return payload
def add_teacher_name(s):
#添加老师页面
url = host + '/xadmin/hello/teacher/add/'
#获取页面隐藏参数
r = requests.get(url)
# print(r.text)
#使用正则表达式获取token
csrftoken = re.findall("name='csrfmiddlewaretoken' value='(.+?)'", r.text)
print(csrftoken)
body = MultipartEncoder(fields=[("csrfmiddlewaretoken", csrftoken[0]),
("csrfmiddlewaretoken", csrftoken[0]),
("teacher_name", "yoyo211111114"),
("tel", "131321313"),
("mail", "*****@*****.**"), ("sex", "M"),
("_save", "")], )
r2 = s.post(url, data=body, headers={'Content-Type': body.content_type})
# print(r2.text)
return r2.text
def _upload_multipart_file_form(file_path, file_uri):
if not os.path.exists(file_path):
error('File not found: ' + file_path)
#port = get_controller_port()i
session = get_session()
#port = session.port
port = 443
path = 'https://%s:%s/api/fileservice/uploads' % (session.controller_ip,
port)
file_name = os.path.basename(file_path)
with open(file_path, "rb") as f:
f_data = {
"file": (file_name, f, "application/octet-stream"),
"uri": file_uri
}
m = MultipartEncoder(f_data)
r = session.post(path, data=m)
if r.status_code > 300:
error('Fail to upload: ' + r.content)
def inference_remote_image(self,
id,
image_hash,
ann=None,
meta=None,
mode=None):
data = {
"request_type": "inference",
"meta": meta or ProjectMeta().to_json(),
"annotation": ann or None,
"mode": mode or {},
"image_hash": image_hash
}
fake_img_data = sly_image.write_bytes(np.zeros([5, 5, 3]), '.jpg')
encoder = MultipartEncoder({
'id': str(id).encode('utf-8'),
'data': json.dumps(data),
'image': ("img", fake_img_data, "")
})
response = self._api.post('models.infer',
MultipartEncoderMonitor(encoder))
return response.json()
def upload_photo(self,
photo,
caption=None,
upload_id=None,
is_sidecar=None):
if upload_id is None:
upload_id = str(int(time.time() * 1000))
data = {
'upload_id':
upload_id,
'_uuid':
self.uuid,
'_csrftoken':
self.token,
'image_compression':
'{"lib_name":"jt","lib_version":"1.3.0","quality":"87"}',
'photo': ('pending_media_%s.jpg' % upload_id, open(photo, 'rb'),
'application/octet-stream', {
'Content-Transfer-Encoding': 'binary'
})
}
if is_sidecar:
data['is_sidecar'] = '1'
m = MultipartEncoder(data, boundary=self.uuid)
self.s.headers.update({
'X-IG-Capabilities': '3Q4=',
'X-IG-Connection-Type': 'WIFI',
'Cookie2': '$Version=1',
'Accept-Language': 'en-US',
'Accept-Encoding': 'gzip, deflate',
'Content-type': m.content_type,
'Connection': 'close',
'User-Agent': USER_AGENT
})
response = self.s.post(API_URL + "upload/photo/", data=m.to_string())
if response.status_code == 200:
if self.configure(upload_id, photo, caption):
self.expose()
return False
def uploadPhoto(self, photo, caption=None, upload_id=None):
if upload_id is None:
upload_id = str(int(time.time() * 1000))
if not compatibleAspectRatio(getImageSize(photo)):
self.logger.info('Not compatible photo aspect ratio')
return False
with open(photo, 'rb') as photo_bytes:
data = {
'upload_id':
upload_id,
'_uuid':
self.uuid,
'_csrftoken':
self.token,
'image_compression':
'{"lib_name":"jt","lib_version":"1.3.0","quality":"87"}',
'photo': ('pending_media_%s.jpg' % upload_id, photo_bytes,
'application/octet-stream', {
'Content-Transfer-Encoding': 'binary'
})
}
m = MultipartEncoder(data, boundary=self.uuid)
self.session.headers.update({
'X-IG-Capabilities': '3Q4=',
'X-IG-Connection-Type': 'WIFI',
'Cookie2': '$Version=1',
'Accept-Language': 'en-US',
'Accept-Encoding': 'gzip, deflate',
'Content-type': m.content_type,
'Connection': 'close',
'User-Agent': config.USER_AGENT
})
response = self.session.post(config.API_URL + "upload/photo/",
data=m.to_string())
if response.status_code == 200:
if self.configurePhoto(upload_id, photo, caption):
self.expose()
return True
return False
def test_send_mail(self, mock_send_mail_handler):
# PREPARE DATA
template = "accounts_change_password"
url_reverse = reverse('api:mail-list')
params = {
"name": faker.name(),
"public_url": faker.url(),
"recipients": [faker.email()],
}
data = {
"template": template,
"params": json.dumps(params),
"lang": "en",
}
m = MultipartEncoder(fields=data)
# DO ACTION
response = self.client.post(url_reverse,
data=m.to_string(),
content_type=m.content_type)
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
self.assertTrue(mock_send_mail_handler.called)
def upload_file(self, relation_key, schema, data, overwrite=None,
delimiter=None, binary=None, is_little_endian=None):
"""Upload a file in a streaming manner to Myria.
Args:
relation_key: relation to be created.
schema: schema of the relation.
data: the bytes to be uploaded.
overwrite: optional boolean indicating that an existing relation
should be overwritten. Myria default is False.
delimiter: optional character which delimits a CSV file. Only valid
if binary is False. Myria default is ','.
binary: optional boolean indicating that the data is encoded as
a packed binary. Myria default is False.
is_little_endian: optional boolean indicating that the binary data
is in little-Endian. Myria default is False.
"""
from requests_toolbelt import MultipartEncoder
fields = [('relationKey', relation_key), ('schema', schema),
('overwrite', overwrite), ('delimiter', delimiter),
('binary', binary), ('isLittleEndian', is_little_endian)]
fields = [(name, (name, json.dumps(value), 'application/json'))
for (name, value) in fields]
# data must be last
if binary:
data_type = 'application/octet-stream'
else:
data_type = 'text/plain'
fields.append(('data', ('data', data, data_type)))
m = MultipartEncoder(fields=fields)
r = self._session.post(self._url_start + '/dataset', data=m,
headers={'Content-Type': m.content_type})
if r.status_code not in (200, 201):
raise MyriaError('Error %d: %s'
% (r.status_code, r.text))
return r.json()
def upload_img(file):
"""
上传图片至微博图传
:param file:
:return:
"""
if os.path.isfile(file):
# API : https://img.yyhyo.com/api.php
url = 'https://img.yyhyo.com/upload.php?type=Sina'
# 拼接提交数据
multipart_encoder = MultipartEncoder(
fields={
# 测试中文文件名会有问题，所以只加上扩展名
'fileupload': ('xx.' + file.split('.')[-1], open(file, 'rb'))
})
res = requests.post(
url,
data=multipart_encoder,
headers={'Content-Type': multipart_encoder.content_type})
source = res.json()
if source['code'] == '0':
return source['msg']
