def themed_send_static_file(self, filename): # do we have an active theme? theme = None if hasattr(flask.g, 'theme'): theme = flask.g.theme if theme is not None: try: return send_from_directory(os.path.join(theme.static_path, blueprint_name), filename) except NotFound: pass if not self.has_static_folder: raise RuntimeError('No static folder for this object') return send_from_directory(self.static_folder, filename)
def download(): """GET /download/ConPaaS.tar.gz Returns ConPaaS tarball. """ return helpers.send_from_directory(common.config_parser.get('conpaas', 'CONF_DIR'), "ConPaaS.tar.gz")
def download(): """GET /download/ConPaaS.tar.gz Returns ConPaaS tarball. """ return helpers.send_from_directory(os.path.dirname(__file__), "ConPaaS.tar.gz")
def showCacheFile(self, filename = ''): cache_dir = Env.get('cache_dir') filename = os.path.basename(filename) from flask.helpers import send_from_directory return send_from_directory(cache_dir, filename)
def static_file(path=None): if not path: path = 'index.html' try: return send_from_directory('webroot', path) except NotFound: return static_file()
def worksheed_data_folder(worksheet, filename): dir = os.path.abspath(worksheet.data_directory()) if not os.path.exists(dir): return make_response(_('No data file'), 404) else: from flask.helpers import send_from_directory return send_from_directory(worksheet.data_directory(), filename)
def read(p="."): if not os.path.exists(p): return make_response(jsonify(description="The path does not exists."), 404) if fs.is_dir(p) or "*" in p: return jsonify(content=fs.ls(p)) else: return send_from_directory(fs.split(p)[0], fs.split(p)[1])
def send_media_file(self, filename): """ Function used to send media files from the media folder to the browser. """ cache_timeout = self.get_send_file_max_age(filename) return send_from_directory(self.config['MEDIA_FOLDER'], filename, cache_timeout=cache_timeout)
def send_theme_file(self, filename): """ Function used to send static theme files from the theme folder to the browser. """ cache_timeout = self.get_send_file_max_age(filename) return send_from_directory(self.config['THEME_STATIC_FOLDER'], filename, cache_timeout=cache_timeout)
def base_static(filename): return send_from_directory( os.path.dirname( os.path.abspath(__file__) ) + '/../bower_components/', filename )
def send_root_file(self, filename): """ Function used to send static files from the root of the domain. """ cache_timeout = self.get_send_file_max_age(filename) return send_from_directory(self.config['ROOT_FOLDER'], filename, cache_timeout=cache_timeout)
def worksheet_data(worksheet, filename): dir = os.path.abspath(worksheet.data_directory()) if not os.path.exists(dir): return current_app.message(_('No data files')) else: from flask.helpers import send_from_directory return send_from_directory(worksheet.data_directory(), filename)
def static_noise_proxy(path): global curNoisePreviewDir if curNoisePreviewDir != "" and os.path.exists(curNoisePreviewDir): print "img", os.path.join(curNoisePreviewDir, path) return send_from_directory(curNoisePreviewDir, path) abort(500)
def get(self, filename): root = self.root if filename.startswith("vendor/") and self.hacky_vendor_root: root = self.hacky_vendor_root # We do this in debug to work around http://stackoverflow.com/q/17460463/871202 # By reading the file into memory ourselves, we seem to avoid hitting that # VirtualBox issue in dev. In prod, it's unchanged and we just send_from_directory if app.debug: full_name = root + "/" + filename if filename: mimetype = mimetypes.guess_type(filename)[0] else: mimetype = 'application/octet-stream' return Response( open(full_name), mimetype=mimetype, headers={ "Content-Disposition": "filename=" + filename } ) else: return send_from_directory( root, filename, cache_timeout=self.cache_timeout)
def public_worksheet_cells(id, filename): worksheet_filename = "pub" + "/" + id try: worksheet = g.notebook.get_worksheet_with_filename(worksheet_filename) except KeyError: return current_app.message("You do not have permission to access this worksheet") #XXX: i18n from flask.helpers import send_from_directory return send_from_directory(worksheet.cells_directory(), filename)
def page(path): #as werkzeug uses unordered dictionary for url mapping, let's hack for static files try: return send_from_directory(os.path.join(app.root_path,"static"), path, as_attachment=True) except NotFound: pass page = pages.get_or_404(path) template = page.content.get('template', 'default.html') return render_template(template, **page.content)
def send_static_file(self, filename): """Function used internally to send static files from the static folder to the browser. """ cache_timeout = current_app.get_send_file_max_age(filename) return send_from_directory( STATIC_FOLDER, filename, cache_timeout=cache_timeout )
def send_storage_file(self, filename): if not self.has_static_folder: raise RuntimeError('No static folder for this object') from flask.helpers import send_from_directory # Ensure get_send_file_max_age is called in all cases. # Here, we ensure get_send_file_max_age is called for Blueprints. cache_timeout = self.get_send_file_max_age(filename) return send_from_directory('storage', filename, cache_timeout=cache_timeout)
def send_static_file(self, filename): """Return static file.""" try: return super(self.__class__, self).send_static_file(filename) except: cache_timeout = self.get_send_file_max_age(filename) return send_from_directory( os.path.join(current_app.instance_path, "docs", "static"), filename, cache_timeout=cache_timeout)
def get_font(filename): """ Get a file from the fonts directory. :param filename: The filename. :type filename: str :return: The font file. :rtype: flask.Response """ return send_from_directory(join(dirname(__file__), "fonts"), filename)
def static(filename, version = None): from flask.helpers import send_from_directory r = send_from_directory(app.config['STATIC_DIR'], filename) if version and version != app.config['STATIC_VERSION']: return redirect(static_url(url_for('static', filename = filename, version = app.config['STATIC_VERSION']))) r.headers['Access-Control-Allow-Origin'] = '*' return r
def send_static_file(self, filename): """Function used internally to send static files from the static folder to the browser. .. versionadded:: 0.5 """ if not self.has_static_folder: raise RuntimeError('No static folder for this object') # Ensure get_send_file_max_age is called in all cases. # Here, we ensure get_send_file_max_age is called for Blueprints. cache_timeout = self.get_send_file_max_age(filename) return send_from_directory(self.static_folder, filename, cache_timeout=1)
def send_static_file(self, filename): cache_timeout = self.get_send_file_max_age(filename) l = self.static_paths[:] if self.has_static_folder: l.append(self.static_folder) for path in l: try: return send_from_directory(path, filename, cache_timeout=cache_timeout) except NotFound: continue raise NotFound()
def render_claim_pdf(): ''' Маршрутизация страницы печати заявления ''' if auth_request(): import pythoncom pythoncom.CoInitializeEx(0) name = renderDocxTemplate(session.get('userLogin')) waybase = os.getcwd() + '\\static' temp = send_from_directory(waybase, name) return temp else: return redirect(url_for('login'))
def getUserScript(self, filename = ''): params = { 'includes': fireEvent('userscript.get_includes', merge = True), 'excludes': fireEvent('userscript.get_excludes', merge = True), 'version': self.getVersion(), 'api': '%suserscript/' % url_for('api.index').lstrip('/'), 'host': request.host_url, } script = self.renderTemplate(__file__, 'template.js', **params) self.createFile(os.path.join(Env.get('cache_dir'), 'couchpotato.user.js'), script) from flask.helpers import send_from_directory return send_from_directory(Env.get('cache_dir'), 'couchpotato.user.js')
def send_static_file(self, filename): # Ensure get_send_file_max_age is called in all cases. # Here, we ensure get_send_file_max_age is called for Blueprints. cache_timeout = self.get_send_file_max_age(filename) # Serve out of 'static' and 'var/static'. for dir_name in 'static', 'var/static': dir_path = os.path.join(self.root_path, dir_name) file_path = os.path.join(dir_path, filename) if os.path.exists(file_path): break return send_from_directory(dir_path, filename, cache_timeout=cache_timeout)
def download_file(): try: # Absolute Path directory = '/mnt/shared/Past/' # File Name StudentId_MemberName.zip filename = session[SessionResources().const.MEMBER_ID] + '_'\ + session[SessionResources().const.MEMBER_NAME] + '.zip' Log.info(session[SessionResources().const.MEMBER_ID] \ + ' download '\ + directory\ + '/' + filename) return send_from_directory(directory = directory, filename = filename) except Exception: pass
def download(username,filename): # os.path.realpath(__file__)打印出来的是当前路径/soft/flask/day1/wenwen.py # os.path.dirname(os.path.realpath(__file__))打印出来的是/soft/flask/day1/ username=username filename=filename user_=db.query_zipfile(username,filename) # current_dir = os.path.dirname(os.path.realpath(__file__)) path='E:/python_code/Baiyinyun'+user_.filepath[1:] path=path.split('/')[:-1] path='/'.join(path) # print(current_dir) # return jsonify({'code':1}) # print(username,filename) return send_from_directory(path, user_.filename,as_attachment=True)
def download_file(): try: # Absolute Path directory = '/mnt/shared/Past/' # File Name StudentId_MemberName.zip filename = session[SessionResources().const.MEMBER_ID] + '_'\ + session[SessionResources().const.MEMBER_NAME] + '.zip' Log.info(session[SessionResources().const.MEMBER_ID] \ + ' download '\ + directory\ + '/' + filename) return send_from_directory(directory=directory, filename=filename) except Exception: pass
def getUserScript(self, random='', filename=''): params = { 'includes': fireEvent('userscript.get_includes', merge=True), 'excludes': fireEvent('userscript.get_excludes', merge=True), 'version': self.getVersion(), 'api': '%suserscript/' % url_for('api.index').lstrip('/'), 'host': request.host_url, } script = self.renderTemplate(__file__, 'template.js', **params) self.createFile( os.path.join(Env.get('cache_dir'), 'couchpotato.user.js'), script) from flask.helpers import send_from_directory return send_from_directory(Env.get('cache_dir'), 'couchpotato.user.js')
def send_static_file(self, filename): if not self.has_static_folder: raise RuntimeError('No static folder defined') cache_timeout = self.get_send_file_max_age(filename) folders = [self.static_folder] + self.static_folders for folder in folders: try: return send_from_directory(folder, filename, cache_timeout=cache_timeout) except NotFound: pass raise NotFound()
def send_file_from_directory(filename, directory, app=None): """ Helper to add static rules, like in `abilian.app`.app Example use:: app.add_url_rule( app.static_url_path + '/abilian/<path:filename>', endpoint='abilian_static', view_func=partial(send_file_from_directory, directory='/path/to/static/files/dir')) """ if app is None: app = current_app cache_timeout = app.get_send_file_max_age(filename) return send_from_directory(directory, filename, cache_timeout=cache_timeout)
def send_file_from_directory(filename, directory, app=None): """Helper to add static rules, like in `abilian.app`.app. Example use:: app.add_url_rule( app.static_url_path + '/abilian/<path:filename>', endpoint='abilian_static', view_func=partial(send_file_from_directory, directory='/path/to/static/files/dir')) """ if app is None: app = current_app cache_timeout = app.get_send_file_max_age(filename) return send_from_directory(directory, filename, cache_timeout=cache_timeout)
def files(self,path="."): ''' show the files in the given path Args: path(str): the path to render ''' template="scan2wiki/datatable.html" title="Scans" activeItem=title fullpath=f"{self.scandir}/{path}" if os.path.isdir(fullpath): # https://stackoverflow.com/questions/57073384/how-to-add-flask-autoindex-in-an-html-page # return files_index.render_autoindex(path,template="scans.html") dictList,lodKeys,tableHeaders=self.getScanFiles() return self.render_template(templateName=template,title=title,activeItem=activeItem,dictList=dictList,lodKeys=lodKeys,tableHeaders=tableHeaders) else: return send_from_directory(self.scandir,path)
def ticket_attendee_pdf(attendee_id): ticket_holder = TicketHolder.query.get(attendee_id) if ticket_holder is None: raise NotFoundError({'source': ''}, 'This attendee is not associated with any ticket') if not (current_user.is_staff or ticket_holder.order.user_id == current_user.id or ticket_holder.user == current_user or has_access( 'is_coorganizer_or_user_itself', event_id=ticket_holder.event_id, user_id=ticket_holder.user.id, )): raise ForbiddenError({'source': ''}, 'Unauthorized Access') file_path = ticket_holder.pdf_url_path if not os.path.isfile(file_path): create_pdf_tickets_for_holder(ticket_holder.order) return send_from_directory('../', file_path, as_attachment=True)
def docs(ref, path): if ref == 'head': ref = get_head() if ref is None: abort(404) elif not re.match(r'^[A-Fa-f0-9]{7,40}$', ref): abort(404) redirect = ensure_login() if redirect: return redirect save_dir = current_app.config['SAVE_DIRECTORY'] if len(ref) < 40: for candi in os.listdir(save_dir): if (os.path.isdir(os.path.join(save_dir, candi)) and candi.startswith(ref)): return redirect(url_for('docs', ref=candi, path=path)) abort(404) return send_from_directory(save_dir, os.path.join(ref, path))
def export_email_addresses(): email_addresses = [u.email for u in cdw.users.with_fields(origin='web')] tmpdir = current_app.config['TMP_DIR'] fn = os.path.join(tmpdir, 'email_addresses.txt') f = open(fn, "w") for item in email_addresses: f.write("%s\n" % item) f.close() zfn = os.path.join(tmpdir, 'email_addresses.zip') zf = zipfile.ZipFile(zfn, mode='w', compression=zipfile.ZIP_DEFLATED) zf.write(fn, arcname='email_addresses.txt') zf.close() os.unlink(fn) return send_from_directory(tmpdir, 'email_addresses.zip')
def receiveFromServer(): passwdServer = request.headers.get('x-passwd') passwdClient = request.headers.get('x-auth') isValid = False if (passwdServer != None): if (master.passwordCorrect(request.headers.get('x-passwd'))): isValid = True else: return {"status": "incorrect password"} elif (passwdClient != None): uid, isValid = requireRegister() else: isValid = False if (isValid): cmd = request.json['sFile'] return send_from_directory(directory=FOLDER, filename=cmd, as_attachment=True) else: return {'status': 'notValid'}, 200
def upload_file(): # check if the post request has the file part if 'file' not in request.files: print(request.files) resp = jsonify({'message': 'No file part in the request'}) return resp, 400 file = request.files['file'] if file.filename == '': resp = jsonify({'message': 'No file selected for uploading'}) return resp, 400 if file and allowed_file(file.filename): filename = secure_filename(file.filename) file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename)) modify(os.path.join(app.config['UPLOAD_FOLDER'], filename)) return send_from_directory(os.path.join(os.getcwd()), 'results.txt') else: resp = jsonify({'message': 'Allowed file types are pdf'}) return resp, 400
def show_image(entry_id, image_id): with app.test_request_context(): entry = Entry.query.filter_by(id = entry_id).first() images = Images.query.filter_by(id = entry.imgs_id).first() print(entry_id, images) img = images.get_images()[image_id] filetype = 'JPEG' if images.get_filetypes()[image_id] == "jpg" else images.get_filetypes()[image_id].upper() img_id = 0 if session.get('img_id') is None else session.get('img_id') img_path = '{}\\{}.{}'.format(app.config['UPLOAD_FOLDER'], img_id, filetype.lower()) try: img = Image.open(io.BytesIO(img)) img.save(img_path, filetype) except UnidentifiedImageError as e: print(e) #deletion-handling session['img_id'] = img_id + 1 session['imgs'] = [img_path] if session.get('imgs') is None else session.get('imgs').append(img_path) return send_from_directory(app.config['UPLOAD_FOLDER'], '{}.{}'.format(img_id, filetype.lower()))
def order_invoices(order_identifier): if current_user: try: order = Order.query.filter_by(identifier=order_identifier).first() except NoResultFound: raise NotFoundError({'source': ''}, 'Order Invoice not found') if (has_access( 'is_coorganizer_or_user_itself', event_id=order.event_id, user_id=order.user_id, ) or order.is_attendee(current_user)): file_path = order.invoice_pdf_path if not os.path.isfile(file_path): create_pdf_tickets_for_holder(order) return send_from_directory('../', file_path, as_attachment=True) else: raise ForbiddenError({'source': ''}, 'Unauthorized Access') else: raise ForbiddenError({'source': ''}, 'Authentication Required to access Invoice')
def get_outputs(location): """ Get a outputs resource --- description: Gets a outputs resource, returning a compressed outputs tar file. produces: - application/json responses: 200: description: A compressed tar of the outputs generated by an analysis. 404: description: Resource not found. parameters: - name: location in: path description: The location of the outputs resource to download. required: true type: string """ logging.debug("Location: {}".format(location)) return send_from_directory(settings.get('server', 'OUTPUTS_DATA_DIRECTORY'), location + TAR_FILE_SUFFIX)
def get_exposure(location): """ Get an exposure resource --- description: Returns an exposure resource. produces: - application/json responses: 200: description: A compressed tar file containing the Oasis exposure files. 404: description: Resource not found parameters: - name: location in: path description: The location of the exposure resource. required: true type: string """ logging.debug("Location: {}".format(location)) return send_from_directory(settings.get('server', 'INPUTS_DATA_DIRECTORY'), location + TAR_FILE_SUFFIX)
def render_tile(hashId, zoom, tileId): print "Request for hash: {2} tile: {1} at zoom {0}".format(zoom, tileId, hashId) # Generate a consistent name based upon the tile request. # Identical future requests result in the same name. # This is the basis for the tile cache. col,row = tileId.split('.')[0].split('_') TILE_SIZE = 64 x0 = (int(col)-1) * TILE_SIZE x1 = x0 + TILE_SIZE # y is inverted (the pano code assumes y is down...) row = 8 - int(row) y0 = (int(row)-1) * TILE_SIZE y1 = y0 + TILE_SIZE outDir = "assets/tiles/" + hashId if not os.path.exists(outDir): os.mkdir(outDir) outputName = "{}_{}-{}_{}-{}.png".format(zoom, x0, x1, y0, y1) outputFilepath = os.path.join(outDir, outputName) sendFile = False if os.path.exists(outputFilepath): print "Sending cached tile:", outputFilepath sendFile = True else: cmdLineArgs = "glow --input={0} --output={1} --imageArea={2},{3},{4},{5} --gamma={6} --verbose". \ format(curSceneFile, outputFilepath, x0, x1, y0, y1, 1.25) print "Calling glow:", cmdLineArgs sendFile = glow.run(cmdLineArgs.split()) == 0 if sendFile: print "sending {} {}".format(outDir, outputName) return send_from_directory(outDir, outputName) abort(500)
def predict(): #Redundant: start_data=first proceeding period of end of dataset #start_date = request.args.get('start_date', '') end_date = request.args.get('end_date', '2012-05-05 23:00:00+00:00') if end_date=='null': end_date = '2012-05-05 23:00:00+00:00' #Depending on output type perform the appropriate prediction action #timeser.get_prediction_for_daterange builds forecast output_type = request.args.get('type', 'json') if output_type=='coords': #For visualization below methods are called return dumps(get_coords(end_date)) elif output_type=='json': predicted_demand = timeser.get_prediction_for_daterange(end_date, asutc=True) return jsonify(predicted_demand.to_dict()) else: predicted_demand = timeser.get_prediction_for_daterange(end_date, asutc=True) odir = './generated_csvs/' tfile = 'temp'+str(datetime.now())+'.csv' predicted_demand.to_csv(odir + tfile) return send_from_directory(odir, tfile)
def get(self, filename): root = self.root if filename.startswith("vendor/") and self.hacky_vendor_root: root = self.hacky_vendor_root # We do this in debug to work around http://stackoverflow.com/q/17460463/871202 # By reading the file into memory ourselves, we seem to avoid hitting that # VirtualBox issue in dev. In prod, it's unchanged and we just send_from_directory if app.debug: full_name = root + "/" + filename if filename: mimetype = mimetypes.guess_type(filename)[0] else: mimetype = 'application/octet-stream' return Response( open(full_name), mimetype=mimetype, headers={"Content-Disposition": "filename=" + filename}) else: return send_from_directory(root, filename, cache_timeout=self.cache_timeout)
def db(): #Xlsxwrite date_string = datetime.now().strftime('%Y%m%d%H%M%S') workbook = xlsxwriter.Workbook('./resources/%s.xlsx' % date_string) worksheet = workbook.add_worksheet('book_data') s_row = 2 s_col = 1 # DB연결 engine = create_engine("mysql+pymysql://root:rootroot@localhost/test") conn = engine.raw_connection() cursor = conn.cursor() cursor.callproc('select_all_books') data = cursor.fetchall() worksheet.write(s_row-1, 1, 'book id') worksheet.write(s_row-1, 2, 'book name') worksheet.write(s_row-1, 3, 'book price') worksheet.write(s_row-1, 4, 'book type') for row_data in data: for col_data in row_data: worksheet.write(s_row, s_col, col_data) s_col += 1 s_col = 1 s_row += 1 worksheet.write(s_row, 2, 'Total') worksheet.write(s_row, 3, '=sum(D3:D12)') worksheet.write(s_row, 4, '=counta(E3:E12)') workbook.close() return send_from_directory('./resources', '%s.xlsx' % date_string, as_attachment=True)
def send_static_file(self, filename): """Function used internally to send static files from the static folder to the browser. .. versionadded:: 1.0.1 """ if not self.has_static_folder: raise RuntimeError('No static folder for this object') # Ensure get_send_file_max_age is called in all cases. # Here, we ensure get_send_file_max_age is called for Blueprints. cache_timeout = self.get_send_file_max_age(filename) folders = self.static_folder if isinstance(self.static_folder, string_types): folders = [self.static_folder] for directory in folders: try: return send_from_directory( directory, filename, cache_timeout=cache_timeout) except NotFound: pass raise NotFound()
def download(book_id): return send_from_directory(app.config['UPLOAD_FOLDER'], f'{book_id}.pdf', as_attachment=True)
def send_static_file(filename): cache_timeout = flaskadminapp.get_send_file_max_age(filename) return send_from_directory(folder, filename, cache_timeout=cache_timeout)
def static_view_func(self, root_path, filename): from flask.helpers import send_from_directory return send_from_directory(root_path, filename)
def index(): return send_from_directory(".", "index.html")
def view(path): return send_from_directory("./images", path)
def js(path): return send_from_directory("js", path)
def favicon(): return send_from_directory(os.path.join(app.root_path, 'static'), 'favicon.ico', mimetype='image/vnd.microsoft.icon')
def send_js(path): return send_from_directory('static', path)
def showStatic(self, filename): d = os.path.join(self.plugin_path, 'static') from flask.helpers import send_from_directory return send_from_directory(d, filename)
def root(): current_app.logger.debug("ROOT: return index.html") return send_from_directory(current_app.config["WEBAPP_SOURCE"], "index.html")