def send_file(name, size):
try:
encoder = MultipartEncoderMonitor.from_fields(fields={
'file': (name, open(os.path.join(args.directory_path, name), 'rb'))
})
progress.last_len = 0
pbar = tqdm(total=encoder.len,
leave=True,
unit_scale=True,
unit='B',
miniters=1,
desc='sending {}'.format(name))
monitor = MultipartEncoderMonitor(
encoder, lambda monitor: progress(monitor.bytes_read, pbar))
r = requests.post(upload_url,
data=monitor,
headers={'Content-Type': monitor.content_type})
progress(size, pbar)
if 'Success' not in r.text:
print(r.text)
else:
print('done.\a') # \a = audio signal
except UnicodeDecodeError:
exit(
'Oops, unicode filenames are not yet supported, please delete the file "{}" and try again. :('
.format(name))
def upload_files(self, path, filename):
try:
f = open(filename, 'rb')
except FileNotFoundError:
raise BaseException('File not found')
destination = path + os.path.basename(filename)
monitor = MultipartEncoderMonitor.from_fields(
fields={'file': ('filename', f, 'application/octet-stream')}, )
upload_response = self.session.post(
self.uploadTarget,
data=monitor,
headers={'Content-Type': monitor.content_type},
verify=False)
if upload_response.status_code is not 200:
raise BaseException('Error')
hash = upload_response.content.decode("utf-8").split(';')[0]
filesize = upload_response.content.decode("utf-8").split(';')[1][:-2]
response = self.session.post("https://cloud.mail.ru/api/v2/file/add",
data={
"token": self.token,
"home": destination,
"conflict": 'rename',
"hash": hash,
"size": filesize,
})
return response.json()
def request_v2(self, method, url, params=None, json=None, data=None, streaming=False):
"""Make a request to rest API and return response."""
params = params or {}
json = json or {}
data = data or {}
url = '{}{}'.format(self.api_entry_point, url)
method = method.upper()
if method not in ['GET', 'POST']:
raise ValueError("method should be in ['GET', 'POST']")
if method == 'POST' and streaming:
# Create new data with encoder
encoder = MultipartEncoder(fields=data)
def callback(monitor):
if 'size' in data:
msg = '{0:.0f}% uploaded '.format(100 * monitor.bytes_read / int(data['size']))
else:
msg = '{} bytes uploaded '.format(monitor.bytes_read)
print(msg, flush=True, end='\r')
multi_data = MultipartEncoderMonitor(encoder, callback)
headers = self.session.headers.copy()
headers['Content-Type'] = multi_data.content_type
resp = self.session.request(method, url, params=params, json=json, data=multi_data, headers=headers)
else:
resp = self.session.request(method, url, params=params, json=json, data=data)
try:
return resp
except Exception:
print("Unexpected error")
sys.exit()
def upload_files(self, fileslist):
path = ''
progress = tqdm(unit='B')
for file in fileslist:
progress.desc = file['filename']
try:
f = open(file['filename'], 'rb')
except FileNotFoundError:
print("File not found: {}".format(file['filename']))
break
files = {'file': f}
if 'path' not in file: path = '/'
else: path = file['path']
destination = path + os.path.basename(file['filename'])
if os.path.getsize(file['filename']) > 1024 * 1024 * 1024 * 2:
raise PyMailCloudError.FileSizeError
monitor = MultipartEncoderMonitor.from_fields(
fields={'file': ('filename', f, 'application/octet-stream')},
callback=lambda monitor: self.upload_callback(monitor, progress))
upload_response = self.session.post(self.uploadTarget, data=monitor,
headers={'Content-Type': monitor.content_type})
if upload_response.status_code is not 200:
raise PyMailCloudError.NetworkError
hash, filesize = upload_response.content.decode("utf-8").split(';')[0], upload_response.content.decode("utf-8").split(';')[1][:-2]
response = self.session.post("https://cloud.mail.ru/api/v2/file/add", # "http://httpbin.org/post",
data={
"token": self.token,
"home": destination,
"conflict": 'rename',
"hash": hash,
"size": filesize,
})
return json.dumps(response.json(), sort_keys=True, indent=3, ensure_ascii=False)
def upload(filename, file=None):
if file is None:
file = open(filename, "rb")
filename = os.path.basename(filename)
print("Uploading %s..." % filename)
key = os.urandom(16)
iv = os.urandom(12)
cipher = AES.new(key, AES.MODE_GCM, iv, mac_len=16)
metadata = {"id": binascii.hexlify(iv).decode(), "filename": filename}
mimetype = mimetypes.guess_type(
filename, strict=False)[0] or 'application/octet-stream'
print("Uploading as mimetype", mimetype)
mpenc = MultipartEncoder(
fields={
'data': (filename,
LazyEncryptedFileWithTag(file, cipher, taglen=16),
mimetype)
})
mpmon = MultipartEncoderMonitor(mpenc,
callback=upload_progress_callback(mpenc))
req = requests.post('https://send.firefox.com/api/upload',
data=mpmon,
headers={
'X-File-Metadata': json.dumps(metadata),
'Content-Type': mpmon.content_type
})
print()
req.raise_for_status()
res = req.json()
url = res['url'] + '#' + base64.urlsafe_b64encode(key).decode().rstrip('=')
print("Your download link is", url)
return url
def test_from_fields(self):
monitor = MultipartEncoderMonitor.from_fields(
self.fields, self.boundary
)
assert isinstance(monitor, MultipartEncoderMonitor)
assert isinstance(monitor.encoder, MultipartEncoder)
assert monitor.encoder.boundary_value == self.boundary
def post(url, data = None, files = None):
if files:
d = dict(files)
if not data:
data = {}
for k, v in data.items():
d[k] = str(v)
d = MultipartEncoder(d)
d = MultipartEncoderMonitor(d, file_callback)
h = headers.copy()
h['Content-Type'] = d.content_type
else:
d = data
h = headers
r = requests.post(
host + url,
headers = h,
stream = True,
cookies = cookies,
data = d
)
if not r.ok:
log.error(u'网站连接失败，错误代码%s，错误信息见`error.log`。' % r.status_code)
with open('error.log', 'a') as f:
f.write(u'运行时间：' + str(datetime.datetime.now()) + '\n')
f.write(u'url：' + r.url + '\n')
f.write(r.text)
return r
def run(self):
"""
Run the worker thread
"""
upl_imgs = list()
my_list_chunks = [
self.uploadFiles[i * self.limit:(i + 1) * self.limit]
for i in range((len(self.uploadFiles) + self.limit - 1) //
self.limit)
]
for img_slice in my_list_chunks:
m = MultipartEncoderMonitor.from_fields(fields={
f'file_{i}':
('filename', open(fPath, 'rb'), guess_type(str(fPath))[1])
for i, fPath in enumerate(img_slice)
},
callback=self.my_callback)
images = requests.post('https://dtf.ru/andropov/upload',
data=m,
headers={
'Content-Type': m.content_type,
"x-this-is-csrf": "THIS IS SPARTA!"
}).json()
print(images)
upl_imgs.extend(images['result'])
# wx.CallAfter(pub.sendMessage, f"update_upload", count=self.uploadSize)
wx.CallAfter(pub.sendMessage, f"update_upload", count=self.uploadSize)
wx.CallAfter(pub.sendMessage,
f"upload_complete",
img_list=zip(
map(lambda x: x.name.split('.')[0], self.uploadFiles),
upl_imgs))
def upload_files(self, file, file_name, folder_name):
progress = tqdm(unit='B')
progress.desc = file_name
destination = '/' + folder_name + '/' + file_name
# if os.path.getsize(file['filename']) > 1024 * 1024 * 1024 * 2:
# raise PyMailCloudError.FileSizeError
monitor = MultipartEncoderMonitor.from_fields(
fields={'file': ('filename', file, 'application/octet-stream')},
callback=lambda monitor: self.upload_callback(monitor, progress))
upload_response = self.session.post(self.uploadTarget, data=monitor,
headers={'Content-Type': monitor.content_type},verify=False)
if upload_response.status_code is not 200:
raise PyMailCloudError.NetworkError
print(monitor)
hash, filesize = upload_response.content.decode("utf-8").split(';')[0], upload_response.content.decode("utf-8").split(';')[1][:-2]
response = self.session.post("https://cloud.mail.ru/api/v2/file/add", # "http://httpbin.org/post",
data={
"token": self.token,
"home": destination,
"conflict": 'rename',
"hash": hash,
"size": filesize,
})
return json.dumps(response.json(), sort_keys=True, indent=3, ensure_ascii=False)
def upload_file(self, name, path, fn=None, content_checksum=None):
_, checksum = util.gen_hash(path)
result = self._call('upload/check',
check_code=True,
data={'checksum': checksum})
data = result.json()
if data.get('result'):
# Already uploaded
return True
hdl = open(path, 'rb')
enc = MultipartEncoder({
'checksum':
checksum,
'content_checksum':
content_checksum,
'file': ('upload', hdl, 'application/octet-stream')
})
enc_len = enc.len
def cb(monitor):
progress.update(monitor.bytes_read / enc_len,
'Uploading %s...' % name)
monitor = MultipartEncoderMonitor(enc, cb)
self._call('upload/file',
data=monitor,
headers={'Content-Type': monitor.content_type},
check_code=True)
return True
def run(self):
while True:
try:
user, password, host, filedata = self.queue.get()
self.name = host
self.lengthofdata = len(filedata)
payload = {'name': user, 'pwd': password}
print('{}: Logging in'.format(self.name))
self.response = self.session.post(
"http://{}/cgi/login.cgi".format(host), headers=self.headers, data=payload, timeout=10)
if self.response.status_code == 200 and "../cgi/url_redirect.cgi?url_name=mainmenu" in self.response.text:
print('{}: Logged in successfully'.format(self.name))
opt = MultipartEncoderMonitor.from_fields(
fields=[('FileType', '3'), ('preserve_config', '1'),
('FS_Whatever', ('SMT_X10_185.bin', filedata, 'application/octet-stream'))],
callback=self.progressbar
) # If you change your file location don't forget to change file name as well
print('{}: Uploading file'.format(self.name))
self.response = self.session.post("http://{}/cgi/firmware_upload.cgi".format(
host), headers=self.headers, data=opt, timeout=360)
if self.response.status_code == 200 and "complete" in self.response.text:
print('{}: Upload successful, give us 1 minute to install and reboot'.format(
self.name))
except:
print("error")
traceback.print_exc()
self.queue.task_done()
return
def build_multipart_encoder(self, filename, fp, fields, progress_callback):
fields['file'] = (filename, fp, None)
data = MultipartEncoder(
fields = fields
)
data = MultipartEncoderMonitor(data, progress_callback)
headers = {'Content-Type': data.content_type}
return data, headers
def upload_dataset(self, dataset, dataset_name, schema_path=None):
""" Upload to the repository an entire dataset from a local path
:param dataset: the local path of the dataset
:param dataset_name: the name you want to assign to the dataset remotely
:return: None
"""
url = self.address + "/datasets/" + dataset_name + "/uploadSample"
header = self.__check_authentication()
fields = dict()
remove = False
if isinstance(dataset, GDataframe):
tmp_path = TempFileManager.get_new_dataset_tmp_folder()
dataset.to_dataset_files(local_path=tmp_path)
dataset = tmp_path
remove = True
# a path is provided
if not isinstance(dataset, str):
raise TypeError(
"Dataset can be a path or a GDataframe. {} was passed".format(
type(dataset)))
file_paths, schema_path_found = Loader.get_file_paths(dataset)
if schema_path is None:
schema_path = schema_path_found
fields['schema'] = (os.path.basename(schema_path),
open(schema_path,
"rb"), 'application/octet-stream')
for i, file in enumerate(file_paths):
fields["file" + str(i + 1)] = (os.path.basename(file),
open(file, "rb"),
'application/octet-stream')
encoder = MultipartEncoder(fields)
callback = create_callback(encoder, len(fields))
m_encoder = MultipartEncoderMonitor(encoder, callback)
header['Content-Type'] = m_encoder.content_type
self.logger.debug("Uploading dataset at {} with name {}".format(
dataset, dataset_name))
response = requests.post(url, data=m_encoder, headers=header)
# closing files
for fn in fields.keys():
_, f, _ = fields[fn]
f.close()
if response.status_code != 200:
raise ValueError("Code {}: {}".format(response.status_code,
response.content))
if remove:
TempFileManager.delete_tmp_dataset(dataset)
def dataset(name, file):
"""
Create a TensorCI dataset from a JSON file.
The dataset will be associated with the TensorCI project of the current working directory.
The dataset's name will default to the name of the project if not specified.
Ex: tensorci create dataset -f mydataset.json
"""
# Must already be logged in to perform this command.
auth_required()
# Find this git project's remote url from inside .git/config
git_repo = gitconfig.get_remote_url()
# If dataset name was specified, slugify it.
if name:
dataset_slug = to_slug(name)
else:
# Default dataset slug will just be the repo name.
dataset_slug = None
# Make sure file actually exists.
if not os.path.exists(file):
log('No file found at path {}'.format(file))
return
# Require dataset file to be JSON.
if not file.endswith('.json'):
log('Dataset must be a JSON file (i.e. dataset.json)')
return
# Build the payload.
payload = {
'git_url': git_repo,
'dataset_slug': dataset_slug,
'file': ('dataset.json', open(file, 'rb'), 'application/json')
}
# Create a multipart encoder.
encoder = MultipartEncoder(fields=payload)
# Create progress callback, specifying message to show when upload completes.
callback = create_callback(
encoder, completion_log='\nConverting dataset to database...')
# Create a monitor for the encoder so we can track upload progress.
monitor = MultipartEncoderMonitor(encoder, callback)
headers = {'Content-Type': monitor.content_type}
try:
# Upload the dataset.
api.post('/dataset', headers=headers, mp_upload_monitor=monitor)
except KeyboardInterrupt:
return
log('Successfully created dataset.')
def _upload(service, filename, file, password=None):
filename = os.path.basename(filename)
secret = os.urandom(16)
iv = os.urandom(12)
encryptKey = deriveFileKey(secret)
authKey = deriveAuthKey(secret)
metaKey = deriveMetaKey(secret)
fileCipher = AES.new(encryptKey, AES.MODE_GCM, iv, mac_len=16)
metaCipher = AES.new(metaKey, AES.MODE_GCM, b'\x00' * 12, mac_len=16)
mimetype = mimetypes.guess_type(
filename, strict=False)[0] or 'application/octet-stream'
print("Uploading as mimetype", mimetype)
metadata = {"iv": b64encode(iv), "name": filename, "type": mimetype}
metadata = metaCipher.encrypt(json.dumps(metadata).encode('utf8'))
metadata += metaCipher.digest()
mpenc = MultipartEncoder(
fields={
'data': (filename,
LazyEncryptedFileWithTag(file, fileCipher, taglen=16),
'application/octet-stream')
})
mpmon = MultipartEncoderMonitor(mpenc,
callback=upload_progress_callback(mpenc))
resp = requests.post(service + 'api/upload',
data=mpmon,
headers={
'X-File-Metadata': b64encode(metadata),
'Authorization': 'send-v1 ' + b64encode(authKey),
'Content-Type': mpmon.content_type
})
print()
resp.raise_for_status()
res = resp.json()
url = res['url'] + '#' + b64encode(secret)
ownerToken = res['owner']
if password is not None:
service, fid, secret = parse_url(url)
newAuthKey = deriveAuthKey(secret, password, url)
resp = requests.post(service + 'api/password/' + fid,
headers={'Content-Type': 'application/json'},
json={
'auth': b64encode(newAuthKey),
'owner_token': ownerToken
})
resp.raise_for_status()
print("Your download link is", url)
print("Owner token is", ownerToken)
return url, res['owner']
def request(self,
method,
url,
params=None,
json=None,
data=None,
affinity=None,
streaming=False):
"""Make a request to rest API and return response as json."""
params = params or {}
json = json or {}
data = data or {}
if self.api_entry_point.endswith('/') and url.startswith('/'):
url = '{}{}'.format(self.api_entry_point, url[1:])
else:
url = '{}{}'.format(self.api_entry_point, url)
method = method.upper()
if method not in ['GET', 'POST']:
raise ValueError("method should be in ['GET', 'POST']")
headers = self.session.headers.copy()
if affinity is not None:
headers['HC-WorkerAffinity'] = affinity
if method == 'POST' and streaming:
# Create new data with encoder
encoder = MultipartEncoder(fields=data)
multi_data = MultipartEncoderMonitor(encoder, None)
headers['Content-Type'] = multi_data.content_type
resp = self.session.request(method,
url,
params=params,
json=json,
data=multi_data,
headers=headers)
else:
resp = self.session.request(method,
url,
params=params,
json=json,
data=data,
headers=headers)
if not resp.ok:
raise requests.exceptions.HTTPError(
'Error while trying to do a {} at {}. Reason is {}\nResponse content: {}'
.format(method, url, resp.reason, resp.text),
response=resp.status_code,
request=url)
try:
return resp.json()
except Exception:
return resp.content
def _request_params(self):
params = super(FileRequest, self)._request_params
data = self.files or {}
data["json"] = ("json", json.dumps(self.data), "application/json")
callback = self.progress_callback or (lambda x: x)
m = MultipartEncoder(data)
params["json"] = None
params["data"] = MultipartEncoderMonitor(m, callback)
params["headers"] = {'Content-Type': params["data"].content_type}
return params
def http_upload(remote_path, filename, filepath, MIME_type):
try:
e = MultipartEncoder(
fields={'file': (filename, open(filepath, 'rb'), MIME_type)})
m = MultipartEncoderMonitor(e, my_callback)
headers = {"Content-Type": m.content_type}
r = requests.post(remote_path, data=m, headers=headers)
return 1
except Exception as err:
print('文件上传异常，异常原因是：{}'.format(err))
return 0
def request(self,
method,
url,
params=None,
json=None,
data=None,
streaming=False):
"""Make a request to rest API and return response as json."""
params = params or {}
json = json or {}
data = data or {}
url = '{}{}'.format(self.api_entry_point, url)
method = method.upper()
if method not in ['GET', 'POST']:
raise ValueError("method should be in ['GET', 'POST']")
if method == 'POST' and streaming:
# Create new data with encoder
encoder = MultipartEncoder(fields=data)
def callback(monitor):
msg = '{} bytes uploaded '.format(monitor.bytes_read)
print(msg, flush=True, end='\r')
multi_data = MultipartEncoderMonitor(encoder, callback)
headers = self.session.headers.copy()
headers['Content-Type'] = multi_data.content_type
resp = self.session.request(method,
url,
params=params,
json=json,
data=multi_data,
headers=headers)
else:
resp = self.session.request(method,
url,
params=params,
json=json,
data=data)
if not resp.ok:
raise requests.exceptions.HTTPError(
'Error while trying to do a {} at {}. Reason is {}\nResponse content: {}'
.format(method, url, resp.reason, resp.text),
response=resp.status_code,
request=url)
try:
return resp.json()
except Exception:
return resp.content
def upload_file(self,
name,
path,
fn=None,
content_checksum=None,
vp_checksum=None):
_, checksum = util.gen_hash(path)
result = self._call('upload/check',
check_code=True,
data={'checksum': checksum})
data = result.json()
if data.get('result'):
# Already uploaded
return True
if vp_checksum:
assert vp_checksum[0] == 'sha256'
vp_checksum = vp_checksum[1]
hdl = open(path, 'rb')
enc = MultipartEncoder({
'checksum':
checksum,
'content_checksum':
content_checksum,
'vp_checksum':
vp_checksum,
'file': ('upload', hdl, 'application/octet-stream')
})
enc_len = enc.len
def cb(monitor):
progress.update(monitor.bytes_read / enc_len,
'Uploading %s...' % name)
monitor = MultipartEncoderMonitor(enc, cb)
# TODO: Implement incremental uploads to get rid of this insanity
self._call(
'upload/file',
data=monitor,
timeout=3 * 60 * 60,
headers={ # timeout = 3 hours
'Content-Type': monitor.content_type
},
check_code=True)
return True
def sendTextMms(subject, content, peoples): # 发送文本彩信
'''
#发送文本彩信
:param subject: 主题
:param content: 内容
:param peoples: 接收人
'''
fields = [
("PhoneNumber", ",".join(peoples)), # 发送对象
("MMSFrom", ""), # 发送人
("MMSSubject", subject), # 发送主题
("MMSText", content), # 文字内容
("MMSBCC", "No"),
("MMSDeliveryReport", "No"),
("MMSReadReport", "No"),
("MMSPriority", "Normal"),
("MMSMessageClass", "Personal"),
("MMSForwardLock", "No"),
("DRMRestrict", "No"),
("DRMRestrictTextXML", ""),
# ( "DRMPermissionPlay",""),
("DRMConstraintCount", ""),
("DRMConstraintStart", ""),
("DRMConstraintEnd", ""),
("DRMConstraintInterval", ""),
("MMSHEADERS", ""),
("Submit", "Submit")
]
encoder = MultipartEncoder(fields=fields)
# print(fields + _fields)
monitor = MultipartEncoderMonitor(encoder)
req = requests.post(
"http://10.105.160.68:8800/Send%20MMS%20Message.htm",
data=monitor,
timeout=120,
headers={
"Accept":
"image/gif, image/jpeg, image/pjpeg, application/x-ms-application, application/xaml+xml, application/x-ms-xbap, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*",
"Cache-Control": "no-cache",
"Connection": "Keep-Alive",
"Referer": "http://10.105.160.68:8800/Send%20MMS%20Message.htm",
"Cookie": "ASP.NET_SessionId=igwzr5gsgeyssz11slb0pyuq",
"Content-Type": monitor.content_type,
"User-Agent": "Auto SMS BY: 892768447 Version: 1.0"
})
return req.text.find("Message Submitted") > -1
def __post_file(self, filename, url, username, job_name, apikey):
logging.debug("sending batch job to server...")
def createCallback(encoder):
# Stuff for progress bar setup
widgets = [
'Transfering Model: ',
Bar(),
Percentage(), ' ',
ETA(), ' ',
FileTransferSpeed()
]
pbar = ProgressBar(max_value=encoder.len, widgets=widgets).start()
def callback(monitor):
current = monitor.bytes_read
pbar.update(current)
return callback
# Create the Multi-Part encoder
data = open(filename, "rb")
encoder = MultipartEncoder(fields={
'job_name': job_name,
'job': (filename, data, 'application/x-tar')
})
headers = {
'Content-Type': encoder.content_type,
}
callback = createCallback(encoder)
monitor = MultipartEncoderMonitor(encoder, callback)
# Actually do the request, and get the response
try:
r = requests.post(url=url,
data=monitor,
headers=headers,
auth=(username, apikey))
if r.status_code != requests.codes.ok:
r.raise_for_status()
except requests.exceptions.HTTPError as err:
text = r.text
sys.stderr.write("\nServer error: {}".format(text))
return
except Exception as e:
sys.stderr.write("\nError: {}".format(e))
return
response_text = r.text
def stream_multipart_post(url, fields, stage_handler=None, stages=50, **kwargs):
"""
Post the fields in fields to the url in url using a streamed
multipart/form-data request. Optionally pass in a callback function which
is called when the uploaded size passes each of total_size/stages.
"""
encoder = MultipartEncoder(fields=fields)
stager = ProgressStager(encoder.len,
total_stages=stages,
stage_handler=stage_handler)
def stager_caller(monitor):
stager.set_cur_size(monitor.bytes_read)
monitor = MultipartEncoderMonitor(encoder, stager_caller)
headers = {'Content-Type':monitor.content_type}
r = requests.post(url, data=monitor, headers=headers, **kwargs)
return r
def multipart_post(self, url, data, files, create_encoder_callback=None):
try:
encoder = MultipartEncoder(fields={**data, **files})
callback = None
if create_encoder_callback is not None:
callback = create_encoder_callback(encoder)
monitor = MultipartEncoderMonitor(encoder, callback)
result = self.send_multipart(url, monitor)
return result
except JSONDecodeError as ex:
raise ResponseIsNotJson(ex)
except Exception as ex:
raise HSApiError(ex)
def upload_files(self, fileslist):
path = ''
progress = tqdm(unit='B')
for file in fileslist:
progress.desc = file['filename']
try:
f = open(file['filename'], 'rb')
except FileNotFoundError:
print("File not found: {}".format(file['filename']))
break
files = {'file': f}
if 'path' not in file: path = '/'
else: path = file['path']
destination = path + os.path.basename(file['filename'])
if os.path.getsize(file['filename']) > 1024 * 1024 * 1024 * 2:
raise PyMailCloudError.FileSizeError
monitor = MultipartEncoderMonitor.from_fields(
fields={'file': ('filename', f, 'application/octet-stream')},
callback=lambda monitor: self.upload_callback(
monitor, progress))
upload_response = self.session.post(
self.uploadTarget,
data=monitor,
headers={'Content-Type': monitor.content_type},
verify=False)
if upload_response.status_code is not 200:
raise PyMailCloudError.NetworkError
hash, filesize = upload_response.content.decode("utf-8").split(
';')[0], upload_response.content.decode("utf-8").split(
';')[1][:-2]
response = self.session.post(
"https://cloud.mail.ru/api/v2/file/add", # "http://httpbin.org/post",
data={
"token": self.token,
"home": destination,
"conflict": 'rename',
"hash": hash,
"size": filesize,
})
return json.dumps(response.json(),
sort_keys=True,
indent=3,
ensure_ascii=False)
def do_update(self):
file_md5 = hashlib.md5(self.file.read()).hexdigest()
self.file.seek(0)
url = 'http://%s/fw?md5=%s&size=%s' % (self.ip, file_md5,
self.file_size)
encoder = MultipartEncoder(
{'file': ('firmware.bin', self.file, 'application/octet-stream')})
monitor = MultipartEncoderMonitor(encoder,
create_callback(self.file_size))
r = requests.post(url,
data=monitor,
headers={'Content-Type': encoder.content_type})
if r.status_code == requests.codes.ok:
print "OK!"
else:
print r.status_code
def post_file_to_api(self, path):
"""
Posts file to API using MultipartEncoder
so progress can be monitored by using a callback
:param path path to file
:returns status JSON
"""
name = os.path.basename(path)
encoder = MultipartEncoder(fields={
'file': (name, open(path, 'rb'), 'application/octet-stream')
})
monitor = MultipartEncoderMonitor(encoder, progress)
r = requests.post(self.post_url,
data=monitor,
headers={'Content-Type': monitor.content_type})
return r.text
class TestMultipartEncoderMonitor(unittest.TestCase):
def setUp(self):
self.fields = {'a': 'b'}
self.boundary = 'thisisaboundary'
self.encoder = MultipartEncoder(self.fields, self.boundary)
self.monitor = MultipartEncoderMonitor(self.encoder)
def test_content_type(self):
assert self.monitor.content_type == self.encoder.content_type
def test_length(self):
assert len(self.encoder) == len(self.monitor)
def test_read(self):
new_encoder = MultipartEncoder(self.fields, self.boundary)
assert new_encoder.read() == self.monitor.read()
def test_callback_called_when_reading_everything(self):
callback = Callback(self.monitor)
self.monitor.callback = callback
self.monitor.read()
assert callback.called == 1
def test_callback(self):
callback = Callback(self.monitor)
self.monitor.callback = callback
chunk_size = int(math.ceil(len(self.encoder) / 4.0))
while self.monitor.read(chunk_size):
pass
assert callback.called == 5
def test_bytes_read(self):
bytes_to_read = len(self.encoder)
self.monitor.read()
assert self.monitor.bytes_read == bytes_to_read
def test_default_callable_is_the_identity(self):
assert self.monitor.callback == IDENTITY
assert IDENTITY(1) == 1
def test_from_fields(self):
monitor = MultipartEncoderMonitor.from_fields(
self.fields, self.boundary
)
assert isinstance(monitor, MultipartEncoderMonitor)
assert isinstance(monitor.encoder, MultipartEncoder)
assert monitor.encoder.boundary_value == self.boundary
def upload_file(self, username, filepath, cb_percentage, cb_success,
cb_failure):
self.file_size = os.path.getsize(filepath)
self.bytes_read = 0
self.diff_sum = 0
filename = filepath.split('/')[-1]
mime_type = mimetypes.guess_type(filepath)
m = MultipartEncoderMonitor.from_fields(
fields={
'username': username,
'filename': filename,
'file': (filename, open(filepath, 'rb'), mime_type[0])
},
callback=lambda monitor: self.cb_file_upload(
monitor, cb_percentage))
resp = post(self.server_addr + 'upload/',
data=m,
headers={'Content-Type': m.content_type})
if resp.status_code == 200:
cb_success()
else:
cb_failure()
def process_creating_new_build(self, projectname, data, api_endpoint, username=None, chroots=None,
progress_callback=None, multipart=False):
if not username:
username = self.username
url = "{0}/coprs/{1}/{2}/{3}/".format(
self.api_url, username, projectname, api_endpoint
)
for chroot in chroots or []:
data[chroot] = "y"
if not multipart:
data = self._fetch(url, data, method="post")
else:
m = MultipartEncoder(data)
callback = progress_callback or (lambda x: x)
monit = MultipartEncoderMonitor(m, callback)
data = self._fetch(url, monit, method="post",
headers={'Content-Type': monit.content_type})
response = CoprResponse(
client=self,
method="cancel_build",
data=data,
request_kwargs={
"projectname": projectname,
"username": username
},
parsers=[
CommonMsgErrorOutParser,
NewBuildListParser,
]
)
response.handle = BaseHandle(
self, response=response,
projectname=projectname, username=username)
return response
class TestMultipartEncoderMonitor(unittest.TestCase):
def setUp(self):
self.fields = {'a': 'b'}
self.boundary = 'thisisaboundary'
self.encoder = MultipartEncoder(self.fields, self.boundary)
self.monitor = MultipartEncoderMonitor(self.encoder)
def test_content_type(self):
assert self.monitor.content_type == self.encoder.content_type
def test_length(self):
assert len(self.encoder) == len(self.monitor)
def test_read(self):
new_encoder = MultipartEncoder(self.fields, self.boundary)
assert new_encoder.read() == self.monitor.read()
def test_callback_called_when_reading_everything(self):
callback = Callback(self.monitor)
self.monitor.callback = callback
self.monitor.read()
assert callback.called == 1
def test_callback(self):
callback = Callback(self.monitor)
self.monitor.callback = callback
chunk_size = int(math.ceil(len(self.encoder) / 4.0))
while self.monitor.read(chunk_size):
pass
assert callback.called == 5
def test_bytes_read(self):
bytes_to_read = len(self.encoder)
self.monitor.read()
assert self.monitor.bytes_read == bytes_to_read
def test_default_callable_is_the_identity(self):
assert self.monitor.callback == IDENTITY
assert IDENTITY(1) == 1
def test_from_fields(self):
monitor = MultipartEncoderMonitor.from_fields(self.fields,
self.boundary)
assert isinstance(monitor, MultipartEncoderMonitor)
assert isinstance(monitor.encoder, MultipartEncoder)
assert monitor.encoder.boundary_value == self.boundary
def send_file(name, size):
try:
encoder = MultipartEncoderMonitor.from_fields(
fields={"file": (name, open(os.path.join(args.directory_path, name), "rb"))}
)
progress.last_len = 0
pbar = tqdm(
total=encoder.len, leave=True, unit_scale=True, unit="B", miniters=1, desc="sending {}".format(name)
)
monitor = MultipartEncoderMonitor(encoder, lambda monitor: progress(monitor.bytes_read, pbar))
r = requests.post(upload_url, data=monitor, headers={"Content-Type": monitor.content_type})
progress(size, pbar)
if "Success" not in r.text:
print(r.text)
else:
print("done.\a")
except UnicodeDecodeError:
print('Oops, there was a problem with the file "{}!\n Unicode filenames are not supported.'.format(name))
return
except requests.exceptions.ConnectionError:
exit("Oops, no response from your Flashair card at {}".format(upload_url))
def upload(local_source_slide, target_folder, target_pma_core_sessionID, callback=None):
"""
Uploads a slide to a PMA.core server. Requires a PMA.start installation
:param str local_source_slide: The local PMA.start relative file to upload
:param str target_folder: The root directory and path to upload to the PMA.core server
:param str target_pma_core_sessionID: A valid session id for a PMA.core server
:param function|boolean callback: If True a default progress will be printed.
If a function is passed it will be called for progress on each file upload.
The function has the following signature:
`callback(bytes_read, bytes_length, filename)`
"""
if not _pma_is_lite():
raise Exception("No PMA.start found on localhost. Are you sure it is running?")
if not target_folder:
raise ValueError("target_folder cannot be empty")
if (target_folder.startswith("/")):
target_folder = target_folder[1:]
files = get_files_for_slide(local_source_slide, _pma_pmacoreliteSessionID)
sessionID = _pma_session_id(target_pma_core_sessionID)
url = _pma_url(sessionID) + "transfer/Upload?sessionID=" + pma._pma_q(sessionID)
mainDirectory = ''
for i, f in enumerate(files):
md = os.path.dirname(f)
if i == 0 or len(md) < len(mainDirectory):
mainDirectory = md
uploadFiles = []
for i, filepath in enumerate(files):
s = os.path.getsize(filepath)
if s > 0:
uploadFiles.append({
"Path": filepath.replace(mainDirectory, '').strip("\\").strip('/'),
"Length": s,
"IsMain": i == len(files) - 1,
"FullPath": filepath
})
data = {"Path": target_folder, "Files": uploadFiles}
uploadHeaderResponse = requests.post(url, json=data)
if not uploadHeaderResponse.status_code == 200:
raise Exception(uploadHeaderResponse.json()["Message"])
uploadHeader = uploadHeaderResponse.json()
pmaCoreUploadUrl = _pma_url(sessionID) + "transfer/Upload/" + pma._pma_q(
uploadHeader["Id"]) + "?sessionID=" + pma._pma_q(sessionID) + "&path={0}"
isAmazonUpload = True
if not uploadHeader['Urls']:
isAmazonUpload = False
uploadHeader['Urls'] = [pmaCoreUploadUrl.format(f["Path"]) for f in uploadFiles]
for i, f in enumerate(uploadFiles):
uploadUrl = uploadHeader['Urls'][i]
e = MultipartEncoder(
fields={"file": (os.path.basename(f["Path"]), open(f["FullPath"], 'rb'), 'application/octet-stream')})
_callback = None
if callback is True:
print("Uploading file: {0}".format(e.fields["file"][0]))
_callback = lambda x: _pma_upload_callback(monitor, e.fields["file"][0])
elif callable(callback):
_callback = lambda x: callback(x.bytes_read, x.len, e.fields["file"][0])
monitor = MultipartEncoderMonitor(e, _callback)
monitor.previous = 0
r = None
if not isAmazonUpload:
r = requests.post(uploadUrl, data=monitor, headers={'Content-Type': monitor.content_type})
else:
r = requests.put(uploadUrl, data=monitor, headers={'Content-Type': monitor.content_type})
if not r.status_code == 200:
raise Exception("Error uploading file {0}: {1}".format(f["Path"], r.json()["Message"]))
def setUp(self):
self.fields = {"a": "b"}
self.boundary = "thisisaboundary"
self.encoder = MultipartEncoder(self.fields, self.boundary)
self.monitor = MultipartEncoderMonitor(self.encoder)
def sendMms(subject, dataDir, peoples, whichs, text=""): # 发送彩信
'''
#发送彩信
:param subject: 主题
:param dataDir: 图片目录
:param peoples: 接收对象
:param whichs: 哪些需要发送
:param text: 附加内容
'''
fields = [
("PhoneNumber", ",".join(peoples)), # 发送对象
("MMSFrom", ""), # 发送人
("MMSSubject", subject), # 发送主题
("MMSText", text), # 文字内容
("MMSBCC", "No"),
("MMSDeliveryReport", "No"),
("MMSReadReport", "No"),
("MMSPriority", "Normal"),
("MMSMessageClass", "Personal"),
("MMSForwardLock", "No"),
("DRMRestrict", "No"),
("DRMRestrictTextXML", ""),
# ( "DRMPermissionPlay",""),
("DRMConstraintCount", ""),
("DRMConstraintStart", ""),
("DRMConstraintEnd", ""),
("DRMConstraintInterval", ""),
("MMSHEADERS", ""),
("Submit", "Submit")
]
_fields = []
if len(whichs) == 0: # 全部
whichs = [p[:-4] for p in os.listdir(dataDir)]
for which in whichs:
try:
int(which)
except:
continue
path = os.path.join(dataDir, str(which) + ".png")
_fields.append((
"MMSFile",
(
quote(os.path.basename(path)), # 获取文件名并对文件名编码
open(path, "rb"), # 二进制流
"image/x-png")))
if not _fields:
return -1
encoder = MultipartEncoder(fields=fields + _fields)
# print(fields + _fields)
monitor = MultipartEncoderMonitor(encoder)
req = requests.post(
"http://10.105.160.68:8800/Send%20MMS%20Message.htm",
data=monitor,
timeout=120,
headers={
"Accept":
"image/gif, image/jpeg, image/pjpeg, application/x-ms-application, application/xaml+xml, application/x-ms-xbap, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*",
"Cache-Control": "no-cache",
"Connection": "Keep-Alive",
"Referer": "http://10.105.160.68:8800/Send%20MMS%20Message.htm",
"Cookie": "ASP.NET_SessionId=igwzr5gsgeyssz11slb0pyuq",
"Content-Type": monitor.content_type,
"User-Agent": "Auto SMS BY: 892768447 Version: 1.0"
})
return req.text.find("Message Submitted") > -1
def setUp(self):
self.fields = {'a': 'b'}
self.boundary = 'thisisaboundary'
self.encoder = MultipartEncoder(self.fields, self.boundary)
self.monitor = MultipartEncoderMonitor(self.encoder)
