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')