Flask BDA
1.0.0
Remarque : toujours en développement !
Version actuelle : 0.0.0 Bêta
Flask-BDA est encore en développement initial et est testé avec la version Python 3.8.6.
Feuille de route actuelle et plan de projet de haut niveau : https://trello.com/b/uu4HNPBh/flask-bda-features-roadmap
Flask-BDA suivra le versionnement sémantique pour ses versions, avec un schéma {major}.{minor}.{patch} pour les numéros de version, où :
Les dépréciations seront maintenues pendant au moins 3 versions mineures, après la version 0.0.1
D'autres solutions telles que Tableau, Power BI et Amazon QuickSight, bien que fantastiques, se concentrent sur le reporting mais ne vous permettent pas de modifier ou d'ajouter des données aux plates-formes en cas de besoin, ce qui signifie que vous avez besoin de solutions ou de logiciels supplémentaires pour atteindre vos objectifs commerciaux.
Des solutions comme Excel sont accessibles à tous et vous offrent toute la flexibilité dont vous pourriez avoir besoin. Pourtant, vos données sont dispersées et ne permettent pas facilement de partager une source de vérité pour votre équipe et vos clients, et il est très facile que des documents Excel soient désynchronisés ou même partagés, exposant votre entreprise à un risque de sécurité.
Flask-BDA vous aide en vous offrant le contrôle nécessaire pour fournir des applications Full-stack rapides et sécurisées 2 à 5 fois (2 à 5 fois) plus rapidement. Sans jamais être dépendant d’un fournisseur ou d’un environnement.
Flask est un « micro-framework » open source écrit par Armin Ronacher qui vous permet de créer des applications Web en Python. La livraison d'un petit ensemble de fonctionnalités de base fournit une base extensible qui permet aux développeurs de choisir les outils supplémentaires dont ils auront besoin pour leur application.
Bien qu'il soit appelé micro-framework, Flask est bien adapté à la création de petites et grandes applications Web. Flask a été utilisé dans les systèmes de production de grandes entreprises telles que Twilio, Pinterest, Lyft, LinkedIn et Uber.
Flask-BDA vous aide à développer plus rapidement en vous fournissant une structure d'application Flask préexistante vous permettant de :
Gérez automatiquement les aspects fastidieux qui ralentissent le développement logiciel
- Créez et gérez toutes les connexions à la base de données et les requêtes complexes.
- Sécurité des applications avec contrôle d'accès basé sur les utilisateurs et les rôles
- Audits automatiques sur chaque action
Flask-BDA est une plate-forme low-code (ce qui signifie que nous vous aiderons en écrivant une grande partie du code pour vous) qui fournit aux entreprises les outils nécessaires pour développer et déployer rapidement des applications sécurisées qui s'exécutent sur n'importe quel appareil.
Nous modifions la façon dont les logiciels sont créés afin que vous puissiez rapidement créer et déployer des applications critiques de toute taille qui évoluent avec votre entreprise, ce qui vous fait gagner du temps et de l'argent.
Les développeurs peuvent créer et déployer une gamme complète d'applications - depuis les applications grand public jusqu'aux systèmes d'entreprise internes critiques - conçues pour aider les développeurs à fournir des applications sécurisées rapidement et efficacement, de sorte que les applications soient livrées en quelques semaines, voire quelques jours.
Flask-BDA fournit un développement Full-stack à partir de ; Interface utilisateur, processus métier, logique personnalisée et modèles de données pour créer des applications multiplateformes prêtes à l'emploi. Vous fournir un échafaudage sur lequel vous pouvez ajouter votre propre code personnalisé en cas de besoin. Sans aucun blocage.
Grâce à des environnements de développement préconfigurés, nous réduisons les difficultés (et les coûts) liés à la mise sur le marché, vous offrant ainsi la flexibilité de choisir où et comment déployer.
Gratuit et convivial pour les développeurs, Flask-BDA est un outil de développement d'applications gratuit et disponible en source avec une licence conviviale pour les développeurs.
Flask-BDA est totalement GRATUIT à utiliser pour des projets commerciaux et personnels.
Cependant, le développement de logiciels est toujours un exercice coûteux :
- Vous devrez payer un ou plusieurs développeurs de logiciels, analystes commerciaux, concepteurs, chefs de projet et autres membres de l'équipe pour créer votre produit.
- Votre produit n'est jamais terminé. Un projet logiciel nécessitera toujours un développement continu.
- Lorsque vous proposez un produit, vos concurrents travaillent déjà sur des fonctionnalités nouvelles et améliorées, et vous devez être en mesure de garder une longueur d'avance ou au moins de suivre le rythme, sinon les utilisateurs se tourneront vers vos concurrents.
- Une fois que vous commencerez à utiliser votre produit, vous et votre équipe penserez à de nouvelles fonctionnalités qui le rendront encore meilleur et amélioreront vos processus.
- Entretien continu. Au fur et à mesure que les utilisateurs utilisent le produit, ils trouveront des moyens de le casser auxquels vous n'avez pas pensé et ils devront être corrigés.
| Taille du projet | Coût initial | Coût permanent |
|---|---|---|
| Projets de petite taille (2 à 6 semaines de développement) | 11 250 $ | 563$ - 1 125$ (±10%) / par mois |
| Projets de taille moyenne (2 à 4 mois de développement) | 33 750$ | 1 563 $ - 3 375 $ (±10 %) / par mois |
| Projets de grande taille (6 à 18 mois ou plus de développement) | 156 250 $ | 3 375$ - 15 625$ (±10%) / par mois |
| Taille du projet | Coût initial | Coût permanent |
|---|---|---|
| Projets de petite taille (1 à 3 semaines de développement) | 3 750$ | 188 $ - 375 $ (±10 %) / par mois |
| Projets de taille moyenne (1 à 3 mois de développement) | 11 250 $ | 375$ - 1 125$ (±10%) / par mois |
| Projets de grande taille (2 à 6 mois ou plus de développement) | 52 084 $ | 1 125$ - 5 208$ (±10%) / par mois |
Avec Flask-BDA, vous NE PERDEZ AUCUNE flexibilité du « développement normal » car il utilise des modèles de développement standardisés et des technologies éprouvées.
Flask-BDA utilise de nombreuses technologies Open Source et exploite les piles technologiques existantes afin que vous puissiez facilement trouver d'autres développeurs qui utilisent les mêmes technologies. Par conséquent, vous n’avez pas à payer de frais de licence coûteux ou de coûts environnementaux, quel que soit le chiffre d’affaires de votre entreprise ou l’endroit où vous vous situez dans votre entreprise.
Démarrez votre avec un environnement de développement préconfiguré rapide et facile en quelques minutes.
Aucune configuration complexe requise. Seul Python (suggéré 3.8.6) est requis.
Mettez à jour vos configurations : connexions à la base de données et paramètres de l'application.
Créez vos propres modules et structures de données (modèle de données) vous permettant d'utiliser différentes bases de données.
Généré automatiquement et entièrement fonctionnel :
- Pages
AdminetMobileREST APIsavec un front-end SwaggerGraphQL APIavec un front-end GraphiQL facilement géré par module.
Configurez les pages selon vos besoins spécifiques et partagez-les facilement avec votre équipe et vos clients.
Écrivez votre propre code personnalisé dans un module isolé, afin de ne pas affecter les autres modules,
Intégrez facilement des modules dans différents projets.
Utilisez la même base de code pour déployer sur :
- Bureau
- Web
- Mobile
Les environnements comprennent :
- Docker
- AWS sans serveur
- Océan numérique
- Héroku
- Hébergement mutualisé.
pip est installé (pip doit déjà être installé car il est livré avec les dernières versions de python). Si ce n'est pas le cas, veuillez l'installer à partir d'ici : https://pip.pypa.io/en/stable/installing/python -m pip --version
REMARQUE : cette documentation suppose que vous exécutez
pip3en tant quepip, en tant que telles, toutes les instructions sont écrites avecpip. Si vous souhaitez faire fonctionnerpip3lorsque vous appelezpip, depuis votre terminal, vous pouvez créer un lien symbolique verspip3à partir depip:
pip install --upgrade pipsudo par exemple : sudo pip install --upgrade pip nano ~ /.bash_profile
Dans le fichier, collez ce qui suit :
alias pip= ' pip3 '
alias python= ' python3 '
REMARQUE : vous devrez peut-être supprimer Python 2.7 sur MacOS car il est préinstallé sur mes distributions. Cela a été très utile pour y parvenir :
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 'puis exécutez la commande suivante pour supprimer tous les liens :
cd /usr/local/bin/
ls -l /usr/local/bin | grep ' ../Library/Frameworks/Python.framework/Versions/2.7 ' | awk ' {print $9} ' | tr -d @ | xargs rmUne fois que vous avez installé Python et
pip, vous devrez installer une dépendance pour que les fonctions de ligne de commande Flask-BDA s'exécutent correctement :
pip install click
Les autres dépendances que vous souhaiterez peut-être installer globalement (mais qui devraient s'exécuter automatiquement lorsque vous créez un projet) incluent :
pip install virtualenv
pip install flaskwebgui
pip install pyinstaller
Pour commencer à créer votre premier projet avec Flask-BDA, suivez les étapes simples ci-dessous pour créer votre propre environnement de développement préconfiguré et opérationnel en quelques minutes.
Dans ce démarrage rapide, nous allons créer un projet appelé
"My Awesome Project". Cependant, vous pouvez appeler le projet comme vous le souhaitez.
create_project.py requis et l'exécutera pour vous aider à démarrer un projet."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 requis et l'exécutera pour vous aider à démarrer un projet."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 "
Remarque : Si vous n'avez pas renseigné un nom de projet valide, vous serez invité à le faire :
- Remplissez le nom de votre projet lorsque vous y êtes invité, par exemple :
- Veuillez vous assurer de mettre des guillemets autour du nom de votre projet pour éviter les erreurs, par exemple :
"My Awesome Project"
Invalid Project Name !
Please enter a valid project name :
"My Awesome Project"Remarque : Vous remarquerez que cela crée un dossier dans le même chemin que le fichier : "create_project_git.py". Ce dossier sera en minuscules et aura supprimé tous les caractères spéciaux et remplacé les espaces par des traits de soulignement, par exemple :
my_awesome_project
Remarque : Pendant le développement, vous souhaiterez peut-être utiliser entièrement une autre branche ou un autre dépôt. Cela peut vous aider lors des tests ou si vous vous êtes éloigné du projet principal Flask-BDA.
- Vous pouvez spécifier le
Owner,RepoetBranchlors de la création d'un nouveau projet.
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 = TrueRemarque : Reste à tester pour tous les types de connexion !
Les connexions à la base de données sont rapides et faciles dans Flask-BDA. Vous pouvez avoir 1 ou plusieurs bases de données, et différents locataires peuvent avoir leurs propres connexions à la base de données ainsi que leur propre type de base de données (SQLite, MySQL, SQL Server, PostgreSQL).
Par défaut, Flask-BDA dispose d'une base de données SQLite configurée. C'est vraiment parce que vous n'avez pas besoin d'infrastructure supplémentaire pour le configurer et démarrer, ce qui fait de SQLite un choix rapide et facile.
Pour modifier la base de données par défaut :
flaskbda ), un utilisateur ( flaskbda_user ) et un mot de passe ( password )config.pyDATABASE_ENGINE pour SQLite et commentez dans le mysql DATABASE_ENGINE .DATABASE_NAME pour SQLite et commentez dans le mysql :DATABASE_HOSTDATABASE_PORTDATABASE_USERNAMEDATABASE_PASSWORDDATABASE_NAMESQLALCHEMY_DATABASE_URI pour SQLite et commentez dans le 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' Pour modifier la base de données par défaut :
flaskbda ), un utilisateur ( flaskbda_user ) et un mot de passe ( password )config.pyimport pyodbc .DATABASE_DRIVER .DATABASE_ENGINE pour SQLite, et par exemple commentez dans le SQLServer DATABASE_ENGINE .DATABASE_NAME pour SQLite et commentez dans SQLServer :DATABASE_HOSTDATABASE_PORTDATABASE_USERNAMEDATABASE_PASSWORDDATABASE_NAMESQLALCHEMY_DATABASE_URI pour SQLite et commentez dans l' try et except du SQLServer SQLALCHEMY_DATABASE_URI .Remarque : si vous exécutez et essayez de vous connecter à
SQLEXPRESS. Veuillez décommenter la variable SQLServerSQLEXPRESS. Cela sera géré dans l'tryetexceptpour créer leSQLALCHEMY_DATABASE_URIcorrect
Remarque : si vous souhaitez une authentification Windows. Veuillez décommenter la variable SQLServer
TRUSTED_CONNECTION. Cela sera géré dans l'tryetexceptpour créer leSQLALCHEMY_DATABASE_URIcorrect
##########
# 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'Assurez-vous que votre instance MS-SQL dispose de droits de connexion à distance configurés et activés (ici) [https://knowledgebase.apexsql.com/configure-remote-access-connect-remote-sql-server-instance-apexsql-tools/ ] :
Assurez-vous que les paramètres « Gestion de la configuration du serveur SQL » sont correctement configurés
REMARQUE : Votre installation nécessitera
Client Tools Connectivity. Si vous ne trouvez pas "Gestion de la configuration du serveur SQL", vous devrez peut-être modifier votre installation pour inclureClient Tools Connectivity
- si vous ne trouvez pas le "", vous devrez peut-être utiliser l'outil "Utiliser la gestion de l'ordinateur". pour y accéder.
- cela semble être un problème de Windows 10
La multilocation est une architecture logicielle dans laquelle une seule instance de logiciel s'exécute sur un serveur et dessert plusieurs locataires (clients). Un logiciel mutualisé permet à plusieurs instances indépendantes d’une ou plusieurs applications de fonctionner dans un environnement partagé.
Flask-BDA prend en charge la multilocation partitionnée verticalement. Le partitionnement vertical signifie que chaque locataire dispose d'une base de données différente (et d'une chaîne de connexion à la base de données).
Par défaut, Flask-BDA se connecte à un locataire appelé
default. Cela se fait à l'aide de l'objetSQLALCHEMY_BINDS(trouvé dansconfig.py), qui doit contenir les détails de connexion spécifiques dont vous avez besoin pour chaque locataire. Les détails de connexion par défaut sont combinés dans une chaîne appeléeSQLALCHEMY_DATABASE_URI, destinée à permettre une configuration rapide et facile à locataire unique.
Vous pouvez cependant utiliser cette même structure pour avoir plusieurs locataires, vous pouvez les ajouter rapidement à l'objet
SQLALCHEMY_BINDS. Pour ajouter un nouveau locataire, il suffit de :
SQLALCHEMY_BINDS , avec le nom du locataire et les détails de la chaîne de connexion SQLALCHEMY_BINDS = {
"default" : SQLALCHEMY_DATABASE_URI ,
"client1" : 'sqlite:///databases/sqlite/client1.db' ,
}Vous pouvez désormais interagir avec une base de données de locataires isolée en ajoutant l'argument
organization=à votre URL, par exemple :example.com?organization=client1oùclient1est le nom que vous avez ajouté dans l'objetSQLALCHEMY_BINDS.
Cela fonctionne en interceptant le
@app.before_requestdansapp/_init_.pyet en modifiant la liaison du moteur de base de données en utilisantdb.choose_tenant(g.organization)depuisapp/mod_tenancy/multi_tenant.pyen utilisant la variable globaleg.organizationqui obtient défini en récupérant l'argument URLorganization. Cela permet au même code dans l'application d'être utilisé par la base de données de chaque locataire tout en gardant les données séparées.
Parfois, vous devez interagir avec différentes bases de données dans une seule fonction (en particulier lors de l'intégration de systèmes ou de la lecture de données provenant de différentes sources).
Par défaut,
MultiBindSQLAlchemysera importé sur tous les contrôleurs.
# import multiple bindings
from app . mod_tenancy . multi_bind import MultiBindSQLAlchemySous l'importation se trouve un code commenté destiné à vous aider à implémenter rapidement des liens vers différentes bases de données dans une seule fonction. Tout d'abord, la liaison de base de données doit être ajoutée à l'objet
SQLALCHEMY_BINDS. Référencez les bases de données isolées avec la même fonctionnalité pour mieux comprendre comment ajouter de nouvelles bases de données à l'objetSQLALCHEMY_BINDS.
Vous pouvez ensuite créer un nouvel objet attaché à l'objet
dben suivant la structure dedb.<binding>par exemple :db.firstoùfirstest le nom auquel vous souhaitez référencer la liaison dans le reste du code. Vous pouvez ensuite attribuer cette variable auMultiBindSQLAlchemy, par exemple :db.first = MultiBindSQLAlchemy('first').
Cela vous permet désormais d'appeler du code personnalisé qui vous permettra d'accéder à la nouvelle liaison de base de données ainsi qu'au locataire principal dans une seule fonction, par exemple :
db.first.execute(...), où vous pourrez exécuter du code SQL brut.
db . first = MultiBindSQLAlchemy ( 'first' )
##################################################
## this will only work for the execute function ##
##################################################
db . first . execute (...)**Remarque : ** cela ne fonctionnera que pour la fonction
execute, il existe des techniques avancées pour continuer à utiliser l'ORM SQLAlchemy qui peuvent être trouvées ici : Tutoriel d'exécution de SQLAlchemy
Un module est un composant autonome, ce qui facilite sa gestion à mesure que le programme se développe. Les modules de Flask-BDA vous aident à créer : un modèle de données, des routes et des fonctions associées pour contrôler la logique et les vues.
Lorsque vous créez un nouveau module CRUD, tous les éléments du dossier
create_module_templatesont copiés dans le répertoire de l'application et renommés avec le nom du module que vous fournissez en remplaçant toutes les valeursxyzpar le nom de votre module et en ajoutant des informations supplémentaires sur le modèle de données comme décrit ci-dessous.
<Path To>/<my_awesome_project>/create_module_json.py<Path To>/<my_awesome_project>/ est le chemin d'accès au projet que vous avez créé 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 : Remarque : cela continuera en boucle jusqu'à ce que vous tapiez et soumettiez les mots exacts : "STOP_CREATING_FIELDS".
Cela vous permet de créer rapidement et facilement plusieurs champs pour votre module.
Les champs ci-dessus devraient montrer que différents types de champs interagissent et créent plusieurs champs.
Remarque : Les relations seront toujours établies sur l'
iddu modèle fourni.Une ForeignKey est créée sur le champ, ainsi qu'une relation paresseuse entre le champ
idfourni par le modèle
Create new field Name (type the string : 'STOP_CREATING_FIELDS' to exit ): STOP_CREATING_FIELDS Create module logic from Data Model ? ( 'True' , 'False' ): TrueRemarque : vous pouvez également générer un module à partir d'un fichier JSON dans "app/generated_config/models//models.json", où est le nom du module que vous saisissez pour ce faire, vous pouvez, ouvrir et exécuter le fichier :
<Path To>/<my_awesome_project>/create_module.py* Où<Path To>/<my_awesome_project>/est le chemin d'accès au projet que vous avez créé * Remplissez les instructions, par exemple :
cd < Path To > / < my_awesome_project > /
python create_module . py - - module = projectsCela créera ensuite les fichiers et dossiers requis comme décrit ci-dessous dans les modifications de l'application.
Les fichiers et dossiers du dossier
create_module_templatesont créés pour le moduleProjectspuis ajoutés au dossierapp.Cela créera des vues CRUD d'administration échafaudées, une API REST (avec insertion et mise à jour en masse), une API GraphQL, ainsi que des vues et une logique accessibles au public pour vous permettre d'interagir immédiatement avec le module que vous avez créé.
Depuis le panneau d'administration, vous pourrez effectuer les actions suivantes : Créer, Lire, Mettre à jour et Supprimer (« CRUD ») pour votre nouveau module.
Les vues publiques permettent aux utilisateurs invités (utilisateurs non connectés) de voir une vue des informations fournies.
└── `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 création d'un nouveau module vous offrira 3 façons d'interagir avec votre nouveau système
Public,Admin,REST APIetGraphQL API.
Pour y accéder, ils auront besoin que l’application s’exécute sur un environnement.
La vue
Publicest une vue non authentifiée des données fournies dans le module.
xyz est le nom du module) :../xyz/public_list Les vues
Adminsont une vue authentifiée des données fournies dans le module.
xyz est le nom du module) :../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 Les vues
APIsont une liste de points de terminaison de l'API REST, la documentation associée et le terrain de jeu d'exécution.
Flask BDA utilise SwaggerUI pour présenter l'API REST à un utilisateur/client.
SwaggerUI permet à n'importe qui, qu'il s'agisse de votre équipe de développement ou de vos consommateurs finaux, de visualiser et d'interagir avec les ressources de l'API sans qu'aucune logique de mise en œuvre soit en place. Au lieu de cela, il est automatiquement généré à partir de votre spécification OpenAPI (anciennement connue sous le nom de Swagger), avec une documentation visuelle facilitant la mise en œuvre back-end et la consommation côté client.
Pour accéder à SwaggerUI :
<base_URL>/api/docs pour accéder à l'API REST SwaggerUI, par exemple : http://localhost:5000/api/docs .Pour accéder à l'API REST sans 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 Les vues
graphqlsont des vues GraphiQL, des points de terminaison d'API, une documentation associée et un terrain de jeu d'exécution.
Flask BDA utilise graphène-python et GraphiQL pour présenter l'API GraphQL à un utilisateur/client, fournissant une API simple mais extensible pour faciliter la vie des développeurs.
GraphQL est un langage de requête de données offrant une alternative aux architectures de services Web REST et ad hoc.
Pour accéder au GraphiQL :
<base_URL>/graphql pour accéder à GraphiQL, API GraphQL, par exemple : http://localhost:5000/graphql .Pour accéder à l'API GraphQL sans GraphiQL :
<base_URL>/../graphqlmod_graphql > query > Query > all_xyz../graphqlmod_graphql > mutation > Mutation > createXyz Il existe actuellement 7 environnements prêts à l'emploi pris en charge (et d'autres devraient bientôt être pris en charge) avec des instructions sur la façon de configurer chacun pour Windows / Linux / Mac , et vous pouvez les exécuter en même temps si vous le souhaitez.
Pour créer et développer une application locale, nous utilisons virtualenv. Un outil pour créer des environnements Python virtuels isolés.
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 par exemple : 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
Certains services d'hébergement partagé offrent la possibilité d'exécuter des applications Python sur leurs serveurs. J'ai personnellement utilisé A2hosting. Leur support a été incroyable et le prix des fonctionnalités est l’un des meilleurs que j’ai rencontrés.
Remarque : Vous n'êtes pas limité à A2 comme option d'hébergement partagé. Cependant, c'est là que j'ai testé Flask-BDA et que j'ai acquis mon expérience dans le téléchargement et l'exécution d'une option d'hébergement partagé. Si votre option d'hébergement partagé offre un ensemble similaire de fonctionnalités, n'hésitez pas à les utiliser.
Pour A2, vous devrez configurer votre serveur pour exécuter une application python qui peut nécessiter une certaine configuration par exemple.
Pour faire fonctionner votre application personnalisée :
Remarque : Dans un environnement
Linuxl'exigencepyodbcne fonctionnera pas par défaut. Pour cette raison, et étant donné qu'il s'agit d'un environnement partagé - vous n'avez peut-être pas le droit d'ajouter les exigences nécessaires pour le faire fonctionner, le moyen le plus simple de garantir que l'installation n'échoue pas est de commenter cette exigence sur le serveur.
requirements.txt , recherchez pyodbc et mettez un # avec un espace avant le nom du package. # pyodbc==4.0.30
requirements.txtSSH à laquelle vous vous êtes connecté à l'étape précédente pip install --upgrade pip
pip install --no-cache-dir -r requirements.txt
Setup Python AppApplication startup file par run_shared_server.pyPour créer et déployer une application conteneurisée, nous utilisons Docker, qui aide les développeurs et les équipes de développement à créer et à expédier des applications. De plus, Docker est utilisé pour la création et le partage d'applications et de microservices conteneurisés.
Remarque : Si vous utilisez Github et que Docker est installé (détails sur la façon d'installer plus loin dans la documentation), vous obtiendrez une nouvelle image créée à chaque fois que vous
pushou effectuerez unepull_requestsur Github, qui est configurée dans le fichier :docker-image.ymlcependant, si vous souhaitez le faire manuellement, veuillez suivre les étapes ci-dessous :
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
Remarque : toujours en développement
Pour créer et déployer une application sans serveur, nous utilisons The Serverless Framework, qui permet un développement sans serveur sans friction, vous permettant de créer facilement des applications qui s'adaptent automatiquement sur une infrastructure cloud de nouvelle génération à faible coût.
Le framework Serverless est un outil open source qui permet un développement et un déploiement faciles de YAML + CLI sur AWS, Azure, Google Cloud, Knative et plus encore.
Remarque : Vous devrez peut-être ajuster les chaînes de base de données par défaut avant del=polying, car le mode sans serveur ne prend pas en charge "SQLite" car la fonction ne conserve pas l'état.
Pour mettre à jour les chaînes de la base de données, veuillez vous référer à [Config]
npm update -g serverless
npm update -g serverless
choco install serverless
Remarque : Si le package ne s'installe pas, vous devrez peut-être exécuter la commande en tant qu'administrateur.
appuyez sur la "Touche Windows", tapez "cmd", "Clic droit" sur le mot "Invite de commandes" et sélectionnez l'option "Exécuter en tant qu'administrateur", puis suivez à nouveau les étapes précédentes
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
Remarque : toujours en développement
Digital Ocean est une plateforme en tant que service (PaaS). Développez, gérez et faites évoluer vos applications sur la plateforme cloud complète de DigitalOcean. Digital Ocean vous propose une tarification simple et prévisible. Créez et publiez en toute confiance avec des produits de calcul évolutifs dans le cloud, des bases de données entièrement gérées, des options de stockage hautement disponibles et évolutives, et bien plus encore. Avec des machines virtuelles dotées d'une bonne quantité de mémoire, adaptées pour héberger et faire évoluer les applications et les bases de données, Digital Ocean propose des solutions simples à des problèmes complexes.
Pour créer et déployer une application sur Heroku depuis le terminal, vous devrez :
138.197.67.25REMARQUE si vous n'êtes pas connecté via SSH, vous devriez recevoir le
passwordvia l'e-mail avec lequel vous avez enregistré le compte, pour Digital Ocean.
cd < Path To > / < my_awesome_project > /
scp -r < my_awesome_project > root@ < ip_address > :/
ssh root@ < ip_address >
Où
<Path To>/<my_awesome_project>/est le chemin d'accès au projet que vous avez créé et où<ip_address>est les droplets <ip_address>, par exemple :138.197.67.25
Remarque: Suivez toutes les invites présentées par le SSH, telles que permettre l'accès depuis le serveur distant.
Une fois que vous êtes connecté, vous devriez pouvoir voir un terminal avec:
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
Où
5000est le numéro de port
et<droplet_name>est le nom
cd < Path To > / < my_awesome_project > /
scp -r < my_awesome_project > root@ < ip_address > :/
ssh root@ < ip_address >
Où
<Path To>/<my_awesome_project>/est le chemin du projet que vous avez créé et où<ip_address>est les gouttelettes <ip_address> par exemple:138.197.67.25
Remarque: Suivez toutes les invites présentées par le SSH, telles que permettre l'accès depuis le serveur distant.
Une fois que vous êtes connecté, vous devriez pouvoir voir un terminal avec:
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
Où
5000est le numéro de port
et<droplet_name>est le nom
Remarque: toujours en cours de développement
Heroku est une plate-forme en tant que service (PaaS). Heroku vous permet de commencer par un engagement zéro, de payer au fur et à mesure que vous n'allez pas. Les développeurs, les équipes et les entreprises de toutes tailles peuvent utiliser Heroku pour déployer, gérer et mettre à l'échelle des applications. Que vous créiez un prototype simple ou un produit critique, la plate-forme entièrement gérée d'Heroku vous offre rapidement un chemin pour livrer des applications.
Pour créer et déployer une application à Heroku à partir du terminal, vous devrez télécharger et installer la CLI Heroku. Pour vérifier l'installation, vous pouvez vérifier la version Heroku à partir du terminal:
heroku --version
Remarque: Assurez-vous que vous avez changé la connexion de votre base de données, car Heroku ne suggère pas d'utiliser SQLite, car les données peuvent être perdues sur les fichiers. Heroku propose une base de données postgres gratuite. Voir leurs plans et choisissez le bon plan pour vous car il existe des limites sur les différents plans.
cd < Path To > /my_awesome_project
heroku login
<my_awesome_project-flask-bda-app> , où <my_awesome_project-flask-bda-app> est le nom que vous avez donné à votre projet.heroku create my_awesome_project-flask-bda-app
git push heroku master
<my_awesome_project-flask-bda-app> est le nom que vous avez donné à votre projet. cd < Path To > /my_awesome_project
sudo snap install --classic heroku
heroku login
<my_awesome_project-flask-bda-app> , où <my_awesome_project-flask-bda-app> est le nom que vous avez donné à votre projet.heroku create my_awesome_project-flask-bda-app
git push heroku master
<my_awesome_project-flask-bda-app> est le nom que vous avez donné à votre projet. cd < Path To > /my_awesome_project
brew tap heroku/brew && brew install heroku
heroku login
<my_awesome_project-flask-bda-app> , où <my_awesome_project-flask-bda-app> est le nom que vous avez donné à votre projet.heroku create my_awesome_project-flask-bda-app
git push heroku master
<my_awesome_project-flask-bda-app> est le nom que vous avez donné à votre projet. Pour les applications mobiles natives, nous utilisons React-Native. Plus précisément, nous utilisons l'Expo comme cadre et une plate-forme pour les applications REACT universelles. Il s'agit d'un ensemble d'outils et de services construits autour des plates-formes natives et natives qui vous aident à développer, créer, déployer et itérer rapidement sur iOS, Android et les applications Web à partir de la même base de code JavaScript / TypeScript.
Nous avons des notifications push pré-set, donc vous n'êtes pas obligé. Cela signifie qu'il est plus rapide et plus facile pour vous de commencer et de fonctionner. De plus, nous tirons parti du package d'expositions par défaut, il permet une implémentation et une approche simplifiées.
Les avantages incluent des flux / processus de travail de construction et de test plus rapides, les tests à distance tout en se développant avec des mises à jour sur l'air (OTA) avec des modifications visibles lors de la sauvegarde pendant le développement.
Cependant, il existe des inconvénients et des limitations que Expo en est conscient et les décrit très bien. Nous vous suggérons de passer en revue ces limitations avant d'utiliser notre méthode prédéfinie.
Créez un projet qui s'exécute nativement sur tous les appareils de vos utilisateurs.
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
Parce que Flask BDA ne dicte pas où vous devez héberger votre site Web, vous devrez dire à votre application mobile où aller.
Dans l'exemple QuickStart, nous avons créé un projet intitulé
"My Awesome Project". Cependant, vous avez peut-être appelé le projet autre chose. Cela aurait créé un dossier où le nom est en minuscules et éliminé tous les caractères spéciaux, et remplacé les espaces par des soulignements, par exemple:my_awesome_project.
Pour mobile, nous aurons automatiquement créé un dossier distinct
"_mobile_app"où le préfixe du dossier est le nom de votre projet, par exemplemy_awesome_project_mobile_app. Il s'agit d'éviter les problèmes avec lepackage.jsonde configurationServerlesset de vous permettre de ne pas déployer tout le code pour une application mobile sur votre serveur Web.
Si vous êtes toujours en développement et / ou que vous n'avez pas encore choisi de fournisseur de services pour l'hébergement, vous pouvez utiliser: Ngrok pour créer une URL de développement public temporaire qui tune votre environnement local. Ngrok expose les serveurs locaux derrière les NAT et les pare-feu à Internet public sur des tunnels sécurisés. Cela vous permet de démontrer des sites Web sur une URL publique et de tester les applications mobiles connectées à votre backend à course local sans déploiement.
Démarrez le serveur de développement local en suivant les instructions de l'environnement local
Si vous ne vous êtes pas inscrit au NGROK auparavant:
Si vous vous êtes déjà inscrit mais que vous ne l'avez pas installé:
Une fois le terminal ngrok ouvert, créez un tunnel de votre serveur local à Ngrok
5000 par défaut, remplacez le numéro après http pour permettre la création du tunnel correct. 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
Remarque: La version gratuite ne maintient ce serveur en vie que pendant 2 heures, vous devrez donc peut-être suivre ce processus à l'avenir, et si vous poussez cette URL vers votre "repo", cela peut ne pas fonctionner pour la prochaine personne.
my_awesome_project_mobile_appapp.json et modifiez la ligne 2 "server_base_url": "https://github.com/RyanJulyan/Flask-BDA" en remplaçant https://github.com/RyanJulyan/Flask-BDA par le vôtre par le vôtre par le vôtre par le vôtre par le vôtre par le vôtre par le vôtre par le vôtre Nom du serveur.expo sur votre propre téléphone mobile en recherchant "Expo" sur l'Apple ou Google Play Store:iOS va à: https://apps.apple.com/app/apple-store/id982107779Android allez à: https://play.google.com/store/apps/details?id=host.exp.exponentUne fois que l'application est installée sur votre téléphone, vous pouvez démarrer un serveur de développement sur votre machine locale.
cd < Path To > /my_awesome_project_mobile_app
expo start
cd < Path To > /my_awesome_project_mobile_app
expo start
Cela ouvrira une page Web avec un code QR dessus. Cela vous permettra d'utiliser l'application Expo si vous êtes sur Android ou utilisez l'appareil photo si vous êtes sur iOS pour scanner le code et ouvrir votre application directement à partir du serveur de développement.
Remarque: Si vous souhaitez que les personnes qui ne soient pas sur votre réseau puissent scanner et tester l'application à distance, appuyez sur le bouton Onglet
tunnelau-dessus du code QR.
Une partie des recommandations consiste à s'assurer que les images sont optimisées. Pour ce faire, Expo a recommandé le package Expo-Optimize qui peut aider à optimiser les images. De plus, l'optimisation des images peut améliorer votre application native TTI (ou le temps à interaction), ce qui signifie moins de temps sur les écrans d'éclaboussures et une livraison plus rapide sur de mauvaises connexions réseau.
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
Pour créer et développer une application de bureau, nous utilisons Flaskwebgui. Un outil pour créer et exécuter votre application Web Flask dans un wrapper Chrome. Pour distribuer l'application de bureau, nous utilisons Pyinstaller. Pyinstaller gèle les applications Python dans des exécutables autonomes sous Windows, GNU / Linux, Mac OS X, FreeBSD, Solaris et AIX.
Chaque déploiement doit être créé sur la plate-forme spécifique que vous souhaitez l'exécuter. Nous avons créé des scripts qui vous permettront de gérer ces déploiements en plaçant les dossiers
buildetdistdans les dossiers parents pour la plate-forme respective. Ces dossiers seront préfixés avecdesktop_suivi de la plate-forme. Cela se fait uniquement pour vous permettre de gérer les processus de distribution et de construction pour les plates-formes spécifiques et de ne pas les écraser lors de la construction de différentes plates-formes.
Pour permettre à l'exportation vers le bureau de fonctionner correctement, nous avons besoin de modifications de code. Par défaut, Flask-BDA est destiné au développement Web et mobile, et nous avons mis en œuvre un limiteur de taux sur le site. Malheureusement, vous avez besoin d'un serveur pour évaluer la limite, et comme vous exportez le système vers une application de bureau, il n'exécute pas de serveur.
En tant que tel, vous devez supprimer toutes les références au limiteur. Ceux-ci peuvent être trouvés sur
app/__init__.py. Pour ce faire, ouvrez le fichier dans un éditeur de texte et commentez les lignes suivantes:
# 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']
# )Remarque: Si vous avez ajouté un limiteur personnalisé, recherchez
@limiter.limit, qui se trouve dans vos contrôleurs. Vous devrez commenter toutes ces références et les références d'importation, par exemple:from app import limiter
Cela vous permettra d'exporter l'application en tant que fichier exécutable de bureau sans erreurs.
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 par exemple: 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 par exemple: 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
Cela ouvrira une fenêtre maximisée qui s'exécutera comme une application de bureau normale. Cela utilisera le navigateur Chrome installé localement pour servir le contenu.
Par défaut, cette application sera servie sur le port
7000. Cependant, vous pouvez modifier le port dans le fichierrun_desktop.pysi cela entre en conflit avec des applications existantes.
Si vous incluez des packages Python supplémentaires dans votre projet, n'oubliez pas d'exécuter
pip freezeà partir de votre terminal pour vous assurer d'obtenir les bons packages pour vos déploiements
pip freeze > requirements.txt
Remarque: il est suggéré d'installer et de congeler des packages Python supplémentaires à partir d'un environnement virtuel plutôt que dans le monde. Cela conserve vos
requirements.txtpetit et limité aux packages que vous utilisez dans votre projet spécifique.
FLASK BDA utilise Swaggerui par défaut pour aider et présenter l'API à un utilisateur / client.
Swaggerui permet à quiconque - soit votre équipe de développement ou vos consommateurs finaux - à visualiser et à interagir avec les ressources de l'API sans que la logique de mise en œuvre en place. Au lieu de cela, il est automatiquement généré à partir de votre spécification OpenAPI (anciennement connue sous le nom de Swagger), avec une documentation visuelle facilitant la mise en œuvre de la mise en œuvre et la consommation côté client.
Pour accéder au Swaggerui:
<base_URL>/api/docs pour accéder à l'API Swaggerui, par exemple: http://localhost:5000/api/docsDe nombreux développeurs préféreront que Postman à SwaggerUi teste et intégrera les API à leur code. Nous avons aidé en fournissant une exportation de collecte directe pour Postman.
Pour importer la collection sur Postman:
Import... (Ctrl + O)Link dans les onglets<base_URL>/api/postman par exemple: http://localhost:5000/api/postman<base_URL>/aswagger.json par exemple: http://localhost:5000/swagger.json et importez-le directement dans Postmanhttps://learning.postman.com/docs/getting-started/importing-and-exporting-data/#converting-postman-collections-from-v1-to-v2 convertir le fichier de V1 en V2 https://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> et <path to the downloaded Postman file> sont des chemins de fichier physiques sur votre machine locale.ContinueImportCela importera une collection Postman qui sera disponible sur le côté gauche en tant que dossier (avec des sous-dossiers de chacun des points de terminaison que vous avez créés).
Vous pouvez générer du code pour de nombreux lanuages et cadres différents à l'aide de Postman. Ces langues comprennent, sans s'y limiter:
Vous permettant d'intégrer votre API nouvellement créée aux projets existants
Parfois, vous devez faire des demandes externes (par exemple à une API externe). Vous pouvez aborder cela en utilisant les demandes AJAX, mais parfois vous devez faire ces demandes à partir du côté serveur, par exemple, si vous souhaitez mettre à jour automatiquement les conversions de devises. Lorsque vous souhaitez accéder aux API externes via le serveur, vous ne souhaitez pas compter sur un utilisateur activement sur la page Web pour envoyer la commande. Au lieu de cela, vous souhaitez que le serveur puisse activer ce commentaire. Pour y parvenir, nous utilisons le module Demandes.
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 )Les demandes AJAX, généralement une demande HTTP faite par (Browser-Client) en JavaScript qui utilise XML / JSON pour demander des données et / ou des données de réponse à partir d'un système interne ou externe. Les demandes AJAX sont faites en utilisant </> htmx par défaut.
HTMX est une bibliothèque sans dépendance qui vous permet d'accéder à AJAX, aux transitions CSS, à WebSocket et à des événements de serveur directement dans HTML, en utilisant des attributs afin que vous puissiez créer des interfaces utilisateur modernes avec la simplicité et la puissance de l'hypertexte. Pour plus de détails sur la façon d'utiliser HTMX, veuillez vous référer aux documents et pour une référence complète sur la fonctionnalité, veuillez vous référer à https://htmx.org/reference/
Vous pouvez utiliser HTMX pour implémenter de nombreux modèles UX communs, tels que la recherche active:
< 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 > Cette entrée nommée Q émettra une demande à /trigger_delay 500 millisecondes après un événement de Key-up si l'entrée a été modifiée et insère les résultats dans le div avec les résultats de recherche d'ID.
Malgré les avantages du cryptage symétrique, il existe un défaut dans cette méthode qui permet aux personnes non autorisées d'accéder aux clés secrètes d'un message.
L'un des moyens les plus efficaces d'empêcher l'accès non autorisé aux clés secrètes d'un message consiste à implémenter une fonction unidirectionnelle comme l'algorithme Diffie-Hellman. Cette méthode permet uniquement à l'expéditeur et au récepteur de déchiffrer le message.
Les fonctions unidirectionnelles sont généralement implémentées à l'aide d'un type d'algorithme qui leur permet de calculer une sortie pour chaque entrée reçue. Cependant, cette méthode n'est pas possible de dériver le résultat exact d'une clé aléatoire.
Les tests sont un élément essentiel pour s'assurer qu'un projet fonctionne avec succès
Il y a 3 aspects des tests fournis dans Flask BDA:
Remarque: Pour exécuter manuellement Python
unittest, assurez-vous que vous avez installé les environnements locaux
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
Remarque: Pour exécuter manuellement Python
unittest, assurez-vous que vous avez installé les environnements locaux
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
Exécution et configuration d'un seul fichier
Projet de flasque de démarrage, qui construit une structure de dossiers de projet avec
992px500px@mobile_template , permettant aux vues de modèle d'être adaptées à une meilleure expérience mobile si nécessaire.{% if request.MOBILE %}True{% else %}False{% endif %}config.py pour l'accès rapide et la gestion des variables environnementales et environnement et SEO par défautconfig.py Créer des fichiers et des dossiers de modules personnalisés qui s'intègrent dans la structure du projet FLASK à partir du fichier create_module.py avec des invites pour créer les éléments suivants:
public_listindexcreatestoreshoweditupdatedestroygetpostgetupdatedeletebefore et after modifications sur un modèle event listeners de données pour:InsertUpdateDeletepublic_listindexcreatestoreshoweditupdatedestroygetpostgetupdate URL ../API/XYZ/USEdeletepostupdategetpublic_list.html (lister les éléments)index.html (listes d'éléments)create.html (formulaire d'élément unique)show.html (élément unique)edit.html (formulaire d'élément unique)api/docs (URL)Prise en charge du navigateur (1 dernière version majeure pas mort)
└── `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 module fait partie d'un programme. Les programmes sont composés d'un ou plusieurs modules développés indépendamment qui, lorsqu'ils sont combinés, créent le programme.
Un module est un composant autonome, ce qui facilite la gestion à mesure que le programme se développe.
Les modules de Flask-BDA vous aident à créer: un modèle de données, des routes et des fonctions associées pour contrôler la logique et les vues
Les contrôleurs peuvent regrouper la logique de traitement des demandes liées en une seule classe. Par exemple, une classe UserController peut gérer toutes les demandes entrantes liées aux utilisateurs, y compris l'affichage, la création, la mise à jour et la suppression des utilisateurs.
Créer, lire, mettre à jour et supprimer ("crud")
La liaison est la vérification automatisée de votre code source pour les erreurs programmatiques et stylistiques. Cela se fait en utilisant un outil de peluche (autrement connu sous le nom de Linter). Un outil de charpie est un analyseur de code statique de base.
Le peluche, ou un linter, est un outil d'analyse de code statique utilisé pour signaler les erreurs de programmation, les bogues, les erreurs stylistiques et les constructions suspectes.
Dans la programmation informatique, les tests unitaires sont une méthode de test logiciel par laquelle les unités individuelles de code source - ensembles d'un ou plusieurs modules de programme informatique ainsi que des données de contrôle associées, des procédures d'utilisation et des procédures de fonctionnement - sont testés pour déterminer s'ils sont aptes à utiliser .
Une plate-forme de développement à faible code fournit un environnement de développement pour créer un logiciel d'application via des interfaces et des configurations utilisateur programmatiques ou graphiques au lieu de la programmation informatique codée à la main traditionnelle.
Nous serions ravis si vous contribuiez au projet de toutes ces manières:
Voir les informations de licence pour Python 3. (Https://docs.python.org/3.8/license.html) et d'autres accords juridiques (https://www.python.org/about/legal/)
Afficher les informations de licence pour Docker. (https://www.docker.com/legal/components-licenses) et d'autres accords juridiques (https://www.docker.com/legal)
Comme pour toutes les images Docker, celles-ci contiennent probablement également d'autres logiciels qui peuvent être sous d'autres licences (telles que Bash, etc., à partir de la distribution de base, ainsi que toute dépendance directe ou indirecte du logiciel principal contenu).
Certaines informations supplémentaires de licence qui pourraient être détectées automatiquement peuvent être trouvées dans le répertoire / répertoire du référentiel Repo-Info.
Quant à toute utilisation d'image prédéfinie, la responsabilité de l'utilisateur de l'image est de s'assurer que toute utilisation de cette image est conforme à toute licence pertinente pour tous les logiciels contenus.
Affichez les informations de licence pour le framework sans serveur et autres accords juridiques (https://app.serverless.com/legal/terms).
Il est de la responsabilité de l'utilisateur de s'assurer que d'adhérer à la politique d'utilisation acceptable (https://app.serverless.com/legal/aup)
Affichez les informations de licence pour le cadre Expo et d'autres accords juridiques (https://github.com/expo/expo/blob/master/license).
Flask-BDA est créé et distribué sous la licence FLASK-BDA conviviale pour les développeurs. La licence Flask-BDA est dérivée de la populaire licence Apache 2.0.
La licence Flask-BDA est l'exigence légale pour vous ou votre entreprise d'utiliser et de distribuer Flask-BDA et des œuvres dérivées telles que les applications que vous faites avec. Votre application ou votre projet peut avoir une licence différente, mais elle doit encore se conformer à l'original.
Inclusion de préavis de licence et de droit d'auteur
La licence FLASK-BDA exige que vous deviez inclure la licence et l'avis de droit d'auteur avec toutes les copies de Flask-BDA et dans tout travail dérivé créé à l'aide de Flask-BDA. C'est à vous de décider comment vous souhaitez distribuer la licence et le préavis. Voici quelques exemples de la façon dont cela peut être fait:
Copyright 2021 Flask-BDA, Ryan Juilletan Licencié sous la version 0.1 de la licence FLASK-BDA (la "licence"); Vous ne pouvez pas utiliser Flask-BDA sauf conformément à la licence. Vous pouvez obtenir une copie de la licence, sur https://github.com/RyanJulyan/Flask-BDA/blob/main/LICENSE sauf si exigée par la loi applicable ou convenu par écrit, les logiciels distribués sous la licence sont distribués sur un " Comme c'est la base, sans garanties ni conditions d'aucune sorte, expressive ou implicite. Voir la licence pour la langue spécifique régissant les autorisations et les limitations sous la licence.
