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():
