def _archives(): rpm = flask.Blueprint("archives", __name__) AutoIndex(rpm, browse_root=path.join( self.app_repo_config.artifacts_directory, 'archives')) self.register_blueprint(rpm, url_prefix="/archives")
def main(): config = configparser.ConfigParser() # INI file validation. try: with open('log_access.ini') as f: config.read('log_access.ini') except IOError: print("log_access.ini doesn't exist. Hence taking a default dict." " with path : /var/log/redant and port : 5000") config = {"serverdata": {"path": "/var/log/redant", "port": 5000}} # Path extraction and validation. try: ppath = config['serverdata']['path'] except Exception as KeyError: print("Key error in path. Defaulting to /var/log/redant as log path.") ppath = "/var/log/redant" # Port extraction and validation. try: fport = int(config['serverdata']['port']) except Exception as KeyError: print("Key error in port. Defaulting to 5000.") fport = 5000 except Exception as ValueError: print("Value error in port. Defaulting to 5000.") fport = 5000 app = Flask(__name__) AutoIndex(app, browse_root=ppath) app.run(host='0.0.0.0', port=fport)
def _ova_updates(): ova = flask.Blueprint("ova", __name__) AutoIndex(ova, browse_root=path.join( self.app_repo_config.artifacts_directory, 'ova', 'updates')) self.register_blueprint(ova, url_prefix="/ova")
def start_server(port, directory): print("Starting server normal") # output_file.write("Starting server normal") os.chdir(directory) app = Flask("Files") AutoIndex(app, browse_root=os.path.curdir) port = int(port) try: app.run(port=port) finally: print("Closing Server")
class cdn : app = Flask(__name__) AutoIndex(app, browse_root=os.path.curdir) @app.route('/list') def list(): r=[] f=[os.path.join(dirpath, f) for dirpath, dirnames, files in os.walk(os.getcwd()) for f in files] for i in range(-1,len(f)-1) : s=str(f[i]).replace(str(os.getcwd()),'') s=s.replace('\\','/') r.append(s[1:len(s)]) return str(r)
def start_server_tor(port, directory, output_fileer): print("Starting server TOR") os.chdir(directory) app = Flask(__name__) AutoIndex(app, browse_root=os.path.curdir) print('Connecting to tor') with Controller.from_port() as controller: controller.authenticate() response = controller.create_ephemeral_hidden_service( {80: 5000}, await_publication=True) print("%s.onion" % response.service_id) output_fileer = str(output_fileer) output_fileer = output_fileer.replace("\\\\", "/") print(output_fileer) temp = open(output_fileer, "w") temp.write("%s.onion" % response.service_id) temp.close() try: app.run() finally: print("Stopping server")
database = databases.Database(DATABASE_URL) user_db = fastusr.db.SQLAlchemyUserDatabase(user_db_model=mdl.UserDB, database=database, users=base.UserTable.__table__) jwt_authentication = fastusr.authentication.JWTAuthentication( secret=SECRET, lifetime_seconds=28800, tokenUrl='/auth/jwt/login') api_users = fastusr.FastAPIUsers(db=user_db, auth_backends=[jwt_authentication], user_model=mdl.User, user_create_model=mdl.UserCreate, user_update_model=mdl.UserUpdate, user_db_model=mdl.UserDB) # Flask AutoIndex module for exploring directories flask_app = Flask(__name__) AutoIndex(flask_app, browse_root=RESULTS_DIR) app.mount('/index', WSGIMiddleware(flask_app)) @app.on_event("startup") async def startup(): await database.connect() @app.on_event("shutdown") async def shutdown(): await database.disconnect() @app.get('/') async def root():
from flask import Flask, request, jsonify from flask_autoindex import AutoIndex from exception import ValueBadRequest, JSONExceptionHandler from werkzeug.utils import secure_filename from checksum import ck app = Flask(__name__) AutoIndex(app, browse_root='./data') JSONExceptionHandler(app) cache = {'crc32': {}, 'sha1': {}, 'md5': {}} @app.route('/checksum', methods=['GET'], strict_slashes=False) def checksum(): mode = request.args.get('mode') filename = request.args.get('filename') checksum_user = request.args.get('checksum') if mode is None: raise ValueBadRequest('mode') if filename is None: raise ValueBadRequest('filename') if checksum_user is None: raise ValueBadRequest('checksum') if cache[mode].get(filename) is None: cache[mode][filename] = ck('./data/{}'.format(filename), mode) checksum_server = cache[mode][filename]
from flask_autoindex import AutoIndex from flask_restful import Api import logging import platform import os.path import sys env = Environment() # prepare the RESTful application # prepare static webserver # set the project root directory as the static folder, you can set others. app = Flask(__name__, static_url_path='', static_folder=str(env.projectPath) + '/web') files_index = AutoIndex(app, browse_root=env.games, add_url_rules=False) api = Api(app) # app.logger.addHandler(logging.StreamHandler(STDOUT)) app.logger.setLevel(logging.INFO) if WebApp.debug: app.logger.setLevel(logging.DEBUG) app.logger.info("python src folder is %s" % (env.scriptPath)) # check if we are running on a raspberry PI app.logger.info("Running on %s" % (platform.system())) # https://raspberrypi.stackexchange.com/questions/5100/detect-that-a-python-program-is-running-on-the-pi if platform.system() == 'Linux' and os.path.exists( '/sys/firmware/devicetree/base/model'): app.logger.info("Running on Raspberry PI")
import os import tarfile from flask import Flask, request, flash, redirect, render_template from flask import Blueprint from flask_autoindex import AutoIndex import shutil from werkzeug.utils import secure_filename app = Flask(__name__) app.config.from_object('tarhosting.config') app.secret_key = app.config['SECRET_KEY'] auto_index = AutoIndex(app, browse_root=app.config['STATIC_DIR'], add_url_rules=False) @app.route("/") def index(): return render_template('index.html', URL=request.url) @app.route('/browse') @app.route('/browse/') @app.route('/browse/<path:path>') def autoindex(path='.'): return auto_index.render_autoindex(path) @app.route('/deploy/<path:name>', methods=['POST']) def deploy(name):
from flask import * from flask_autoindex import AutoIndex from werkzeug.utils import secure_filename import os, json with open('backend/path.json', 'r') as f: k = json.loads(f.read()) UPLOAD_FOLDER = k['path'] # pls change this, thanks! ALLOWED_EXTENSIONS = {'txt', 'pdf', 'png', 'jpg', 'jpeg', 'gif'} app = Flask(__name__) AutoIndex(app, browse_root=UPLOAD_FOLDER) app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER app.secret_key = 'super secret key' app.config['SESSION_TYPE'] = 'filesystem' def allowed_file(filename): return '.' in filename and \ filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS @app.route('/upload', methods=['GET', 'POST']) def upload_file(): x = request.args.get('path') if request.method == 'POST': # check if the post request has the file part if 'file' not in request.files: flash('No file part') return redirect(request.url)
import os.path from flask import Flask from flask_autoindex import AutoIndex app = Flask(__name__) AutoIndex(app, browse_root=os.path.curdir + "/output") if __name__ == '__main__': app.run(host='0.0.0.0', port=80)
#!/usr/bin/env python3 from subprocess import Popen, PIPE from functools import wraps import requests import atexit from flask import Flask, render_template, request, jsonify, escape from flask_autoindex import AutoIndex import giphypop from music_backend import sched from deezer import deezer_search, start_deezer_keepalive, stop_deezer_keepalive, is_deezer_session_valid from configuration import config app = Flask(__name__) auto_index = AutoIndex(app, config["download_dirs"]["base"], add_url_rules=False) auto_index.add_icon_rule('music.png', ext='m3u8') giphy = giphypop.Giphy() # user input validation def validate_schema(*parameters_to_check): def decorator(f): @wraps(f) def wrapper(*args, **kw): j = request.get_json(force=True) print("User request: {} with {}".format(request.path, j)) # check if all parameters are supplied by the user if set(j.keys()) != set(parameters_to_check):
WHERE filename = ?''' cur = conn.cursor() cur.execute(sql, comic) conn.commit() def init_db(): sql = '''CREATE TABLE comics(filename TEXT,status INT,page INT)''' conn = create_connection(db_file) cur = conn.cursor() cur.execute(sql) conn.commit() ppath = "/comics/" # update your own parent directory here files_index = AutoIndex(app, ppath, add_url_rules=False) files_index.add_icon_rule('contrast.png', rule=is_comic_reading) files_index.add_icon_rule('tick.png', rule=is_comic_read) db_file = r"/usr/src/app/sqlite.db" @app.route('/') @app.route('/index') def index(): if not os.path.isfile(db_file): init_db() # TODO : List currently reading comics return render_template('index.html', comics=get_reading_comics()) @app.route('/update_path')
def _python(): rpm = flask.Blueprint("python", __name__) AutoIndex(rpm, browse_root=path.join( self.app_repo_config.artifacts_directory, 'python')) self.register_blueprint(rpm, url_prefix="/python")
import os.path from flask import Flask, escape, request, send_from_directory from flask_autoindex import AutoIndex from environs import Env import subprocess import demjson import requests import tempfile import json from flask_cors import CORS env = Env() env.read_env() app = Flask(__name__) CORS(app) AutoIndex(app, browse_root=os.path.curdir) def form_to_ini(form): """Take the form submitted and convert it to an INI file.""" ini_dict = {} for k in form.keys(): v = form[k] sec_key = k.split(':') if len(sec_key) != 2: continue if not sec_key[0] in ini_dict: ini_dict[sec_key[0]] = {sec_key[1]: v} else: ini_dict[sec_key[0]][sec_key[1]] = v
#!/usr/bin/python3 import json, os, yaml, time, sys from flask import Flask, render_template from flask_autoindex import AutoIndex start_time = time.time() with open("settings.yml", "r") as file: settings = yaml.load(file, Loader=yaml.FullLoader) app = Flask(__name__) AutoIndex(app,browse_root=settings['files_path']) @app.errorhandler(404) def page_not_found(e): return render_template('404.html', 404) if settings['status_path'] != "OFF": @app.route(settings['status_path']) def status(): return render_template("status.html", version=settings['version'], uptime=time.time()-start_time) if __name__ == "__main__": app.run()
from flask import render_template, flash, redirect, url_for, request from flask_login import login_user, logout_user, current_user, login_required from werkzeug.urls import url_parse from app import app, db from app.forms import LoginForm, RegistrationForm from app.models import User import os import os.path from flask_autoindex import AutoIndex files_index = AutoIndex(app, os.path.curdir + '/app/zapis', add_url_rules=False) @app.route('/asd') @app.route('/asd <path:path>') def autoindex(path='.'): return files_index.render_autoindex(path) @app.route('/') @app.route('/index') @login_required def index(): posts = [{ 'author': { 'username': '******' }, 'body': 'Beautiful day in Portland!' }, {
last_name='toilet', email='*****@*****.**', password='******', is_authenticated='False') db.session.add(user) db.session.add(admin) db.session.commit() print('Database seeded.') # db_create() # db_seed() # db_drop() files_index = AutoIndex(app, browse_root=os.path.curdir, add_url_rules=False) # Custom indexing @app.route('/dir') @app.route('/dir/<path:path>') def autoindex(path='.'): return files_index.render_autoindex(path) @app.errorhandler(404) def page_not_found(error): print(basedir) template = ''' <h1>That page doesn't exist.</h1> <h3>%s Not found</h3>''' % (urllib.parse.unquote(request.url))
# ----------------------------------------------------------------# # file serving related # defining the root folder to allow looking # just into it root1 = get_config("base_path") #------------------------------------------------------------------# # FLASK related #-------------------------------------------------# # creating app app = Flask(__name__) # allowing different origins to communicate with it cors = CORS(app, resources={r"/*": {"origins": "*"}}) AutoIndex(app, browse_root=root1) #-------------------------------------------------# # route to VIEW docs and folders in the shared folder @app.route("/docs_view/", methods=["GET"]) @app.route('/docs_view/<path:path>', methods=["GET"]) def get_dir(**kwargs): # using **kwargs allows having any argument with any name # also allows having no arguments (needed to access most # exterior folder) # creating a list of the args given (only 1 or 0 in this case) # to use them later on as path relative_path = list(kwargs.items())
from sqlalchemy.orm.exc import NoResultFound from sqlalchemy import or_ import main import config import lgogdaemon import models from models import Game, User, LoginStatus, Status, Session app = main.app download_scheduler = ThreadPoolExecutor(max_workers=2) update_scheduler = ThreadPoolExecutor(max_workers=2) # Create instance of AutoIndex used to display contents of game download # directory. Explicitely disable add_url_rules as it would define some default # routes for "/" index = AutoIndex(app, config.lgog_library, add_url_rules=False) # Define logger handlers and start update timer if not app.debug or os.environ.get("WERKZEUG_RUN_MAIN") == "true": _session = Session() app.logger.info("Initialize lgogwebui ...") app.logger.info(sys.version) # Make sure that the database exists models.Base.metadata.create_all(models.ENGINE) # Make sure that login state exists in the DB try: _user = _session.query(User).one() except NoResultFound: _user = User() _session.add(_user) _session.commit()
return "" ################################################################################ # state: import new documents @app.route("/state") def state(): imp() f = open(dir + "/Scan/state", "r") state = f.read() f.close() state = state.strip() if state != "": state = state + "<br/><br />" return state ################################################################################ @app.route('/') @app.route('/index.html') def index(): return render_template('index.html') ################################################################################ AutoIndex(app, browse_root=dir) if __name__ == '__main__': app.debug = True app.run(host='0.0.0.0', port=5000)
help="Sets the path for the Private Key", default="privkey.key") args = parser.parse_args() UPLOAD_FOLDER = args.folder app = Flask(__name__, static_url_path=UPLOAD_FOLDER) app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER app.secret_key = 'super secret key' app.config['SESSION_TYPE'] = 'filesystem' if args.ssl: context = ssl.SSLContext() context.load_cert_chain(args.fullchain, args.privkey) AutoIndex(app, browse_root=app.config['UPLOAD_FOLDER']) logging.basicConfig(filename='filebrowser.log', level=logging.DEBUG) log = logging.getLogger('pydrop') @app.route("/", defaults={'path': ''}, methods=['GET', 'POST']) @app.route('/<path:path>', methods=['GET', 'POST']) def index(path): if request.method == 'POST': if request.files['file'].filename != '': file = request.files['file'] save_path = os.path.join( os.path.join(app.config['UPLOAD_FOLDER'], path), secure_filename(file.filename)) current_chunk = int(request.form['dzchunkindex'])
from flask import * from . import login_manager from .models import db, User from flask_autoindex import AutoIndex import json # Blueprint configuration. main_bp = Blueprint('main_bp', __name__, template_folder='templates', static_folder='static') # assets config - locally uploaded. assets_files_index = AutoIndex( main_bp, 'flask_internals/', add_url_rules=False) @main_bp.route('/<path:path>') def autoindex(path='.'): """ Serving /css, images/, and /js paths """ return assets_files_index.render_autoindex('static/assets/' + path) @main_bp.route('/') @main_bp.route('/index.html') def load_index(): return render_template('index.html')
def index(): AutoIndex(horse, browse_root=os.path.curdir + 'Engineering')
def _deb(): deb = flask.Blueprint("deb", __name__) AutoIndex(deb, browse_root=path.join( self.app_repo_config.artifacts_directory, 'deb')) self.register_blueprint(deb, url_prefix="/deb")
try: parse = reqparse.RequestParser() parse.add_argument('file', type=werkzeug.datastructures.FileStorage, location='files') args = parse.parse_args() image_file = args['file'] image_file.save("files/name.jpg") return "Uploaded", 200 except: return "Some error", 401 def get(self): return "F**K YOU", 200 def delete(self): return "F**K YOU", 200 def put(self): return "F**K YOU", 200 api.add_resource(User, "/api/user/<string:name>") api.add_resource(Download, "/api/download/<string:name>") api.add_resource(Upload, '/api/upload/') AutoIndex(app) # app.run(host='0.0.0.0', port=5000, debug=True, threaded=True) if __name__ == "main": app.run()
# Create flask app application = Flask(__name__, static_folder="static") # Load the default configuration application.config.from_object("config.DefaultConfig") # Define the database object which is imported # by modules and controllers db = SQLAlchemy(application) # Authetication scheme auth = HTTPTokenAuth(scheme="Token") # Listing reports directory autoindex = AutoIndex(application, browse_root=Files.REPORTS_FOLDER, add_url_rules=False) @auth.verify_token def verify_token(token): """ Verify token for authentication :param token: Token used by client :return: Boolean """ if token in AppTokens.tokens: g.current_user = AppTokens.tokens[token] return True return False
import os.path from flask import Flask from flask_autoindex import AutoIndex app = Flask(__name__) AutoIndex(app, browse_root='/home/pi/Desktop/surveillance/images') if __name__ == '__main__': app.run(host='0.0.0.0', port=80)
def _directory_index(): packages = flask.Blueprint("packages", __name__) AutoIndex(packages, browse_root=self.app_repo_config.packages_directory) self.register_blueprint(packages, url_prefix="/packages")