def import_sub_type(self, url, params, api_proxy, path):
filename = path.split('/')[-1]
authorization_headers = self.build_authorization_header()
headers = authorization_headers
headers['Prefer'] = 'respond-async'
print("Posting the file %s" % (filename))
try:
if self.mfa:
with open(path, 'rb') as f:
form = encoder.MultipartEncoder({
"documents": (path, f, "application/octet-stream"),
"composite": "NONE",
})
headers['Content-Type'] = form.content_type
resp = requests.post(url, params=params, proxies=self.proxy_dict, verify=False, headers=headers, data=form)
else:
with open(path, 'rb') as f:
form = encoder.MultipartEncoder({
"documents": (path, f, "application/octet-stream"),
"composite": "NONE",
})
headers['Content-Type'] = form.content_type
resp = requests.post(url, auth=self.authentication, params=params, proxies=self.proxy_dict, verify=False, headers=headers, data=form)
resp.raise_for_status()
except requests.exceptions.HTTPError:
print_response(resp)
raise Exception("Error during importing of Apigee: %s" % (api_proxy))
return resp
def blob_upload(self, blob_id: str, fd, total_length: int):
""" Upload the BLOB and use a callback function for progress indicator. """
self.__total_length = total_length
# fields={'field0': 'value', 'field1': 'value',
# 'field2': ('filename', open('file.py', 'rb'), 'text/plain')}
the_fields: dict = dict()
the_fields["blob_id"] = blob_id
the_fields["file"] = ("filename", fd, "application/octet-stream")
e = encoder.MultipartEncoder(fields=the_fields)
m = encoder.MultipartEncoderMonitor(e, self.my_callback)
the_headers = dict(self.__headers) # or orig.copy()
the_headers["Content-Type"] = m.content_type
the_url = self._url + "blob_upload"
# requests.post(the_url, data=m, headers={'Content-Type': m.content_type}, proxies=self.__proxies,
# auth=self.__auth)
requests.post(the_url,
data=m,
headers=the_headers,
proxies=self.__proxies,
auth=self.__auth)
def gofile_upload(files):
"""
Uploads to gofile.io
"""
try:
global progress_state
session = Session()
with open(files, 'rb') as f:
form = encoder.MultipartEncoder({
"file": (files, f, "application/octet-stream"),
})
headers = {
"Prefer": "respond-async",
"Content-Type": form.content_type
}
r = session.post("https://srv-store1.gofile.io/uploadfile",
headers=headers,
data=form)
session.close()
resp = json.loads(r.content)
if r.status_code == 200:
gofile_url = f'https://gofile.io/d/{resp["data"]["code"]}'
print(f'GoFile Uploaded: {gofile_url}')
progress_state.append(1)
if gui_state:
gui.update_links(f'GoFile: {gofile_url}')
else:
print('Something else happened')
except Exception as e:
print('GoFile did not upload')
def __upload_large_file(session,
file_path,
asset_name,
properties=None,
nodata=None):
upload_url = __get_upload_url(session)
with open(file_path, 'rb') as f:
form = encoder.MultipartEncoder({
"documents": (file_path, f, "application/octet-stream"),
"composite":
"NONE",
})
headers = {
"Prefer": "respond-async",
"Content-Type": form.content_type
}
resp = session.post(upload_url, headers=headers, data=form)
gsid = resp.json()[0]
asset_data = {
"id":
asset_name,
"tilesets": [{
"sources": [{
"primaryPath": gsid,
"additionalPaths": []
}]
}],
"bands": [],
"properties":
properties,
"missingData": {
"value": nodata
}
}
return asset_data
def storeImg(filename):
#store the image on a web server.
global deviceId, imgUploadServer, app_key
e = encoder.MultipartEncoder(
fields={'file': (filename, open(filename, 'rb'), 'image/jpeg')})
m = encoder.MultipartEncoderMonitor(e, imgStoreMonitor_callback)
reqParams = {
'value': filename,
'name': filename,
'filename': filename,
'st_filename': filename,
'st_deviceid': deviceId,
'app_key': app_key
}
contentType = 'image/jpeg'
contentDisposition = 'form-data'
#send image as a post.
r = requests.post(imgUploadServer,
data=m,
params=reqParams,
headers={'Content-Type': m.content_type})
if r.status_code != requests.codes.ok:
print 'there was an error' + str(r.status_code)
return None
else:
jsonData = json.loads(r.text)
newURL = jsonData['attachment']['url']
print 'Image sent. returned URL=' + newURL
return newURL
def anonfiles_upload(files):
"""
Uploads to anonfiles.io
"""
try:
global progress_state
session = Session()
with open(files, 'rb') as f:
form = encoder.MultipartEncoder({
"file": (files, f, "application/octet-stream"),
})
headers = {
"Prefer": "respond-async",
"Content-Type": form.content_type
}
r = session.post("https://api.anonfiles.com/upload",
headers=headers,
data=form)
session.close()
resp = json.loads(r.content)
if r.status_code == 200:
print('AnonFiles Uploaded: ' +
resp['data']['file']['url']['short'])
progress_state.append(1)
if gui_state:
gui.update_links('AnonFiles: ' +
resp['data']['file']['url']['short'])
else:
print('Something else happened')
except Exception as e:
print('AnonFiles did not upload')
def upload(cls, file_name, task, progressCallback=None):
"""Upload a resource e.g.
"""
form = task['data']['result']['form']
port_url = form['url']
params = form['parameters']
params['x:timestamp'] = int(time.time())
fields = params if params else {}
try:
file = open(file_name, 'rb')
_, shortName, ext = util.get_fileNameExt(file_name)
for key in fields.keys():
if isinstance(fields[key], int):
fields[key] = str(fields[key])
fields['file'] = (shortName+ext, file, 'video/mp4')
e = encoder.MultipartEncoder(fields=fields)
m = encoder.MultipartEncoderMonitor(e, progressCallback)
res = requests.request(method='POST', url=port_url, data=m, headers={'Content-Type': m.content_type})
file.close()
if res.status_code != 200:
raise Exception("got exception while uploading file")
else:
result = json.loads(res.text)
if result['code'] > 0:
raise Exception(result['msg'])
if result['data']['status']=='failed':
raise Exception(result['data']['message'])
return result
except Exception as e:
raise Exception("got exception while uploading file")
def upload_dataset(self, dataset_path, dataset_name=None, has_header=True):
if dataset_name is None:
head, tail = os.path.split(dataset_path)
dataset_name = tail
# dataset_name = dataset_path.split('/')[-1]
url = self.server_url + self.routes['upload_dataset']
headers = self.get_auth_header()
if headers is None:
return False, "Cannot get Auth token. Please log in."
if not os.path.isfile(dataset_path):
return False, "File not found"
with open(dataset_path, 'rb') as f:
form = encoder.MultipartEncoder({
"dataset": (str(dataset_path), f, 'text/csv/h5'),
'dataset_name':
str(dataset_name),
'has_header':
str(has_header)
})
headers.update({
"Prefer": "respond-async",
"Content-Type": form.content_type
})
r = self.s.post(url, headers=headers, data=form)
return self.get_return_info(r)
def uploadFile(self, filePath, name='runner.ipa'):
self.p(' 开始上传' + filePath)
url = 'https://www.pgyer.com/apiv2/app/upload'
file = open(filePath, 'rb')
# dataJson = {
# '_api_key': '2e8571d626b9a8c8b752e59624481847',
# 'buildInstallType': '3',
# 'buildPassword': '',
# }
# 没有进度条的上传
# fileDir = {'file': file}
# response = requests.post(url, files=fileDir, data=dataJson)
# jsonStr = response.json()
e = encoder.MultipartEncoder(
fields={
'_api_key': '2e8571d626b9a8c8b752e59624481847',
# 'buildInstallType': '3',
# 'buildPassword': '',
'file': (name, file, 'application/x-www-form-urlencoded'),
}, )
m = encoder.MultipartEncoderMonitor(e, self.my_callback)
h = {'Content-Type': m.content_type, "enctype": "multipart/form-data"}
self.fileLength = os.path.getsize(filePath)
r = requests.post(url, data=m, headers=h).json()
if int(dict(r).get('code')) != 0:
raise Exception('上传失败:{0}'.format(dict(r).get('message')), )
else:
self.p(str(r).replace('u\'', '\'')) # 去掉前边的u
self.p(filePath + '上传成功')
def uploadFile(filename):
e = encoder.MultipartEncoder(
fields={
'file': ('xianzixun.apk', open(filename, 'rb'),
'application/vnd.android.package-archive')
})
m = encoder.MultipartEncoderMonitor(e, my_callback)
headers = {
'Authorization': "Bearer" + token,
'Referer': "http://xianzixun.net:8000/swagger-ui.html",
'Origin': 'http://xianzixun.net:8000',
'Content-Type': m.content_type
}
print("上传中...")
pbar.maxval = m.len
pbar.term_width = 60
print("total len:" + str(m.len))
pbar.start()
resp = requests.post(server_url, data=m, headers=headers)
print(resp.status_code, resp.text)
down_url = json.loads(resp.text)["data"]
print("更新apk_info中的下载链接...")
apk_info["downUrl"] = down_url
print("更新后apk_info:" + json.dumps(apk_info))
print("------------------------------------------")
return json.loads(resp.text)["data"]
def upload_datafile_with_post(datafile_path, datafile_dict, upload):
"""
Upload a file to the MyTardis API via POST, creating a new
DataFile record.
"""
url = "%s/api/v1/mydata_dataset_file/" % settings.general.mytardis_url
upload.buffered_reader = io.open(datafile_path, "rb")
encoded = encoder.MultipartEncoder(
fields={
"json_data":
json.dumps(datafile_dict),
"attached_file": (
upload.filename,
upload.buffered_reader,
"application/octet-stream",
),
})
# Workaround for issue with httplib's hard-coded read size
# of 8192 bytes which can lead to slow uploads, see:
# http://toolbelt.readthedocs.io/en/latest/uploading-data.html
# https://github.com/requests/toolbelt/issues/75
multipart_encoder_read_method = encoded.read
encoded.read = lambda size: multipart_encoder_read_method(1024 * 1024)
multipart = encoder.MultipartEncoderMonitor(encoded)
headers = settings.default_headers
headers["Content-Type"] = multipart.content_type
response = requests.post(url, data=multipart, headers=headers)
return response
def create_version(image_name, version, workspace_path, monitor_callback,
token):
with open(workspace_path, 'rb') as file:
e = encoder.MultipartEncoder(
fields={
'version': version,
'source': ('workspace', file, 'text/plain')
})
m = encoder.MultipartEncoderMonitor(e, monitor_callback)
response = requests.post(base_images_url + '/' + image_name +
'/versions',
data=m,
headers={
'Content-Type': m.content_type,
'Authorization': 'JWT ' + token
})
if response.status_code == 404:
raise ResourceNotFoundError(
response=response,
message="There is no image named {}, please check for typo".
format(image_name))
if response.status_code != 200:
raise get_exception(response)
else:
return response.text
def createfile(self, path, parentId, puid, _call_back=None):
self.data = None
size = os.path.getsize(path)
limit = 1024 * 1024
bytes_per_chunk = 512 * 1024
if size >= limit + bytes_per_chunk * 2 :
filename = os.path.basename(path)
buf0, buf1=None, None
with open(path, 'rb') as f:
buf0 = f.read(bytes_per_chunk)
f.seek(-bytes_per_chunk, 2)
buf1 = f.read(bytes_per_chunk)
e = encoder.MultipartEncoder(
fields = {
"size": str(size),
"fn" : filename,
"file0" : ("blob", buf0, "application/octet-stream"),
"file1" : ("blob", buf1, "application/octet-stream"),
"fldid" : parentId,
"puid" : self.check_puid(parentId, puid),
},
boundary = "------WebKitFormBoundary" + "kYAh6TNBAQmVa4BH"
)
data = self.make_data(e, _call_back, "create file: ", False)
url = DATA["api"]["createfile"]["url"]
header = DATA["pan_header"]
header["Content-Type"] = data.content_type
r = self.session.post(url=url, headers=header, data=data)
if r.status_code == 200:
self.data=json.loads(r.text)
#print("createfile success!")
else:
print("createfile failed!")
sys.exit(1)
return self
def echo(self, speech):
headers = self._build_headers()
metadata = self._build_meta()
meta = json.dumps(metadata)
multiple_files = [
('metadata', ('metadata', meta, 'application/json; charset=UTF-8')),
('audio', ('audio', speech, 'application/octet-stream')),
]
data = encoder.MultipartEncoder(
fields=multiple_files
)
headers['Content-Type'] = data.content_type
try:
r = self._sess.post(self._api_events,
headers=headers,
data=data,
#timeout=60,
stream=True)
except ssl.SSLError as e:
print(e)
return []
return self.get_audio_out(r)
def get_multipartdata(file_path):
multipartdata = encoder.MultipartEncoder(
fields={
"files[0]": (os.path.basename(file_path),
open(file_path, "rb").read(), "image/jpeg")
})
return multipartdata
def _build_dynamic_upload_data(self, fields, callback=None):
# The monitor is the data!
encoded_data = encoder.MultipartEncoder(fields=fields)
if self.state.is_using_cli is True and self.state.verbose:
bar = Bar('Uploading ' + fields['file'][0], suffix='%(percent)d%%')
return encoder.MultipartEncoderMonitor(encoded_data, lambda m: bar.goto(m.bytes_read / m.len * 100))
elif self.state.is_using_cli is False and callback:
return encoder.MultipartEncoderMonitor(encoded_data, lambda m: callback(EVENT_METHOD_PROGRESS_PERCENT,
m.bytes_read / m.len * 100))
else:
return encoder.MultipartEncoderMonitor(encoded_data, None)
def base_upload(self, path, parentId, puid, _call_back=None):
crc, ts = None, None
data = self.createfile(path, parentId, puid).data
if data is not None:
if not self.quite:
print(data)
result = data["result"]
if result:
print("upload success!")
return self
else:
crc = data["crc"]
ts = data["timemil"]
else:
print("file size < 2M")
filename = os.path.basename(path)
size = os.path.getsize(path)
date = getFileLastGMTime(path)
url = DATA["api"]["upload"]["url"]
header = DATA["pan_header"]
header["Accept"] = "*/*"
header["X-Requested-With"] = "mark.via"
fields = {
"folderId" : parentId,
"puid" : self.check_puid(parentId, puid),
"id" : "WU_FILE_0",
"name" : filename,
"type" : "application/octet-stream",
"lastModifiedDate" : date,
"size": str(size),
"file" : (filename, open(path, "rb"), "application/octet-stream")
}
if crc is not None:
fields["crc"] = crc
if ts is not None:
fields["ts"] = ts
e = encoder.MultipartEncoder(
fields = fields,
boundary = "------WebKitFormBoundary" + "kYAh6TNBAQmVa4BH"
)
if not self.quite:
print(fields)
print()
data = self.make_data(e, _call_back, "uploading: ")
header["Content-Type"] = data.content_type
r = self.session.post(url=url, headers=header, data=data)
self.data=json.loads(r.text)
print()
if r.status_code == 200 and self.data["success"]:
print("upload success!")
else:
print("upload failed!")
return self
def upload(ctw_path,
credentials,
url_base="http://localhost:5555/",
group=None):
assert credentials['email'] is not None and credentials[
"password"] is not None
print("Attempting login")
login_url = url_base + "user/sign-in"
session = requests.Session()
# Have to grab the token from the login request in order to successfully login.
r = session.post(login_url, data=credentials)
soup = BeautifulSoup(r.text, "html.parser")
token = soup.find('input', {'name': 'csrf_token'})['value']
credentials.update({"csrf_token": token})
r = session.post(login_url, data=credentials)
print("Successful login...")
# The worksheet name is encoded by the filename of the .ctw.tgz file.
worksheet_name = os.path.basename(ctw_path.split(".ctw.")[0])
# Construct url.
upload_url = url_base + "user/worksheet/" + worksheet_name
if group is not None:
upload_url += "?group=" + group
# Tag the file onto the request.
form = encoder.MultipartEncoder({
"documents":
(os.path.basename(ctw_path), open(ctw_path,
"rb"), "application/octet-stream"),
"composite":
"NONE",
})
headers = {"Prefer": "respond-async", "Content-Type": form.content_type}
# Attempt to upload file.
try:
r = session.post(upload_url, headers=headers, data=form)
# TODO: the server isn't returning error codes with the requests library.
# Catching this error is a temporary fix. Could be flask, could be machine based.
except ConnectionError:
# This error seems to occur in the likely case that
# credentials aren't valid. TODO: evaluate whether the server
# should be less cryptic, why isn't the 403 coming back?
raise ValueError(
"""Please check your credentials file for the proper email and password.
If you have supplied a group name, double check and make sure the name is spelled correctly."""
)
if r.status_code != 200:
print("server failed with code %d" % r.status_code)
def _encode_multi_part_input(parts=[]):
if type(parts) is dict:
new_parts = []
for key, value in parts.items():
new_parts.append((key, value))
parts = new_parts
encoded_parts = []
for key, value in parts:
add = (key, value if type(value) is tuple else value)
encoded_parts.append(add)
ret = encoder.MultipartEncoder(encoded_parts)
return ret.to_string(), ret.content_type
def upload(self, dataset_id, file_io, headers={}):
form = encoder.MultipartEncoder(
{"file": ('dataset.hdf5', file_io, "text/plain")})
headers.update({
"Prefer": "respond-async",
"Content-Type": form.content_type,
})
url = '/api/v1/dataset/{}'.format(dataset_id)
resp = self.simulate_post(url, headers=headers, body=form.read())
return resp
def test_case_layout(file_name, solution_file_name):
url = os.getenv('BASE_URL', None)
if url is None:
raise "Base url is not export in the enviorment."
with open(file_name, 'rb') as f:
form = encoder.MultipartEncoder(
{"df_file": (file_name, f, "text/csv")})
headers = {"Content-Type": form.content_type}
resp = requests.post(url, headers=headers, data=form)
answers = transform_data(resp)
count = check_equality(answers, solution_file_name)
return (answers, count)
def upload(dataset_id, file_name):
url = 'http://localhost:8080/api/v1/dataset/{}'.format(dataset_id)
with open(file_name, 'rb') as f:
form = encoder.MultipartEncoder({
"file": (file_name, f, "text/plain")
})
print("Content-Type:", form.content_type)
headers = {
"Prefer": "respond-async",
"Content-Type": form.content_type,
}
resp = post(url, headers=headers, data=form, stream=True)
print('Upload dataset:', resp.status_code, 'resp.text:', resp.text)
def upload(fname, folderid):
#strip unicode characters from filename
file_name = str(fname.name).encode('ascii',
errors='replace').decode('ascii')
if os.path.getsize(fname) == 0:
print("{0} is empty! Skipping...".format(file_name))
return 0
try:
file = open(fname, 'rb')
except Exception:
print("{0} could not be opened! Skipping...".format(
os.path.split(fname)[1]))
return 0
payload = encoder.MultipartEncoder({
'fa':
'c.apiupload',
'api_key':
apiKey,
'destfolderid':
folderid,
'filedata': (file_name, file, 'application/octet-stream')
})
print("Uploading {0}...".format(os.path.split(fname)[1]),
end=' ',
flush=True)
r = requests.post(upload_url,
data=payload,
headers={"Content-Type": payload.content_type})
file.close()
if r.status_code == requests.codes.ok:
data = xmltodict.parse(r.content)
if int(data['Response']['responsecode']) == 0:
print('OK')
return 0
else:
if data['Response']['message'] == 'File already exists in Razuna':
print("Exists! Skipping...")
return 0
else:
print('FAIL')
print(data['Response']['message'])
return -1
def upload_source(workspace_path, manifest, monitor_callback):
with open(workspace_path, 'rb') as file:
e = encoder.MultipartEncoder(
fields={
'source': ('workspace', file, 'text/plain'),
'manifest': manifest
})
m = encoder.MultipartEncoderMonitor(e, monitor_callback)
response = get_session().post(base_sources_url,
data=m,
headers={'Content-Type': m.content_type})
if response.status_code != 200:
raise get_exception(response)
return response.json()
def post_file(self, url, data, filepath):
url = "https://%s:%d%s" % (self.ip, self.port, url)
form = encoder.MultipartEncoder({
'json': (None, json.dumps(data), 'application/json'),
'file': ("file", open(filepath, 'rb'), 'application/octet-stream')
})
res = requests.post(url,
data=form,
headers={'Content-Type': form.content_type},
verify=False)
data = res.text
return json.loads(data)
def upload_file(file_name, base, token):
session = requests.Session()
with open(file_name, 'rb') as f:
form = encoder.MultipartEncoder({
'file': (file_name, f, 'application/octet-stream')
})
headers = {
'Authorization': f'Bearer {token}',
'User-Agent': 'App/1.0 ([email protected])',
'Content-Type': form.content_type,
'X-File-Parse': 'true',
'Prefer': 'respond-async'
}
resp = session.post(base + 'account/6/upload', headers=headers, data=form)
session.close()
assert resp.status_code == requests.codes.ok, f'error : {resp.text}'
return resp
def __upload_file_gee(session, file_path, use_multipart):
with open(file_path, 'rb') as f:
upload_url = __get_upload_url(session)
if use_multipart:
form = encoder.MultipartEncoder({
"documents": (file_path, f, "application/octet-stream"),
"composite": "NONE",
})
headers = {"Prefer": "respond-async", "Content-Type": form.content_type}
resp = session.post(upload_url, headers=headers, data=form)
else:
files = {'file': f}
resp = session.post(upload_url, files=files)
gsid = resp.json()[0]
return gsid
def handle_uploaded_file_monitor(file):
"""
:param file: Of type UploadedFile
"""
e = encoder.MultipartEncoder(fields={file.name: file.read()})
encoder_len = e.len
bar = ProgressBar(expected_size=encoder_len, filled_char='=')
def callback(monitor):
bar.show(monitor.bytes_read)
m = encoder.MultipartEncoderMonitor(e, callback)
r = requests.put('http://localhost:4444/',
data=m,
headers={'Content-Type': m.content_type})
print('\nUpload finished! (Returned status {} {})'.format(
r.status_code, r.reason))
def upload_model_expfs(self, model_id, expfs, **kwargs):
"""上传模型扩展文件集
Args:
model_id (str): 模型编号。
expfs (path): 模型扩展文件集。
Returns:
Model: 任务id、时间、状态和返回值；
"""
if isinstance(expfs, text_type):
filename = split(expfs)[1]
else:
filename = expfs.name
def upload_callback(monitor):
total_bytes = monitor.len
bytes_consumed = monitor.bytes_read
sys.stdout.write('\r文件大小：{}, 上传进度: {}%，已上传 {}'.format(
human_byte(total_bytes, 2),
'%.2f' % ((bytes_consumed / total_bytes) * 100),
human_byte(bytes_consumed, 2)))
sys.stdout.flush()
e = encoder.MultipartEncoder(
fields={
'model_id': model_id,
'expfs': (filename, open(expfs, 'rb'), 'application/zip')
})
m = encoder.MultipartEncoderMonitor(e, upload_callback)
timeout = self.timeout
verbose = self.verbose
max_retries = self.max_retries
request = HTTPRequest(self.endpoint,
max_retries=max_retries,
verbose=verbose)
request.set_authorization(self.token_type, self.access_token)
model_url = '/model/expfs/upload'
result = request.post(model_url,
data=m,
timeout=timeout,
headers={'Content-Type': m.content_type})
sys.stdout.write('')
return models.Model(result)
def gofile_upload(files):
try:
session = requests.Session()
with open(files, 'rb') as f:
form = encoder.MultipartEncoder({
"file": (files, f, "application/octet-stream"),
})
headers = {"Prefer": "respond-async", "Content-Type": form.content_type}
r = session.post("https://srv-store1.gofile.io/uploadfile", headers=headers, data=form)
session.close()
resp = json.loads(r.content)
if r.status_code == 200:
print('GoFile Uploaded: ' + 'https://gofile.io/d/' + resp['data']['code'])
if gui_state:
gui.update_links('GoFile: ' + 'https://gofile.io/d/' + resp['data']['code'])
else:
print('Something else happened')
except Exception as e:
print('GoFile did not upload')
