Flask BDA
1.0.0
Nota: ¡Aún en desarrollo!
Versión actual: 0.0.0 Beta
Flask-BDA aún se encuentra en desarrollo inicial y se está probando con la versión Python 3.8.6.
Hoja de ruta actual y plan de proyecto de alto nivel: https://trello.com/b/uu4HNPBh/flask-bda-features-roadmap
Flask-BDA seguirá el control de versiones semántico para sus lanzamientos, con un esquema {major}.{minor}.{patch} para los números de versiones, donde:
Las obsolescencias se mantendrán durante al menos 3 versiones menores, después de la versión 0.0.1
Otras soluciones como Tableau, Power BI y Amazon QuickSight, si bien son herramientas fantásticas, se centran en la generación de informes, pero no le permiten editar ni agregar datos a las plataformas cuando sea necesario, lo que significa que necesita soluciones o software adicionales para lograr sus objetivos comerciales.
Soluciones como Excel son accesibles para todos y le brindan toda la flexibilidad que pueda necesitar. Aún así, sus datos están dispersos y no permiten fácilmente una fuente de verdad compartida para su equipo y sus clientes, y es muy fácil que los documentos de Excel no estén sincronizados o incluso se compartan, lo que expone a su empresa a un riesgo de seguridad.
Flask-BDA lo ayuda brindándole el control para entregar aplicaciones Full-stack rápidas y seguras de 2 a 5 veces (2 a 5 veces) más rápido. Sin ningún tipo de dependencia del proveedor o del entorno, nunca.
Flask es un "micromarco" de código abierto escrito por Armin Ronacher que le permite crear aplicaciones web en Python. El envío de solo un pequeño conjunto básico de funciones proporciona una base extensible que permite a los desarrolladores elegir qué herramientas adicionales necesitarán para su aplicación.
A pesar de que se le llama micromarco, Flask es ideal para crear aplicaciones web grandes y pequeñas. Flask ha sido utilizado en sistemas de producción por grandes empresas como Twilio, Pinterest, Lyft, LinkedIn y Uber.
Flask-BDA le ayuda a desarrollarse más rápido proporcionándole una estructura de aplicación de matraz preexistente que le permite:
Ocúpese automáticamente de los aspectos tediosos que ralentizan el desarrollo de software.
- Cree y administre todas las conexiones de bases de datos y consultas complejas.
- Seguridad de aplicaciones con control de acceso basado en usuarios y roles
- Auditorías automáticas de cada acción
Flask-BDA es una plataforma de código bajo (lo que significa que lo ayudaremos escribiendo gran parte del código por usted) que proporciona las herramientas para que las empresas desarrollen e implementen rápidamente aplicaciones seguras que se ejecutan en cualquier dispositivo.
Cambiamos la forma en que se construye el software para que pueda crear e implementar rápidamente aplicaciones críticas de cualquier tamaño que evolucionen con su negocio, ahorrándole tiempo y dinero.
Los desarrolladores pueden crear e implementar una gama completa de aplicaciones, desde aplicaciones para consumidores hasta sistemas comerciales internos críticos, diseñadas para ayudar a los desarrolladores a entregar aplicaciones seguras de manera rápida y eficiente, de modo que las aplicaciones se entreguen en semanas e incluso días.
Flask-BDA proporciona desarrollo completo desde; UI, procesos de negocio, lógica personalizada y modelos de datos para crear aplicaciones multiplataforma listas para usar. Proporcionándole un andamio donde puede agregar su propio código personalizado cuando sea necesario. Sin ningún bloqueo jamás.
Con entornos de desarrollo preconfigurados, reducimos la molestia (y el costo) de llegar al mercado, brindándole la flexibilidad de elegir dónde y cómo realizar la implementación.
Flask-BDA, gratuito y apto para desarrolladores, es una herramienta de desarrollo de aplicaciones de uso gratuito y disponible en código fuente con una licencia compatible con desarrolladores.
Flask-BDA es de uso completamente GRATUITO para proyectos comerciales y personales.
Sin embargo, el desarrollo de software es siempre un ejercicio costoso:
- Deberá pagar a uno o varios desarrolladores de software, analistas comerciales, diseñadores, gerentes de proyectos y otros miembros del equipo para desarrollar su producto.
- Su producto nunca está terminado. Un proyecto de software siempre necesitará un desarrollo continuo.
- Cuando entregas un producto, tu competencia ya está trabajando en características nuevas y mejoradas, y necesitas poder mantenerte a la vanguardia o al menos mantener el ritmo, o los usuarios se trasladarán a tu competencia.
- Una vez que comience a utilizar su producto, usted y su equipo pensarán en nuevas funciones que lo mejorarán aún más y mejorarán sus procesos.
- Mantenimiento continuo. A medida que los usuarios utilicen el producto, encontrarán formas de dañarlo que usted no había pensado y es necesario solucionarlas.
| Tamaño del proyecto | Costo inicial | Costo continuo |
|---|---|---|
| Proyectos de pequeño tamaño (2 - 6 semanas de desarrollo) | $11 250 | $563 - $1 125 (±10%) / por mes |
| Proyectos medianos (2 - 4 meses de desarrollo) | $33 750 | $1 563 - $3 375 (±10%) / por mes |
| Proyectos de gran tamaño (de 6 a 18 meses, o más, de desarrollo) | $156 250 | $3 375 - $15 625 (±10%) / por mes |
| Tamaño del proyecto | Costo inicial | Costo continuo |
|---|---|---|
| Proyectos de pequeño tamaño (1 - 3 semanas de desarrollo) | $3 750 | $188 - $375 (±10%) / por mes |
| Proyectos medianos (1 - 3 meses de desarrollo) | $11 250 | $375 - $1 125 (±10%) / por mes |
| Proyectos de gran tamaño (de 2 a 6 meses, o más, de desarrollo) | $52 084 | $1 125 - $5 208 (±10%) / por mes |
Con Flask-BDA, NO PIERDE NINGUNA flexibilidad del "Desarrollo normal", ya que utiliza patrones de desarrollo estandarizados y tecnologías probadas y comprobadas.
Flask-BDA utiliza muchas tecnologías de código abierto y aprovecha las pilas de tecnología existentes para que pueda encontrar fácilmente otros desarrolladores que utilicen las mismas tecnologías. Como resultado, no tiene que pagar costosas tarifas de licencia o costos ambientales, independientemente de cuántos ingresos obtenga su empresa o en qué parte de su negocio se encuentre.
Comience con un entorno de desarrollo preconfigurado rápido y sencillo en minutos.
No se requiere ninguna configuración compleja. Solo se requiere Python (3.8.6 sugerido).
Actualice sus configuraciones: conexiones de bases de datos y configuraciones de aplicaciones.
Crea tus propios módulos y estructuras de datos (modelo de datos) permitiéndote utilizar diferentes bases de datos.
Generado automáticamente y completamente funcional:
- Páginas
AdminyMobileREST APIscon una interfaz SwaggerGraphQL APIcon una interfaz GraphiQL fácilmente administrada por módulo.
Configure páginas según sus necesidades específicas y compártalas fácilmente con su equipo y clientes.
Escriba su propio código personalizado en un módulo aislado, para que no afecte a otros módulos.
Integre fácilmente módulos en diferentes proyectos.
Utilice la misma base de código para implementar en:
- De oficina
- Web
- Móvil
Los entornos incluyen:
- Estibador
- AWS sin servidor
- Océano digital
- héroeku
- Alojamiento compartido.
pip esté instalado (pip ya debería estar instalado porque viene con las últimas versiones de Python). En caso de que no lo esté, instálelo desde aquí: https://pip.pypa.io/en/stable/installing/python -m pip --version
NOTA: Esta documentación asume que está ejecutando
pip3comopip, por lo que todas las instrucciones están escritas conpip. Si desea quepip3se ejecute cuando llamapip, desde su terminal, puede crear un enlace simbólico apip3desdepip:
pip install --upgrade pipsudo , por ejemplo: sudo pip install --upgrade pip nano ~ /.bash_profile
En el archivo, pegue lo siguiente:
alias pip= ' pip3 '
alias python= ' python3 '
NOTA: Es posible que deba eliminar Python 2.7 en MacOS, ya que está preinstalado en mis distribuciones. Esto fue muy útil para lograr esto:
sudo rm -rf /Library/Frameworks/Python.framework/Versions/2.7sudo rm -rf " /Applications/Python 2.7 "ls -l /usr/local/bin | grep ' ../Library/Frameworks/Python.framework/Versions/2.7 'y luego ejecute el siguiente comando para eliminar todos los enlaces:
cd /usr/local/bin/
ls -l /usr/local/bin | grep ' ../Library/Frameworks/Python.framework/Versions/2.7 ' | awk ' {print $9} ' | tr -d @ | xargs rmUna vez que haya instalado Python y
pip, necesitará instalar una dependencia para que las funciones de la línea de comandos de Flask-BDA se ejecuten correctamente:
pip install click
Otras dependencias que quizás quieras instalar globalmente (pero que deberían ejecutarse automáticamente cuando crees un proyecto) incluyen:
pip install virtualenv
pip install flaskwebgui
pip install pyinstaller
Para comenzar a construir su primer proyecto con Flask-BDA, siga los sencillos pasos a continuación para crear su propio entorno de desarrollo preconfigurado y funcionando en minutos.
En este inicio rápido, crearemos un proyecto llamado
"My Awesome Project". Sin embargo, puedes llamar al proyecto como quieras.
create_project.py requerido y lo ejecutará para ayudarlo a iniciar un proyecto."My Awesome Project" curl -L https://raw.githubusercontent.com/RyanJulyan/Flask-BDA/main/create_project_git.py --ssl-no-revok -o create_project_git.py
python create_project_git.py --project= " My Awesome Project "
create_project.py requerido y lo ejecutará para ayudarlo a iniciar un proyecto."My Awesome Project" curl -L https://raw.githubusercontent.com/RyanJulyan/Flask-BDA/main/create_project_git.py --ssl-no-revok -o create_project_git.py
python create_project_git.py --project= " My Awesome Project "
Nota: Si no completó un nombre de proyecto válido, se le pedirá que lo haga:
- Complete el nombre de su proyecto cuando se le solicite, por ejemplo:
- Asegúrese de incluir comillas alrededor del nombre de su proyecto para evitar errores, por ejemplo:
"My Awesome Project"
Invalid Project Name !
Please enter a valid project name :
"My Awesome Project"Nota: Notarás que esto crea una carpeta en la misma ruta que el archivo: "create_project_git.py". Esta carpeta estará en minúsculas y se eliminarán todos los caracteres especiales y se reemplazarán los espacios con guiones bajos, por ejemplo:
my_awesome_project
Nota: Durante el desarrollo, es posible que desee utilizar otra rama o repositorio por completo. Esto puede ayudar con las pruebas o si se ha separado del proyecto principal Flask-BDA.
- Puede especificar el
Owner,RepoyBranchal crear un nuevo proyecto.
curl - L https : // raw . githubusercontent . com / RyanJulyan / Flask - BDA / RyanJulyan - Dev / create_project_git . py - - ssl - no - revok - o create_project_git . py
python create_project_git . py - - project = "My Awesome Project" - - owner = "RyanJulyan" - - repo = "Flask-BDA" - - branch = "RyanJulyan-Dev" - - create_venv = TrueNota: ¡Aún debe probarse para todos los tipos de conexión!
Las conexiones de bases de datos son rápidas y sencillas en Flask-BDA. Puede tener 1 o varias bases de datos, y diferentes inquilinos pueden tener sus propias conexiones de base de datos, así como su propio tipo de base de datos (SQLite, MySQL, SQL Server, PostgreSQL).
De forma predeterminada, Flask-BDA tiene configurada una base de datos SQLite. En realidad, esto se debe a que no requiere infraestructura adicional para configurarlo y ponerlo en marcha, lo que hace de SQLite una opción rápida y sencilla.
Para cambiar la base de datos predeterminada:
flaskbda ), usuario ( flaskbda_user ) y contraseña ( password )config.pyDATABASE_ENGINE para SQLite y comente en mysql DATABASE_ENGINE .DATABASE_NAME para SQLite y comente en mysql:DATABASE_HOSTDATABASE_PORTDATABASE_USERNAMEDATABASE_PASSWORDDATABASE_NAMESQLALCHEMY_DATABASE_URI para SQLite y comente en mysql SQLALCHEMY_DATABASE_URI . ##########
# SQLite #
##########
# DATABASE_ENGINE = 'sqlite:///'
# DATABASE_NAME = os.path.join(BASE_DIR, 'databases/sqlite/default.db')
# SQLALCHEMY_DATABASE_URI = DATABASE_ENGINE + DATABASE_NAME
#########
# MySQL #
#########
DATABASE_ENGINE = 'mysql://'
DATABASE_HOST = ''
DATABASE_PORT = '1433'
DATABASE_USERNAME = ''
DATABASE_PASSWORD = ''
DATABASE_NAME = ''
SQLALCHEMY_DATABASE_URI = DATABASE_ENGINE + DATABASE_USERNAME + ':' + DATABASE_PASSWORD + '@' + DATABASE_HOST + ':' + DATABASE_PORT + '/' + DATABASE_NAME
DATABASE_HOSTDATABASE_PORTDATABASE_USERNAMEDATABASE_PASSWORDDATABASE_NAME DATABASE_HOST = 'localhost'
DATABASE_PORT = '3306'
DATABASE_USERNAME = 'flaskbda_user'
DATABASE_PASSWORD = 'password'
DATABASE_NAME = 'flaskbda' Para cambiar la base de datos predeterminada:
flaskbda ), usuario ( flaskbda_user ) y contraseña ( password )config.pyimport pyodbc SQLServer.DATABASE_DRIVER .DATABASE_ENGINE para SQLite y, por ejemplo, comente en SQLServer DATABASE_ENGINE .DATABASE_NAME para SQLite y comente en SQLServer:DATABASE_HOSTDATABASE_PORTDATABASE_USERNAMEDATABASE_PASSWORDDATABASE_NAMESQLALCHEMY_DATABASE_URI para SQLite y comente en el try y except SQLServer SQLALCHEMY_DATABASE_URI .Nota: si está ejecutando e intentando conectarse a
SQLEXPRESS. Descomente la variableSQLEXPRESSde SQLServer. Esto se manejará en eltryyexceptpara crear elSQLALCHEMY_DATABASE_URIcorrecto
Nota: si desea autenticación de Windows. Descomente la variable
TRUSTED_CONNECTIONde SQLServer. Esto se manejará en eltryyexceptpara crear elSQLALCHEMY_DATABASE_URIcorrecto
##########
# SQLite #
##########
# DATABASE_ENGINE = 'sqlite:///'
# DATABASE_NAME = os.path.join(BASE_DIR, 'databases/sqlite/default.db')
# SQLALCHEMY_DATABASE_URI = DATABASE_ENGINE + DATABASE_NAME
#############
# SQLServer #
#############
import pyodbc # noqa: E402
DATABASE_ENGINE = 'mssql+pyodbc://'
# SQLEXPRESS = '\SQLEXPRESS' # for SQLEXPRESS
# TRUSTED_CONNECTION = 'yes' # for windows authentication.
DATABASE_DRIVER = 'SQL+Server+Native+Client+11.0' # for windows authentication.
DATABASE_HOST = ''
DATABASE_PORT = '1433'
DATABASE_USERNAME = ''
DATABASE_PASSWORD = ''
DATABASE_NAME = ''
try :
if SQLEXPRESS == ' \ SQLEXPRESS' :
try :
if TRUSTED_CONNECTION == 'yes' :
SQLALCHEMY_DATABASE_URI = DATABASE_ENGINE + DATABASE_HOST + ':' + DATABASE_PORT + SQLEXPRESS + '/' + DATABASE_NAME + '?trusted_connection=' + TRUSTED_CONNECTION + '&driver=' + DATABASE_DRIVER
else :
SQLALCHEMY_DATABASE_URI = DATABASE_ENGINE + DATABASE_USERNAME + ':' + DATABASE_PASSWORD + '@' + DATABASE_HOST + ':' + DATABASE_PORT + SQLEXPRESS + '/' + DATABASE_NAME + '&driver=' + DATABASE_DRIVER
except NameError :
SQLALCHEMY_DATABASE_URI = DATABASE_ENGINE + DATABASE_USERNAME + ':' + DATABASE_PASSWORD + '@' + DATABASE_HOST + ':' + DATABASE_PORT + SQLEXPRESS + '/' + DATABASE_NAME + '&driver=' + DATABASE_DRIVER
except NameError :
try :
if TRUSTED_CONNECTION == 'yes' :
SQLALCHEMY_DATABASE_URI = DATABASE_ENGINE + DATABASE_HOST + ':' + DATABASE_PORT + '/' + DATABASE_NAME + '?trusted_connection=' + TRUSTED_CONNECTION + '&driver=' + DATABASE_DRIVER
else :
SQLALCHEMY_DATABASE_URI = DATABASE_ENGINE + DATABASE_USERNAME + ':' + DATABASE_PASSWORD + '@' + DATABASE_HOST + ':' + DATABASE_PORT + SQLEXPRESS + '/' + DATABASE_NAME + '&driver=' + DATABASE_DRIVER
except NameError :
SQLALCHEMY_DATABASE_URI = DATABASE_ENGINE + DATABASE_USERNAME + ':' + DATABASE_PASSWORD + '@' + DATABASE_HOST + ':' + DATABASE_PORT + '/' + DATABASE_NAME + '&driver=' + DATABASE_DRIVER
DATABASE_HOSTDATABASE_PORTDATABASE_USERNAMEDATABASE_PASSWORDDATABASE_NAME DATABASE_HOST = 'MSSQLSERVER'
DATABASE_PORT = '1433'
DATABASE_USERNAME = 'flaskbda_user'
DATABASE_PASSWORD = 'password'
DATABASE_NAME = 'flaskbda'Asegúrese de que su instancia de MS-SQL tenga derechos de conexión remota configurados y referencia habilitada (aquí)[https://knowledgebase.apexsql.com/configure-remote-access-connect-remote-sql-server-instance-apexsql-tools/ ]:
Asegúrese de que los ajustes de "Administración de configuración del servidor SQL" estén configurados correctamente
NOTA: Su instalación requerirá
Client Tools Connectivity; si no puede encontrar "Administración de configuración del servidor SQL", es posible que deba modificar su instalación para incluirClient Tools Connectivity
- Si no puede encontrar "", es posible que deba utilizar la herramienta "Usar la administración de computadoras". para acceder a él.
- esto parece ser un problema de Windows 10
Multitenancy es una arquitectura de software en la que una única instancia de software se ejecuta en un servidor y sirve a varios inquilinos (clientes). El software multiinquilino permite que varias instancias independientes de una o varias aplicaciones operen en un entorno compartido.
Flask-BDA admite multiinquilino con particiones verticales. La partición vertical significa que cada inquilino tiene una base de datos diferente (y una cadena de conexión de base de datos).
De forma predeterminada, Flask-BDA se conecta a un inquilino llamado
default. Esto se hace utilizando el objetoSQLALCHEMY_BINDS(que se encuentra enconfig.py), que debe tener los detalles de conexión específicos que necesita para cada inquilino. Los detalles de conexión predeterminados se combinan en una cadena llamadaSQLALCHEMY_DATABASE_URI, que estaba destinada a permitir una configuración rápida y sencilla de un solo inquilino.
Puede utilizar esta misma estructura; sin embargo, para tener varios inquilinos, puede agregarlos rápidamente al objeto
SQLALCHEMY_BINDS. Para agregar un nuevo inquilino, simplemente:
SQLALCHEMY_BINDS , con el nombre del inquilino y los detalles de la cadena de conexión. SQLALCHEMY_BINDS = {
"default" : SQLALCHEMY_DATABASE_URI ,
"client1" : 'sqlite:///databases/sqlite/client1.db' ,
}Ahora puede interactuar con una base de datos de inquilinos aislada agregando el argumento
organization=a su URL, por ejemplo:example.com?organization=client1dondeclient1es el nombre que agregó en el objetoSQLALCHEMY_BINDS.
Esto funciona interceptando
@app.before_requestenapp/_init_.pyy cambiando el enlace del motor de base de datos usandodb.choose_tenant(g.organization)desdeapp/mod_tenancy/multi_tenant.pyusando la variable globalg.organizationque obtiene se establece obteniendo el argumento URLorganization. Esto permite que la base de datos de cada inquilino utilice el mismo código en la aplicación mientras se mantienen los datos separados.
A veces es necesario interactuar con diferentes bases de datos en una sola función (especialmente al integrar sistemas o leer datos de diferentes fuentes).
De forma predeterminada, todos los controladores tendrán
MultiBindSQLAlchemyimportado.
# import multiple bindings
from app . mod_tenancy . multi_bind import MultiBindSQLAlchemyDebajo de la importación hay un código comentado destinado a ayudarle a implementar rápidamente enlaces a diferentes bases de datos en una sola función. En primer lugar, es necesario agregar el enlace de la base de datos al objeto
SQLALCHEMY_BINDS. Consulte las bases de datos aisladas con la misma funcionalidad para comprender mejor cómo agregar nuevas bases de datos al objetoSQLALCHEMY_BINDS.
Luego puede crear un nuevo objeto adjunto al objeto
dbsiguiendo la estructura dedb.<binding>por ejemplo:db.firstdondefirstes el nombre al que desea hacer referencia el enlace en el resto del código. Luego puede asignar esta variable aMultiBindSQLAlchemy, por ejemplo:db.first = MultiBindSQLAlchemy('first').
Esto ahora le permite llamar a un código personalizado que le permitirá acceder al nuevo enlace de la base de datos, así como al inquilino principal en una sola función, por ejemplo:
db.first.execute(...), donde puede ejecutar código SQL sin formato.
db . first = MultiBindSQLAlchemy ( 'first' )
##################################################
## this will only work for the execute function ##
##################################################
db . first . execute (...)**Nota: ** esto solo funcionará para la función
execute, existen algunas técnicas avanzadas para seguir usando el ORM de SQLAlchemy que se pueden encontrar aquí: Tutorial de ejecución de SQLAlchemy
Un módulo es un componente autónomo, lo que facilita su administración a medida que crece el programa. Los módulos en Flask-BDA lo ayudan a crear: un modelo de datos, rutas y funciones asociadas para controlar la lógica y las vistas.
Cuando crea un nuevo módulo CRUD, todos los elementos de la carpeta
create_module_templatese copian en el directorio de la aplicación y se les cambia el nombre al nombre del módulo que proporciona reemplazando todos los valoresxyzcon el nombre de su módulo y agregando información adicional del modelo de datos como se describe a continuación.
<Path To>/<my_awesome_project>/create_module_json.py<Path To>/<my_awesome_project>/ es la ruta al proyecto que creaste cd < Path To > / < my_awesome_project > /
python create_module_json . py - - module = Projects Create new field Name (type the string : 'STOP_CREATING_FIELDS' to exit ): "name"
What datatype is name
Choose one of the following options
( 'String'
, 'Int'
, 'Float'
, 'Numeric'
, 'Text'
, 'Date'
, 'DateTime'
, 'Boolean'
, 'BigInt'
, 'Enum'
, 'JSON'
, 'LargeBinary' ): "String"
String Length ( 1 - 256 ): 256
Is name nullable ( 'True' , 'False' ): False
Is name unique ( 'True' , 'False' ): True
Does the name have a Relationship with another Data Model ? ( 'True' , 'False' ): False
Default value : Nota: Esto seguirá repitiéndose hasta que escriba y envíe las palabras exactas: "STOP_CREATING_FIELDS".
Esto le permite crear múltiples campos para su módulo de forma rápida y sencilla.
Los campos anteriores deberían mostrar que diferentes tipos de campos interactúan y crean múltiples campos.
Nota: Las relaciones siempre se realizarán según la
iddel modelo proporcionado.Se crea una ForeignKey en el campo, así como una relación diferida entre el campo
idproporcionado por el modelo.
Create new field Name (type the string : 'STOP_CREATING_FIELDS' to exit ): STOP_CREATING_FIELDS Create module logic from Data Model ? ( 'True' , 'False' ): TrueNota: también puede generar un módulo a partir de un archivo JSON en "app/generated_config/models//models.json", donde está el nombre del módulo que ingresa para hacer esto. Puede abrir y ejecutar el archivo:
<Path To>/<my_awesome_project>/create_module.py* Donde<Path To>/<my_awesome_project>/es la ruta al proyecto que creaste * Complete las instrucciones, por ejemplo:
cd < Path To > / < my_awesome_project > /
python create_module . py - - module = projectsEsto luego creará los archivos y carpetas necesarios como se describe a continuación en los cambios de la aplicación.
Los archivos y carpetas de la carpeta
create_module_templatese crean para el móduloProjectsy luego se agregan a la carpetaapp.Esto creará vistas CRUD de administrador con scaffolding, una API REST (con inserción y actualización masiva), una API GraphQL y vistas y lógica públicas que le permitirán interactuar inmediatamente con el módulo que creó.
Desde el panel de administración, podrá realizar las siguientes acciones: Crear, Leer, Actualizar y Eliminar ("CRUD") para su nuevo módulo.
Las vistas públicas permiten a los usuarios invitados (usuarios que no han iniciado sesión) ver una vista de la información proporcionada.
└── `my_awesome_project`
└── app
├── generated_config
│ └── models
│ └── `projects`
│ └── models.json
└── `mod_projects`
├── templates
│ ├── mobile
│ │ └── `projects`
│ │ ├── admin
│ │ │ ├── create.html
│ │ │ ├── edit.html
│ │ │ ├── index.html
│ │ │ └── show.html
│ │ └── public
│ │ └── public_list.html
│ └── `projects`
│ ├── admin
│ │ ├── create.html
│ │ ├── edit.html
│ │ ├── index.html
│ │ └── show.html
│ └── public
│ └── public_list.html
├── api_controllers.py
├── controllers.py
├── forms.py
├── models.py
└── types.py
La creación de un nuevo módulo le proporcionará tres formas de interactuar con su nuevo sistema
Public,Admin,REST APIyGraphQL API.
Para acceder a ellos, necesitarán que la aplicación se ejecute en un entorno.
La vista
Publices una vista no autenticada de los datos proporcionados en el módulo.
xyz es el nombre del módulo):../xyz/public_list Las vistas
Adminson vistas autenticadas de los datos proporcionados en el módulo.
xyz es el nombre del módulo):../admin/xyz/index../admin/xyz/createcreate../admin/xyz/storestore../admin/xyz/show/{id}show../admin/xyz/edit/{id}edit../admin/xyz/update/{id}update../admin/xyz/destroy/{id}destroy Las vistas
APIson una lista de puntos finales de API REST, documentación asociada y área de ejecución.
Flask BDA utiliza SwaggerUI para presentar la API REST a un usuario/cliente.
SwaggerUI permite que cualquier persona, ya sea su equipo de desarrollo o sus consumidores finales, visualice e interactúe con los recursos de la API sin tener implementada ninguna lógica de implementación. En cambio, se genera automáticamente a partir de la especificación OpenAPI (anteriormente conocida como Swagger), con documentación visual que facilita la implementación back-end y el consumo del lado del cliente.
Para acceder a SwaggerUI:
<base_URL>/api/docs para acceder a la API REST de SwaggerUI, por ejemplo: http://localhost:5000/api/docs .Para acceder a la API REST sin SwaggerUI:
<base_URL>/../api/xyzXyzListResource > get../api/xyzXyzListResource > post../api/xyz/{id}XyzResource > get../api/xyz/{id}XyzResource > update../api/xyz/{id}XyzResource > delete../api/xyz/bulkXyzBulkListResource > post../api/xyz/bulkXyzBulkListResource > update../api/xyz/aggregateXyzAggregateResource > get Las vistas
graphqlson vistas GraphiQL, puntos finales API, documentación asociada y área de ejecución.
Flask BDA utiliza grafeno-python y GraphiQL para presentar la API GraphQL a un usuario/cliente, proporcionando una API simple pero extensible para facilitar la vida de los desarrolladores.
GraphQL es un lenguaje de consulta de datos que proporciona una alternativa a las arquitecturas de servicios web REST y ad-hoc.
Para acceder a GraphiQL:
<base_URL>/graphql para acceder a GraphiQL, GraphQL API, por ejemplo: http://localhost:5000/graphql .Para acceder a la API GraphQL sin GraphiQL:
<base_URL>/../graphqlmod_graphql > query > Query > all_xyz../graphqlmod_graphql > mutation > Mutation > createXyz Actualmente hay 7 entornos compatibles (con planes para que se admitan más pronto) con instrucciones sobre cómo configurar cada uno para Windows / Linux / Mac , y puede ejecutarlos al mismo tiempo si lo desea.
Para crear y desarrollar una aplicación local, utilizamos virtualenv. Una herramienta para crear entornos virtuales aislados de Python.
pip install --upgrade pipcd <Path To>/my_awesome_project cd < Path To > /my_awesome_project
pip install --upgrade pip
pip install virtualenv
virtualenv venv
venv S cripts a ctivate
pip install --upgrade pip
pip install --no-cache-dir -r requirements.txt
set FLASK_APP=app
set FLASK_ENV=development
flask run --port 5000
pip install --upgrade pipsudo , por ejemplo: sudo pip install --upgrade pip cd < Path To > /my_awesome_project
pip install --upgrade pip
pip install virtualenv
virtualenv venv
source venv/bin/activate
pip install --upgrade pip
pip install --no-cache-dir -r requirements.txt
export FLASK_APP=app
export FLASK_ENV=development
flask run --port 5000
Algunos servicios de alojamiento compartido ofrecen la posibilidad de ejecutar aplicaciones Python en sus servidores. Yo personalmente he utilizado A2hosting. Su soporte ha sido increíble y el precio de las funciones es uno de los mejores que he encontrado.
Nota: No está limitado a A2 como opción de alojamiento compartido. Sin embargo, aquí es donde probé Flask-BDA y tengo experiencia en cargar y ejecutar una opción de alojamiento compartido. Si su opción de alojamiento compartido ofrece un conjunto similar de funciones, no dude en utilizarlas.
Para A2, necesitará configurar su servidor para ejecutar una aplicación Python que puede requerir alguna configuración, por ejemplo.
Para que su aplicación personalizada funcione:
Nota: En un entorno
Linuxel requisitopyodbcno funcionará de forma predeterminada. Debido a esto, y al ser un entorno compartido, es posible que no tenga derechos para agregar los requisitos para que funcione, la forma más fácil de garantizar que la instalación no falle es comentar este requisito en el servidor.
requirements.txt , busque pyodbc y coloque un # con un espacio antes del nombre del paquete. # pyodbc==4.0.30
requirements.txtSSH en la que inició sesión en el paso anterior pip install --upgrade pip
pip install --no-cache-dir -r requirements.txt
Setup Python App nuevamenteApplication startup file a run_shared_server.pyPara crear e implementar una aplicación en contenedores, utilizamos Docker, que ayuda a los desarrolladores y equipos de desarrollo a crear y enviar aplicaciones. Además, Docker se utiliza para crear y compartir aplicaciones y microservicios en contenedores.
Nota: Si está utilizando Github y tiene Docker instalado (los detalles sobre cómo instalarlo se encuentran más adelante en la documentación), obtendrá una nueva imagen creada cada vez que
pusho realice unapull_requesten Github, que se configura en el archivo:docker-image.ymlsin embargo, si desea hacer esto manualmente, siga los pasos a continuación:
cd < Path To > /my_awesome_project
docker build -t flask_app:latest .
docker run -p 5000:5000 flask_app
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh
systemctl start docker
cd < Path To > /my_awesome_project
docker build -t flask_app:latest .
docker run -it -p 5000:5000 flask_app
Nota: Aún en desarrollo
Para crear e implementar una aplicación sin servidor, utilizamos The Serverless Framework, que permite un desarrollo sin servidor sin fricción, lo que le permite crear fácilmente aplicaciones que se escalan automáticamente en una infraestructura de nube de próxima generación y de bajo costo.
El marco Serverless es una herramienta de código abierto que proporciona un desarrollo e implementación sencillos de YAML + CLI en AWS, Azure, Google Cloud, Knative y más.
Nota: Es posible que deba ajustar las cadenas de la base de datos predeterminada antes de del=polying, ya que la tecnología sin servidor no admite "SQLite" ya que la función no mantiene el estado.
Para actualizar las cadenas de la base de datos, consulte [Configuración]
npm update -g serverless
npm update -g serverless
choco install serverless
Nota: Si el paquete no se instala, es posible que deba ejecutar el comando como administrador.
presione la "tecla Windows", escriba "cmd", "clic derecho" en la palabra "Símbolo del sistema" y seleccione la opción "Ejecutar como administrador" y luego siga los pasos anteriores nuevamente
serverless
cd < Path To > /my_awesome_project
sls plugin install -n serverless-python-requirements
sls plugin install -n serverless-wsgi
serverless deploy
curl -o- -L https://slss.io/install | bash
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh
systemctl start docker
cd < Path To > /my_awesome_project
sls plugin install -n serverless-python-requirements
sls plugin install -n serverless-wsgi
serverless deploy
Nota: Aún en desarrollo
Digital Ocean es una plataforma como servicio (PaaS). Desarrolle, administre y escale sus aplicaciones en la completa plataforma en la nube de DigitalOcean. Digital Ocean le ofrece precios simples y predecibles. Cree y publique con confianza con productos informáticos escalables en la nube, bases de datos totalmente administradas, opciones de almacenamiento escalables y de alta disponibilidad, y más. Con máquinas virtuales con una buena cantidad de memoria adaptadas para alojar y escalar aplicaciones y bases de datos, Digital Ocean ofrece soluciones simples para problemas complejos.
Para crear e implementar una aplicación en Heroku desde la terminal, necesitará:
138.197.67.25NOTA: si no se ha conectado a través de SSH, debe recibir la
passworda través del correo electrónico con el que registró la cuenta, para Digital Ocean.
cd < Path To > / < my_awesome_project > /
scp -r < my_awesome_project > root@ < ip_address > :/
ssh root@ < ip_address >
Donde
<Path To>/<my_awesome_project>/es la ruta al proyecto que creó y donde<ip_address>son los droplets <ip_address>, por ejemplo:138.197.67.25
Nota: Siga cualquier indicación presente el SSH, como permitir el acceso desde el servidor remoto.
Una vez que haya iniciado sesión, debería poder ver un terminal con:
root@ < droplet_name > :
cd < Path To > / < my_awesome_project > /
chmod +x setup.sh
bash setup.sh
virtualenv venv
source venv/bin/activate
sudo pip install --upgrade pip
sudo pip install --no-cache-dir -r requirements.txt
sudo pip install uwsgi
sudo ufw allow 5000
export FLASK_APP=app
uwsgi --socket 0.0.0.0:5000 --protocol=http -w wsgi:app
Donde
5000es el número de puerto
y<droplet_name>es el nombre
cd < Path To > / < my_awesome_project > /
scp -r < my_awesome_project > root@ < ip_address > :/
ssh root@ < ip_address >
Donde
<Path To>/<my_awesome_project>/es la ruta al proyecto que creó y donde<ip_address>es las gotas <Ip_address> EG:138.197.67.25
Nota: Siga cualquier indicación presente el SSH, como permitir el acceso desde el servidor remoto.
Una vez que haya iniciado sesión, debería poder ver un terminal con:
root@ < droplet_name > :
cd < Path To > / < my_awesome_project > /
chmod +x setup.sh
bash setup.sh
virtualenv venv
source venv/bin/activate
sudo pip install --upgrade pip
sudo pip install --no-cache-dir -r requirements.txt
sudo pip install uwsgi
sudo ufw allow 5000
export FLASK_APP=app
uwsgi --socket 0.0.0.0:5000 --protocol=http -w wsgi:app
Donde
5000es el número de puerto
y<droplet_name>es el nombre
Nota: Todavía en desarrollo
Heroku es una plataforma como servicio (PAAS). Heroku le permite comenzar con cero compromiso, pagar a medida que no se bloquea. Los desarrolladores, equipos y empresas de todos los tamaños pueden usar Heroku para implementar, administrar y escalar aplicaciones. Ya sea que esté construyendo un prototipo simple o un producto crítico de negocios, la plataforma totalmente administrada de Heroku le brinda una ruta simple para entregar aplicaciones rápidamente.
Para crear e implementar una aplicación en Heroku desde el terminal, deberá descargar e instalar el Heroku CLI. Para verificar la instalación, puede verificar la versión de Heroku desde el terminal:
heroku --version
Nota: Asegúrese de haber cambiado la conexión de su base de datos, ya que Heroku no sugiere usar SQLite, ya que los datos pueden perderse en los archivos. Heroku ofrece una base de datos gratuita de Postgres. Vea sus planes y elija el plan adecuado para usted, ya que hay límites en los diferentes planes.
cd < Path To > /my_awesome_project
heroku login
<my_awesome_project-flask-bda-app> , donde <my_awesome_project-flask-bda-app> es el nombre que le dio a su proyecto.heroku create my_awesome_project-flask-bda-app
git push heroku master
<my_awesome_project-flask-bda-app> es el nombre que le dio a su proyecto. cd < Path To > /my_awesome_project
sudo snap install --classic heroku
heroku login
<my_awesome_project-flask-bda-app> , donde <my_awesome_project-flask-bda-app> es el nombre que le dio a su proyecto.heroku create my_awesome_project-flask-bda-app
git push heroku master
<my_awesome_project-flask-bda-app> es el nombre que le dio a su proyecto. cd < Path To > /my_awesome_project
brew tap heroku/brew && brew install heroku
heroku login
<my_awesome_project-flask-bda-app> , donde <my_awesome_project-flask-bda-app> es el nombre que le dio a su proyecto.heroku create my_awesome_project-flask-bda-app
git push heroku master
<my_awesome_project-flask-bda-app> es el nombre que le dio a su proyecto. Para aplicaciones móviles nativas, estamos usando React-Native. Específicamente, utilizamos Expo como marco y una plataforma para aplicaciones React Universal. Es un conjunto de herramientas y servicios creados en torno a las plataformas reaccionadas nativas y nativas que lo ayudan a desarrollar, construir, implementar e iterar rápidamente en aplicaciones iOS, Android y web de la misma base de código JavaScript/TypeScript.
Tenemos notificaciones push previas pre-set, por lo que no tiene que hacerlo. Esto significa que es más rápido y más fácil para usted comenzar y correr en funcionamiento. Además, estamos aprovechando el paquete predeterminado de Notificaciones de Expo que permite una implementación y un enfoque simplificados.
Las ventajas incluyen flujos/procesos de trabajo de compilación y prueba más rápidos, pruebas remotas mientras se desarrollan con actualizaciones de aire (OTA) con cambios visibles para guardar durante el desarrollo.
Sin embargo, hay algunas desventajas y limitaciones que Expo es consciente de esto y las describe bastante bien. Sugerimos revisar estas limitaciones antes de usar nuestro método preconstruido.
Cree un proyecto que se ejecute de forma nativa en todos los dispositivos de sus usuarios.
cd < Path To > /my_awesome_project_mobile_app
npm install -g expo-cli
npm install
cd < Path To > /my_awesome_project_mobile_app
npm install -g expo-cli
npm install
Debido a que Flask BDA no dicta dónde debe alojar su sitio web, deberá decirle a su aplicación móvil a dónde ir.
En el ejemplo rápido, creamos un proyecto llamado
"My Awesome Project". Sin embargo, es posible que haya llamado al proyecto algo más. Esto habría creado una carpeta donde el nombre está todo en minúsculas y ha eliminado todos los caracteres especiales, y reemplazado espacios con guiones bajos, por ejemplo:my_awesome_project.
Para los dispositivos móviles, habremos creado automáticamente una carpeta
"_mobile_app"separada donde el prefijo de la carpeta es el nombre de su proyecto, por ejemplo,my_awesome_project_mobile_app. Esto es para evitar problemas con elpackage.jsonde configuraciónServerlessy permitirle no implementar todo el código para una aplicación móvil en su servidor web.
Si todavía está en desarrollo y/o no ha elegido un proveedor de servicios para alojar todavía, puede usar: NGROK para crear una URL de desarrollo público temporal que tunga a su entorno local. Ngrok expone servidores locales detrás de NATS y firewalls a Internet público a través de túneles seguros. Esto le permite demostrar sitios web en una URL pública y probar aplicaciones móviles conectadas a su backend de ejecución local sin implementar.
Inicie el servidor de desarrollo local siguiendo las instrucciones de entorno local
Si no se ha registrado para NGROK antes:
Si ya se ha registrado pero no lo tiene instalado:
Una vez que el terminal NGROK esté abierto, cree un túnel desde su servidor local a Ngrok
5000 predeterminado, reemplace el número después de http para permitir que se cree el túnel correcto. ngrok http 5000
ngrok by @inconshreveable
(Ctrl+C to quit)
Session Status online
Session Expires 1 hour, 59 minutes
Version 2.3.40
Region United States (us)
Web Interface http://127.0.0.1:4040
Forwarding http://573d4ec93267.ngrok.io - > http://localhost:5000
Forwarding https://573d4ec93267.ngrok.io - > http://localhost:5000
Connections
ttl opn rt1 rt5 p50 p90
0 0 0.00 0.00 0.00 0.00
Nota: La versión gratuita solo mantiene en vivo este servidor durante 2 horas, por lo que es posible que deba seguir este proceso en el futuro, y si impulsa esta URL a su "repositorio", es posible que no funcione para la próxima persona.
my_awesome_project_mobile_appapp.json y edite la línea 2 "server_base_url": "https://github.com/RyanJulyan/Flask-BDA" reemplazando https://github.com/RyanJulyan/Flask-BDA con su propio Nombre del servidor.expo en su propio teléfono móvil buscando "Expo" en la tienda Apple o Google Play:iOS ir a: https://apps.apple.com/app/apple-store/id982107779Android Vaya a: https://play.google.com/store/apps/details?id=host.exp.exponentUna vez que tenga la aplicación instalada en su teléfono, puede iniciar un servidor de desarrollo en su máquina local.
cd < Path To > /my_awesome_project_mobile_app
expo start
cd < Path To > /my_awesome_project_mobile_app
expo start
Esto abrirá una página web con un código QR. Esto le permitirá usar la aplicación Expo si está en Android o usar la cámara si está en iOS para escanear el código y abrir su aplicación directamente desde el servidor de desarrollo.
Nota: Si desea que las personas que no están en su red puedan escanear y probar la aplicación de forma remota, presione el botón de la pestaña
tunnelsobre el código QR.
Parte de las recomendaciones es garantizar que las imágenes estén optimizadas. Para hacer esto, Expo ha recomendado el paquete Expo-Optimize que puede ayudar a optimizar las imágenes. Además, la optimización de imágenes puede mejorar su aplicación nativa TTI (o tiempo de interacción), lo que significa menos tiempo en pantallas de salpicaduras y una entrega más rápida a través de malas conexiones de red.
cd < Path To > /my_awesome_project_mobile_app
npm install -g sharp-cli
npx expo-optimize --quality 0.9
cd < Path To > /my_awesome_project_mobile_app
npm install -g sharp-cli
npx expo-optimize --quality 0.9
Para crear y desarrollar una aplicación de escritorio, estamos utilizando FlaskWebGui. Una herramienta para crear y ejecutar su aplicación web Flask en un envoltorio Chrome. Para distribuir la aplicación de escritorio, estamos utilizando PyInstaller. Pyinstaller congela (paquetes) Aplicaciones Python en ejecutables independientes en Windows, GNU/Linux, Mac OS X, FreeBSD, Solaris y AIX.
Cada implementación debe crearse en la plataforma específica que desea ejecutarla. Hemos creado scripts que le permitirán administrar estas implementaciones colocando las carpetas
buildanddisten las carpetas principales para la plataforma respectiva. Estas carpetas se prefijan condesktop_seguido de la plataforma. Esto se hace exclusivamente para permitirle administrar los procesos de distribución y construcción para las plataformas específicas y no sobrescribirlos cuando se construye en diferentes plataformas.
Para permitir que la exportación al escritorio funcione correctamente, requerimos algunos cambios en el código. Por defecto, Flask-BDA está destinado al desarrollo web y móvil, y hemos implementado un limitador de velocidad en el sitio. Desafortunadamente, necesita un servidor para calificar el límite, y dado que está exportando el sistema a una aplicación de escritorio, no está ejecutando un servidor.
Como tal, debe eliminar todas las referencias al limitador. Estos se pueden encontrar en
app/__init__.py. Para hacer esto, abra el archivo en un editor de texto y comente las siguientes líneas:
# from flask_limiter import Limiter
# from flask_limiter.util import get_remote_address
# limiter = Limiter(
# app,
# key_func=get_remote_address,
# default_limits=app.config['DEFAULT_LIMITS']
# )Nota: Si agregó un limitador personalizado, busque
@limiter.limit, que se encontraría en sus controladores. Deberá comentar todas esas referencias y las referencias de importación, por ejemplo:from app import limiter
Esto le permitirá exportar la aplicación como un archivo ejecutable de escritorio sin errores.
pip install --upgrade pipcd <Path To>/my_awesome_project cd < Path To > /my_awesome_project
pip install --upgrade pip
pip install virtualenv
virtualenv venv
venv S cripts a ctivate
pip install --upgrade pip
pip install --no-cache-dir -r requirements.txt
python create_desktop_installer_windows.py
pip install --upgrade pipsudo , por ejemplo, sudo pip install --upgrade pip cd < Path To > /my_awesome_project
pip install --upgrade pip
pip install virtualenv
virtualenv venv
source venv/bin/activate
pip install --upgrade pip
pip install --no-cache-dir -r requirements.txt
python create_desktop_installer_lunix.py
pip install --upgrade pipsudo , por ejemplo, sudo pip install --upgrade pip cd < Path To > /my_awesome_project
pip install --upgrade pip
pip install virtualenv
virtualenv venv
source venv/bin/activate
pip install --upgrade pip
pip install --no-cache-dir -r requirements.txt
python create_desktop_installer_mac.py
Esto abrirá una ventana maximizada que se ejecutará como una aplicación de escritorio normal. Esto utilizará el navegador Chrome instalado localmente para servir al contenido.
Por defecto, esta aplicación se servirá en el puerto
7000. Sin embargo, puede editar el puerto en el archivorun_desktop.pysi eso entra en conflicto con cualquier aplicación existente.
Si incluye paquetes adicionales de Python en su proyecto, no olvide ejecutar
pip freezedesde su terminal para asegurarse de obtener los paquetes correctos para sus implementaciones
pip freeze > requirements.txt
Nota: Se sugiere que instale y congele paquetes de Python adicionales de un entorno virtual en lugar de a nivel mundial. Esto mantiene sus
requirements.txtTXT pequeño y limitado a los paquetes que está utilizando en su proyecto específico.
Flask BDA usa Swaggerui de forma predeterminada para ayudar y presentar la API a un usuario/cliente.
Swaggerui permite que cualquiera, ya sea su equipo de desarrollo o sus consumidores finales, visualizar e interactuar con los recursos de la API sin tener ninguna de la lógica de implementación en su lugar. En cambio, se genera automáticamente a partir de su especificación OpenAPI (anteriormente conocida como Swagger), con la documentación visual que facilita la implementación de fondo y el consumo del lado del cliente.
Para acceder al swaggerui:
<base_URL>/api/docs para acceder a la API Swaggerui, por ejemplo: http://localhost:5000/api/docsMuchos desarrolladores preferirán Postman sobre Swaggerui para probar e integrar API con su código. Hemos ayudado proporcionando una exportación de colección directa para Postman.
Para importar la colección en Postman:
Import... (Ctrl+O)Link desde las pestañas<base_URL>/api/postman EG: http://localhost:5000/api/postman<base_URL>/aswagger.json , por ejemplo, http://localhost:5000/swagger.json e importarlo directamente a Postmanhttps://learning.postman.com/docs/getting-started/importing-and-exporting-data/#converting-postman-collections-from-v1-to-v2 npm install -g postman-collection-transformer
postman-collection-transformer convert -i <path to the input Postman collection file> -o <path to the downloaded Postman file> -j 1.0.0 -p 2.0.0 -P
<path to the input Postman collection file> y <path to the downloaded Postman file> son rutas de archivo físico en su máquina local.ContinueImportEsto importará una colección Postman que estará disponible en el lado izquierdo como una carpeta (con subcarpetas de cada uno de los puntos finales que creó).
Puede generar código para muchas líneas y marcos diferentes utilizando Postman. Estos idiomas incluyen, pero no se limitan a:
Permitiéndole integrar su API recién creada con proyectos existentes
A veces, debe hacer solicitudes externas (por ejemplo, a una API externa). Puede abordar esto utilizando solicitudes AJAX, pero a veces debe realizar estas solicitudes desde el lado del servidor, por ejemplo, si desea actualizar las conversiones de divisas automáticamente. Cuando desea acceder a API externos a través del servidor, no desea confiar en que un usuario esté activamente en la página web para enviar el comando. En su lugar, desea que el servidor pueda activar este comentario. Para lograr esto, utilizamos el módulo de solicitudes.
import requests
requests . methodname ( params ) import requests
params = { "model" : "Mustang" }
x = requests . get ( 'https://w3schools.com/python/demopage.php' , params = params )
print ( x . status_code )
print ( x . text ) import requests
data = { "Name" : "Example" }
headers = { "Authorization" : "Bearer <token>" }
x = requests . post ( 'https://w3schools.com/python/demopage.php' , data = data , headers = headers )
print ( x . status_code )
print ( x . text ) import requests
import json
data = { "Name" : "Example" }
headers = { "Authorization" : "Bearer <token>" }
x = requests . post ( 'https://w3schools.com/python/demopage.php' , json = data , headers = headers )
print ( x . status_code )
print ( x . text )
# use this to load JSON returned as a python dictionary
return_data = json . loads ( x . text ) import requests
data = { "Name" : "Example" }
headers = { "Authorization" : "Bearer <token>" }
x = requests . put ( 'https://w3schools.com/python/demopage.php' , data = data , headers = headers )
print ( x . status_code )
print ( x . text ) import requests
import json
data = { "Name" : "Example" }
headers = { "Authorization" : "Bearer <token>" }
x = requests . put ( 'https://w3schools.com/python/demopage.php' , json = data , headers = headers )
print ( x . status_code )
print ( x . text )
# use this to load JSON returned as a python dictionary
return_data = json . loads ( x . text ) import requests
x = requests . delete ( 'https://w3schools.com/python/demopage.php' )
print ( x . status_code )
print ( x . text )Las solicitudes de AJAX, típicamente una solicitud HTTP realizada por (Browser-Client) en JavaScript que usa XML/JSON para solicitar datos y/o datos de respuesta de un sistema interno o externo. Las solicitudes AJAX se realizan usando </> HTMX de forma predeterminada.
HTMX es una biblioteca sin dependencia que le permite acceder a AJAX, transiciones CSS, WebSockets y eventos orientados al servidor directamente en HTML, utilizando atributos para que pueda construir interfaces de usuario modernas con la simplicidad y el poder del hipertexto. Para obtener detalles sobre cómo usar HTMX, consulte los documentos y para obtener una referencia completa sobre la funcionalidad, consulte https://htmx.org/reference/
Puede usar HTMX para implementar muchos patrones UX comunes, como la búsqueda activa:
< input type =" text " name =" q "
hx-get =" /trigger_delay "
hx-trigger =" keyup changed delay:500ms "
hx-target =" #search-results "
placeholder =" Search... " />
< div id =" search-results " > </ div > Esta entrada llamada Q emitirá una solicitud a /trigger_delay 500 milisegundos después de un evento de clave si la entrada ha sido cambiada e inserta los resultados en el DIV con los resultados de búsqueda de ID.
A pesar de las ventajas del cifrado simétrico, hay una falla en este método que permite a las personas no autorizadas acceder a las claves secretas de un mensaje.
Una de las formas más efectivas de evitar el acceso no autorizado a las claves secretas de un mensaje es implementar una función unidireccional como el algoritmo Diffie-Hellman. Este método solo permite que el remitente y el receptor descifraran el mensaje.
Las funciones unidireccionales generalmente se implementan utilizando un tipo de algoritmo que les permite calcular una salida para cada entrada recibida. Sin embargo, este método no es factible para derivar el resultado exacto de una clave aleatoria.
La prueba es una parte vital de garantizar que un proyecto se ejecute con éxito
Hay 3 aspectos de las pruebas proporcionadas en Flask BDA:
Nota: Para ejecutar manualmente Python
unittest, asegúrese de haber instalado los entornos locales
cd < Path To > /my_awesome_project
venv S cripts a ctivate
flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
flake8 . --count --exit-zero --max-complexity=11 --max-line-length=127 --statistics
cd < Path To > /my_awesome_project
source venv/bin/activate
flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
Nota: Para ejecutar manualmente Python
unittest, asegúrese de haber instalado los entornos locales
cd < Path To > /my_awesome_project
venv S cripts a ctivate
python -m unittest discover
cd < Path To > /my_awesome_project
venv/bin/activate
python -m unittest discover
Ejecutar y configuración de un solo archivo
Proyecto de inicio Flask, que crea una estructura de carpeta de proyecto con
992px500px@mobile_template , permitiendo que las vistas de la plantilla se adapten para una mejor experiencia móvil si es necesario.{% if request.MOBILE %}True{% else %}False{% endif %}config.py para acceso rápido y administración de las variables de entorno y entorno y SEO predeterminadoconfig.py Cree archivos y carpetas de módulos personalizados que se ajusten a la estructura del proyecto Flask desde el archivo create_module.py con indicaciones para crear lo siguiente:
public_listindexcreatestoreshoweditupdatedestroygetpostgetupdatedeletebefore y after cambios en un modelo de datos de datos event listeners para:InsertUpdateDeletepublic_listindexcreatestoreshoweditupdatedestroygetpostgetupdatedeletepostupdategetpublic_list.html (elementos de lista)index.html (elementos de lista)create.html (formulario de un solo elemento)show.html (elemento único)edit.html (formulario de elemento único)api/docs (URL)Soporte del navegador (última versión principal no muerta)
└── `project_name`
├── .github
│ └── workflows
│ ├── docker-image.yml
│ └── run_tests.yml
├── app
│ ├── generated_config
│ │ ├── model_editor
│ │ └── models
│ │ ├── hierarchies
│ │ │ └── models.json
│ │ └── organisations
│ │ └── models.json
│ ├── mod_audit
│ │ ├── __init__.py
│ │ ├── controllers.py
│ │ └── models.py
│ ├── mod_users
│ │ ├── templates
│ │ │ ├── mobile
│ │ │ │ └── auth
│ │ │ │ ├── admin
│ │ │ │ │ ├── create.html
│ │ │ │ │ ├── edit.html
│ │ │ │ │ ├── index.html
│ │ │ │ │ └── show.html
│ │ │ │ └── public
│ │ │ │ └── public_list.html
│ │ │ ├── email
│ │ │ │ ├── activate.html
│ │ │ │ └── reset.html
│ │ │ └── users
│ │ │ ├── admin
│ │ │ │ ├── create.html
│ │ │ │ ├── edit.html
│ │ │ │ ├── index.html
│ │ │ │ └── show.html
│ │ │ └── public
│ │ │ └── public_list.html
│ │ ├── __init__.py
│ │ ├── controllers.py
│ │ ├── forms.py
│ │ └── models.py
│ ├── mod_email
│ │ ├── __init__.py
│ │ ├── controllers.py
│ │ └── models.py
│ ├── mod_file_upload
│ │ ├── templates
│ │ │ └── file_upload
│ │ │ └── upload.html
│ │ ├── __init__.py
│ │ ├── controllers.py
│ │ ├── forms.py
│ │ └── models.py
│ ├── static
│ │ ├── css
│ │ ├── images
│ │ ├── js
│ │ ├── manifest.json
│ │ └── sw.js
│ ├── templates
│ │ ├── admin
│ │ │ └── index.html
│ │ ├── email
│ │ │ └── auth
│ │ │ ├── activate.html
│ │ │ └── reset.html
│ │ ├── mobile
│ │ ├── public
│ │ │ └── index.html
│ │ ├── 403.html
│ │ ├── 404.html
│ │ └── index.html
│ └── __init__.py
├── create_module_template
│ ├── generated_config
│ │ └── models
│ │ └── xyz
│ │ └── models.json
│ └── mod_xyz
│ ├── templates
│ │ ├── mobile
│ │ │ └── xyz
│ │ │ ├── admin
│ │ │ │ ├── create.html
│ │ │ │ ├── edit.html
│ │ │ │ ├── index.html
│ │ │ │ └── show.html
│ │ │ └── public
│ │ │ └── public_list.html
│ │ └── xyz
│ │ ├── admin
│ │ │ ├── create.html
│ │ │ ├── edit.html
│ │ │ ├── index.html
│ │ │ └── show.html
│ │ └── public
│ │ └── public_list.html
│ ├── api_controllers.py
│ ├── controllers.py
│ ├── forms.py
│ └── models.py
├── databases
│ └── sqlite
│ ├── core.db
│ └── default.db
├── .dockerignore
├── .gitignore
├── config.py
├── create_all_models_json.py
├── create_desktop_installer_lunix.py
├── create_desktop_installer_mac.py
├── create_desktop_installer_windows.py
├── create_module.py
├── create_module_json.py
├── Dockerfile
├── FLASK-BDA LICENSE
├── LICENSE
├── package.json
├── package-lock.json
├── Procfile
├── README.md
├── requirements.txt
├── run.py
├── run_desktop.py
├── run_shared_server.py
└── serverless.yml
Un módulo es parte de un programa. Los programas están compuestos por uno o más módulos desarrollados independientemente que, cuando se combinan, crean el programa.
Un módulo es un componente autónomo, lo que facilita la gestión a medida que crece el programa.
Los módulos en Flask-BDA lo ayudan a crear: un modelo de datos, rutas y funciones asociadas para controlar la lógica y las vistas
Los controladores pueden agrupar la lógica de manejo de solicitudes relacionadas en una sola clase. Por ejemplo, una clase UserController podría manejar todas las solicitudes entrantes relacionadas con los usuarios, incluida la muestra, la creación, la actualización y la eliminación de los usuarios.
Crear, leer, actualizar y eliminar ("crud")
La pelusa es la verificación automatizada de su código fuente para errores programáticos y estilísticos. Esto se hace utilizando una herramienta de pelusa (también conocida como Linter). Una herramienta de pelusa es un analizador de código estático básico.
La pelusa, o un linter, es una herramienta de análisis de código estático utilizada para marcar errores de programación, errores, errores estilísticos y construcciones sospechosas.
En la programación de computadoras, las pruebas unitarias son un método de prueba de software mediante el cual las unidades individuales del código fuente, los sets de uno o más módulos de programas de computadora junto con los datos de control asociados, los procedimientos de uso y los procedimientos operativos, se prueban para determinar si son adecuados para su uso .
Una plataforma de desarrollo de bajo código proporciona un entorno de desarrollo para crear software de aplicación a través de interfaces y configuraciones de usuarios programáticas o gráficas en lugar de programación de computadoras codificada a mano tradicional.
Estaríamos encantados si contribuyera al proyecto en una o todas estas formas:
Ver información de la licencia para Python 3. (Https://docs.python.org/3.8/license.html) y otros acuerdos legales (https://www.python.org/about/legal/)
Ver información de licencia para Docker. (https://www.docker.com/legal/components-licenses) y otros acuerdos legales (https://www.docker.com/legal)
Al igual que con todas las imágenes de Docker, probablemente también contienen otro software que puede estar bajo otras licencias (como Bash, etc., de la distribución base, junto con cualquier dependencia directa o indirecta del software primario que se está conteniendo).
Se puede encontrar alguna información de licencia adicional que podría detectarse automáticamente en el directorio/ directorio del repositorio de reposinfo.
En cuanto a cualquier uso de imagen previamente construido, la responsabilidad del usuario de la imagen es asegurarse de que cualquier uso de esta imagen cumpla con cualquier licencia relevante para todo el software contenido.
Vea la información de la licencia para el marco sin servidor y otros acuerdos legales (https://app.serverless.com/legal/terms).
Es responsabilidad del usuario asegurarse de que se adhiera a la política de uso aceptable (https://app.serverless.com/legal/aup)
Vea la información de la licencia para el marco de exposición y otros acuerdos legales (https://github.com/expo/expo/blob/master/license).
Flask-BDA se crea y distribuye bajo la licencia Flask-BDA amigable para el desarrollador. La licencia Flask-BDA se deriva de la popular licencia Apache 2.0.
La licencia Flask-BDA es el requisito legal para que usted o su empresa usen y distribuyan Flask-BDA y trabajos derivados, como las aplicaciones que realiza con él. Su solicitud o proyecto puede tener una licencia diferente, pero aún debe cumplir con la original.
Licencia de licencia y aviso de derechos de autor de la inclusión
La licencia Flask-BDA requiere que deba incluir la licencia y el aviso de derechos de autor con todas las copias de Flask-BDA y en cualquier trabajo derivado creado con Flask-BDA. Depende de usted decidir cómo desea distribuir la licencia y el aviso. A continuación se presentan algunos ejemplos de cómo se puede hacer esto:
Copyright 2021 Flask-BDA, Ryan Julyan con licencia bajo la Licencia Flask-BDA versión 0.1 (la "Licencia"); No puede usar Flask-BDA excepto de conformidad con la licencia. Puede obtener una copia de la licencia, en https://github.com/RyanJulyan/Flask-BDA/blob/main/LICENSE a menos que la ley aplicable sea requerida o acordado por escrito, el software distribuido bajo la licencia se distribuye en un " Como es "base, sin garantías ni condiciones de ningún tipo, expresa o implícita. Consulte la licencia para los permisos y limitaciones de rigor de idioma específico bajo la licencia.
