from pathlib import Path from config import config from flask_dropzone import Dropzone import xmlschema import xml.etree.ElementTree from xml.etree.ElementTree import ParseError from flask_cors import CORS import xmljson import xmltodict from xmljson import badgerfish as bf from lxml.etree import fromstring, tostring import json app = Flask(__name__) CORS(app) bootstrap = Bootstrap() dropzone = Dropzone(app) app.config.from_pyfile('config.cfg') reldate = app.config['RELEASE_DATE'] version = app.config['VERSION'] app.config.update( # Flask-Dropzone config: DROPZONE_ALLOWED_FILE_CUSTOM=True, DROPZONE_ALLOWED_FILE_TYPE='.spif', DROPZONE_MAX_FILE_SIZE=1, DROPZONE_MAX_FILES=1, ) # Shorthand def setGeneralInfo(xmlRoot, target, paramList):
from datetime import datetime from flask import Flask, render_template, redirect, url_for, flash, session, request from flask_bootstrap import Bootstrap from flask_script import Manager from forms import LoginForm, RegistrarForm, BuscarForm, AltaVentaForm #Import para verificar si existe el archivo ventas que vamos a usar para procesar: import os.path #Generamos un archivo que tenga las clases generadas por nosotros y las cargamos para su uso con un from from classes import LineaTabla #Numpy nos permite sumar, agrupar, sacar listas unicas (para el criterio de filtros viene como trompada) y otros menesteres. import numpy as np #Permite inteligencia de datos import pandas as pd app = Flask(__name__) manager = Manager(app) bootstrap = Bootstrap(app) app.config[ 'SECRET_KEY'] = 'un string que funcione como llave' #String que funciona como llave tablaRegistros = None tablaFiltrada = None ultimasVentas = None mensajesErroresArchivo = [] cabeceras = [ '', '', '', '', '' ] #Lo defino global adrede porque lo tengo que tener en cuenta al momento de grabar! @app.route('/') def index(): return render_template('index.html', fecha_actual=datetime.utcnow(),
from selenium.webdriver.common.by import By from selenium.webdriver.support.ui import WebDriverWait from selenium.webdriver.support import expected_conditions as EC from selenium.webdriver.common.action_chains import ActionChains from selenium.webdriver.common.keys import Keys from selenium.common.exceptions import TimeoutException, StaleElementReferenceException def WaitforElement(browser, timeout, xpathElement): try: WebDriverWait(browser, timeout).until(EC.visibility_of_element_located((By.XPATH, xpathElement))) except TimeoutException: print("Timed out waiting for page to load") browser.quit() app = Flask(__name__) Bootstrap(app) # use bootstrap action_url = "https://play.google.com/store/apps/category/GAME_ACTION?hl=en" browser = webdriver.Chrome() browser.get(action_url) #game categories objects of all game titles and category all_game_categories = collections.OrderedDict() title_categoryElements = browser.find_elements_by_xpath('//a[@class="title-link id-track-click"]') # get all the Title buttons title_categories = [(x.text, x.get_attribute('href')) for x in title_categoryElements] for title in title_categories: browser.get(title[1])
from flask import Flask, render_template, redirect, url_for, flash, abort from flask_bootstrap import Bootstrap from flask_ckeditor import CKEditor from datetime import date from functools import wraps from werkzeug.security import generate_password_hash, check_password_hash from flask_sqlalchemy import SQLAlchemy from sqlalchemy.orm import relationship from flask_login import UserMixin, login_user, LoginManager, login_required, current_user, logout_user from forms import LoginForm, RegisterForm, CreatePostForm, CommentForm from flask_gravatar import Gravatar app = Flask(__name__) app.config['SECRET_KEY'] = '8BYkEfBA6O6donzWlSihBXox7C0sKR6b' ckeditor = CKEditor(app) Bootstrap(app) gravatar = Gravatar(app, size=100, rating='g', default='retro', force_default=False, force_lower=False, use_ssl=False, base_url=None) ##CONNECT TO DB app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///blog.db' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db = SQLAlchemy(app) login_manager = LoginManager() login_manager.init_app(app)
def create_app(config_filename="config.development.Config", app_name=None, register_blueprints=True): # App configuration app = Flask(app_name or __name__) app_settings = os.getenv("APP_SETTINGS", config_filename) print(f" * Loading config: '{app_settings}'") try: cfg = import_string(app_settings)() except ImportError: print(" *** Cannot import config ***") cfg = import_string("config.config.BaseConfig") print(" *** Default config loaded, expect problems ***") if hasattr(cfg, "post_load"): print(" *** Doing some magic") cfg.post_load() app.config.from_object(cfg) app.wsgi_app = ProxyFix(app.wsgi_app, x_proto=1, x_host=1) Bootstrap(app) app.jinja_env.add_extension("jinja2.ext.with_") app.jinja_env.add_extension("jinja2.ext.do") app.jinja_env.globals.update(is_admin=is_admin) if HAS_SENTRY: sentry_sdk.init( app.config["SENTRY_DSN"], integrations=[SentryFlaskIntegration(), SentryCeleryIntegration()], release=f"{VERSION} ({GIT_VERSION})", ) print(" * Sentry Flask/Celery support activated") print(" * Sentry DSN: %s" % app.config["SENTRY_DSN"]) if app.debug: app.jinja_env.auto_reload = True logging.basicConfig(level=logging.DEBUG) # Logging if not app.debug: formatter = logging.Formatter("%(asctime)s %(levelname)s: %(message)s " "[in %(pathname)s:%(lineno)d]") file_handler = RotatingFileHandler("%s/errors_app.log" % os.getcwd(), "a", 1000000, 1) file_handler.setLevel(logging.INFO) file_handler.setFormatter(formatter) app.logger.addHandler(file_handler) CORS(app, origins=["*"]) if app.debug: logging.getLogger("flask_cors.extension").level = logging.DEBUG mail = Mail(app) # noqa: F841 migrate = Migrate(app, db) # noqa: F841 lgtm [py/unused-local-variable] babel = Babel(app) # noqa: F841 app.babel = babel template = { "swagger": "2.0", "info": { "title": "reel2bits API", "description": "API instance", "version": VERSION }, "host": app.config["AP_DOMAIN"], "basePath": "/", "schemes": ["https"], "securityDefinitions": { "OAuth2": { "type": "oauth2", "flows": { "authorizationCode": { "authorizationUrl": f"https://{app.config['AP_DOMAIN']}/oauth/authorize", "tokenUrl": f"https://{app.config['AP_DOMAIN']}/oauth/token", "scopes": { "read": "Grants read access", "write": "Grants write access", "admin": "Grants admin operations", }, } }, } }, "consumes": ["application/json", "application/jrd+json"], "produces": ["application/json", "application/jrd+json"], } db.init_app(app) # ActivityPub backend back = Reel2BitsBackend() ap.use_backend(back) # Oauth config_oauth(app) # Setup Flask-Security security = Security( app, user_datastore) # noqa: F841 lgtm [py/unused-local-variable] @FlaskSecuritySignals.password_reset.connect_via(app) @FlaskSecuritySignals.password_changed.connect_via(app) def log_password_reset(sender, user): if not user: return add_user_log(user.id, user.id, "user", "info", "Your password has been changed !") @FlaskSecuritySignals.reset_password_instructions_sent.connect_via(app) def log_reset_password_instr(sender, user, token): if not user: return add_user_log(user.id, user.id, "user", "info", "Password reset instructions sent.") @FlaskSecuritySignals.user_registered.connect_via(app) def create_actor_for_registered_user(app, user, confirm_token): if not user: return actor = create_actor(user) actor.user = user actor.user_id = user.id db.session.add(actor) db.session.commit() @babel.localeselector def get_locale(): # if a user is logged in, use the locale from the user settings identity = getattr(g, "identity", None) if identity is not None and identity.id: return identity.user.locale # otherwise try to guess the language from the user accept # header the browser transmits. We support fr/en in this # example. The best match wins. return request.accept_languages.best_match(AVAILABLE_LOCALES) @babel.timezoneselector def get_timezone(): identity = getattr(g, "identity", None) if identity is not None and identity.id: return identity.user.timezone @app.before_request def before_request(): _config = Config.query.first() if not _config: flash(gettext("Config not found"), "error") cfg = { "REEL2BITS_VERSION_VER": VERSION, "REEL2BITS_VERSION_GIT": GIT_VERSION, "app_name": _config.app_name, "app_description": _config.app_description, } if GIT_VERSION: cfg["REEL2BITS_VERSION"] = "{0}-{1}".format(VERSION, GIT_VERSION) else: cfg["REEL2BITS_VERSION"] = VERSION g.cfg = cfg @app.errorhandler(InvalidUsage) def handle_invalid_usage(error): response = jsonify(error.to_dict()) response.status_code = error.status_code return response # Tracks files upload set sounds = UploadSet("sounds", AUDIO) configure_uploads(app, sounds) # Album artwork upload set artworkalbums = UploadSet("artworkalbums", Reel2bitsDefaults.artwork_extensions_allowed) configure_uploads(app, artworkalbums) # Track artwork upload set artworksounds = UploadSet("artworksounds", Reel2bitsDefaults.artwork_extensions_allowed) configure_uploads(app, artworksounds) # User avatars avatars = UploadSet("avatars", Reel2bitsDefaults.avatar_extensions_allowed) configure_uploads(app, avatars) # Total max size upload for the whole app patch_request_class(app, app.config["UPLOAD_TRACK_MAX_SIZE"]) app.flake_id = FlakeId() if register_blueprints: from controllers.main import bp_main app.register_blueprint(bp_main) from controllers.admin import bp_admin app.register_blueprint(bp_admin) # ActivityPub from controllers.api.v1.well_known import bp_wellknown app.register_blueprint(bp_wellknown) from controllers.api.v1.nodeinfo import bp_nodeinfo app.register_blueprint(bp_nodeinfo) from controllers.api.v1.ap import bp_ap # Feeds from controllers.feeds import bp_feeds app.register_blueprint(bp_feeds) # API app.register_blueprint(bp_ap) from controllers.api.v1.auth import bp_api_v1_auth app.register_blueprint(bp_api_v1_auth) from controllers.api.v1.accounts import bp_api_v1_accounts app.register_blueprint(bp_api_v1_accounts) from controllers.api.v1.timelines import bp_api_v1_timelines app.register_blueprint(bp_api_v1_timelines) from controllers.api.v1.notifications import bp_api_v1_notifications app.register_blueprint(bp_api_v1_notifications) from controllers.api.tracks import bp_api_tracks app.register_blueprint(bp_api_tracks) from controllers.api.albums import bp_api_albums app.register_blueprint(bp_api_albums) from controllers.api.account import bp_api_account app.register_blueprint(bp_api_account) from controllers.api.reel2bits import bp_api_reel2bits app.register_blueprint(bp_api_reel2bits) # Pleroma API from controllers.api.pleroma_admin import bp_api_pleroma_admin app.register_blueprint(bp_api_pleroma_admin) # OEmbed from controllers.api.oembed import bp_api_oembed app.register_blueprint(bp_api_oembed) # Iframe from controllers.api.embed import bp_api_embed app.register_blueprint(bp_api_embed) swagger = Swagger( app, template=template) # noqa: F841 lgtm [py/unused-local-variable] # SPA catchalls for meta tags from controllers.spa import bp_spa app.register_blueprint(bp_spa) @app.route("/uploads/<string:thing>/<path:stuff>", methods=["GET"]) @cross_origin(origins="*", methods=["GET", "HEAD", "OPTIONS"], expose_headers="content-length", send_wildcard=True) def get_uploads_stuff(thing, stuff): if app.testing or app.debug: directory = safe_join(app.config["UPLOADS_DEFAULT_DEST"], thing) app.logger.debug(f"serving {stuff} from {directory}") return send_from_directory(directory, stuff, as_attachment=True) else: app.logger.debug(f"X-Accel-Redirect serving {stuff}") resp = Response("") resp.headers[ "Content-Disposition"] = f"attachment; filename={stuff}" resp.headers[ "X-Accel-Redirect"] = f"/_protected/media/{thing}/{stuff}" resp.headers[ "Content-Type"] = "" # empty it so Nginx will guess it correctly return resp def render_tags(tags): """ Given a dict like {'tag': 'meta', 'hello': 'world'} return a html ready tag like <meta hello="world" /> """ for tag in tags: yield "<{tag} {attrs} />".format( tag=tag.pop("tag"), attrs=" ".join([ '{}="{}"'.format(a, html.escape(str(v))) for a, v in sorted(tag.items()) if v ]), ) @app.errorhandler(404) def page_not_found(msg): excluded = ["/api", "/.well-known", "/feeds", "/oauth/authorize"] if any([request.path.startswith(m) for m in excluded]): return jsonify({"error": "page not found"}), 404 html = get_spa_html(app.config["REEL2BITS_SPA_HTML"]) head, tail = html.split("</head>", 1) request_tags = get_request_head_tags(request) default_tags = get_default_head_tags(request.path) unique_attributes = ["name", "property"] final_tags = request_tags skip = [] for t in final_tags: for attr in unique_attributes: if attr in t: skip.append(t[attr]) for t in default_tags: existing = False for attr in unique_attributes: if t.get(attr) in skip: existing = True break if not existing: final_tags.append(t) head += "\n" + "\n".join(render_tags(final_tags)) + "\n</head>" return head + tail @app.errorhandler(403) def err_forbidden(msg): if request.path.startswith("/api/"): return jsonify({"error": "access forbidden"}), 403 pcfg = { "title": gettext("Whoops, something failed."), "error": 403, "message": gettext("Access forbidden"), "e": msg, } return render_template("error_page.jinja2", pcfg=pcfg), 403 @app.errorhandler(410) def err_gone(msg): if request.path.startswith("/api/"): return jsonify({"error": "gone"}), 410 pcfg = { "title": gettext("Whoops, something failed."), "error": 410, "message": gettext("Gone"), "e": msg } return render_template("error_page.jinja2", pcfg=pcfg), 410 if not app.debug: @app.errorhandler(500) def err_failed(msg): if request.path.startswith("/api/"): return jsonify({"error": "server error"}), 500 pcfg = { "title": gettext("Whoops, something failed."), "error": 500, "message": gettext("Something is broken"), "e": msg, } return render_template("error_page.jinja2", pcfg=pcfg), 500 @app.after_request def set_x_powered_by(response): response.headers["X-Powered-By"] = "reel2bits" return response # Register CLI commands app.cli.add_command(commands.db_datas) app.cli.add_command(commands.users) app.cli.add_command(commands.roles) app.cli.add_command(commands.tracks) app.cli.add_command(commands.system) return app
from flask import Flask from flask_bootstrap import Bootstrap from config import Config from flask_sqlalchemy import SQLAlchemy from flask_migrate import Migrate from flask_login import LoginManager app = Flask(__name__) app.config.from_object(Config) db = SQLAlchemy(app) migrate = Migrate(app, db) login = LoginManager(app) login.login_view = 'login' from app import routes, models bootstrap = Bootstrap( app) #Do this to use bootstrap instead of linking with style tag in HTML
def create_app(config_name): log_config_path = os.path.join( Path(__file__).parent.absolute(), 'log/logger.conf') if not (os.path.isfile(log_config_path)): assert os.environ.get( 'LOG_FILE' ), 'É necessário informar o path do arquivo de configuração do log!' log_config_path = os.environ.get('LOG_FILE') logging.config.fileConfig(log_config_path) logging.getLogger(__name__).info('Criando objeto da aplicação') app = Flask(__name__, instance_relative_config=True) app.config.from_object(app_config[config_name]) app.config.from_pyfile('config.py') db.init_app(app) login_manager.init_app(app) login_manager.login_message = "Você precisa estar logado para acessar esta página!" login_manager.login_view = "auth.login" Bootstrap(app) migrate = Migrate(app, db) logging.getLogger(__name__).info('Registrando blueprints') app.register_blueprint(admin, url_prefix='/admin') app.register_blueprint(auth) app.register_blueprint(home) @app.errorhandler(403) def forbidden(error): return render_template('errors/403.html', title='Acesso proibido'), 403 @app.errorhandler(404) def page_not_found(error): return render_template('errors/404.html', title='Página não encontrada'), 404 @app.errorhandler(500) def internal_server_error(error): return render_template('errors/500.html', title='Erro genérico'), 500 import dropshipping.api.categorias.resources as api_categoria import dropshipping.api.fornecedores.resources as api_fornecedor import dropshipping.api.produtos.resources as api_produto api = Api(app) api.add_resource(api_categoria.CategoriaAPI, '/api/v1/categoria/<int:id>') api.add_resource(api_categoria.ListaCategoriaAPI, '/api/v1/categoria') api.add_resource(api_fornecedor.FornecedorAPI, '/api/v1/fornecedor/<int:id>') api.add_resource(api_fornecedor.ListaFornecedorAPI, '/api/v1/fornecedor') api.add_resource(api_produto.ProdutoAPI, '/api/v1/produto/<int:id>') api.add_resource(api_produto.ListaProdutoAPI, '/api/v1/produto') return app
def web_interface(): webui = Flask(__name__) bootstrap = Bootstrap(webui) wi_selected_room = '' @webui.route('/') def index(): return render_template('index.html', room_list=room_list()) @webui.route('/room/<room_name>', methods=['GET', 'POST']) def room_name(room_name): global h if request.method == 'POST': dev_to_ctrl = request.form['status'].split(' ') if dev_to_ctrl[0] == 'On': for i in h.room: if room_name.encode('ascii') == i.name: for j in i.device: if dev_to_ctrl[1] == j.name: j.level = 100 break return render_template('room.html', room_name=room_name, dev_list=dev_list(room_name), status='Device is turned On!') elif dev_to_ctrl[0] == 'Off': for i in h.room: if room_name.encode('ascii') == i.name: for j in i.device: if dev_to_ctrl[1] == j.name: j.level = 0 break return render_template('room.html', room_name=room_name, dev_list=dev_list(room_name), status='Device is turned Off!') else: return render_template('room.html', room_name=room_name, dev_list=dev_list(room_name), status='') @webui.route('/add_room') def add_room(): return render_template('add_room.html') @webui.route('/rem_room') def rem_room(): return render_template('rem_room.html', room_list=room_list()) @webui.route('/load_backup') def load_backup(): return render_template('load_backup.html') @webui.route('/add_dev') def add_dev(): global wi_selected_room room_name = request.referrer.split('/') wi_selected_room = room_name[4] return render_template('add_dev.html') @webui.route('/rem_dev') def rem_dev(): global wi_selected_room room_name = request.referrer.split('/') wi_selected_room = room_name[4] return render_template('rem_dev.html', dev_list=dev_list(wi_selected_room)) @webui.route('/msg/<method_type>', methods=['GET', 'POST']) def msg(method_type): global h global wi_selected_room method_type = method_type.encode('ascii') if request.method == 'POST': if 'add_room' == method_type: return render_template('msg.html', msg=h.add_room(request.form['room_name'])) elif 'rem_room' == method_type: return render_template('msg.html', msg=h.rem_room(request.form['room_name'])) elif 'add_dev' == method_type: dev_name = request.form['dev_name'] pin_no = int(request.form['pin_no']) for i in h.room: if i.name == wi_selected_room: msg = i.add_dev(dev_name, pin_no) break wi_selected_room = '' return render_template('msg.html', msg=msg) elif 'rem_dev' == method_type: dev_name = request.form['dev_name'] for i in h.room: if i.name == wi_selected_room: msg = i.rem_dev(dev_name) break wi_selected_room = '' return render_template('msg.html', msg=msg) elif 'load' == method_type: # There is one problem, a file if not saved before and asked to load is unhandled in this function, might be implemented later. filename = request.form['load'] h = hl.house_load('r', h, filename) return render_template('msg.html', msg='BackUp loaded!') elif 'backup' == method_type: filename = request.form['backup'] hl.house_load('w', h, filename) return render_template('msg.html', msg='BackUp done!') else: return 'Problem Occured!' else: return render_template('index.html') webui.run(debug=True, host='localhost', port=8080)
#!/usr/bin/env python3 # _*_ coding:utf-8 _*_ from datetime import datetime from flask import Flask, render_template from flask_bootstrap import Bootstrap from flask_moment import Moment __author__ = 'CityManager' app = Flask(__name__) Bootstrap(app) # 使用flask_bootstrap扩展 Moment(app) @app.route('/micros/') def learn_micros(): return render_template('common.html', comments=range(1, 10)) @app.route('/include/') def learn_include(): return render_template('base.html', comments=range(1, 10)) @app.route('/extends/') def learn_extend(): return render_template('use_base.html', comments=range(1, 10)) @app.route('/flask_bootstrap/') def use_flask_bootstrap():