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)