Flask BDA
1.0.0
Nota: Ainda em desenvolvimento!
Versão atual: 0.0.0 Beta
Flask-BDA ainda está em desenvolvimento inicial e está sendo testado com Python versão 3.8.6.
Roteiro atual e plano de projeto de alto nível: https://trello.com/b/uu4HNPBh/flask-bda-features-roadmap
Flask-BDA seguirá versionamento semântico para seus lançamentos, com um esquema {major}.{minor}.{patch} para números de versões, onde:
As descontinuações serão mantidas em pelo menos três versões secundárias, após a versão 0.0.1
Outras soluções, como Tableau, Power BI e Amazon QuickSight, embora sejam ferramentas fantásticas, concentram-se em relatórios, mas não permitem editar ou adicionar dados às plataformas quando necessário, o que significa que você precisa de soluções ou software adicionais para atingir seus objetivos de negócios.
Soluções como o Excel são acessíveis a todos e oferecem toda a flexibilidade necessária. Ainda assim, seus dados estão dispersos e não permitem facilmente o compartilhamento de uma fonte de verdade para sua equipe e clientes, e é muito fácil que documentos Excel fiquem fora de sincronia ou até mesmo compartilhados, expondo sua empresa a um risco de segurança.
O Flask-BDA ajuda você, fornecendo o controle para fornecer aplicativos Full-stack rápidos e seguros, 2 a 5x (2 a 5 vezes) mais rápido. Sem dependência de fornecedor ou ambiente, nunca.
Flask é uma "microestrutura" de código aberto escrita por Armin Ronacher que permite construir aplicações web em Python. O envio de apenas um pequeno conjunto básico de recursos fornece uma base extensível que permite aos desenvolvedores escolher quais ferramentas adicionais serão necessárias para seus aplicativos.
Apesar de ser chamado de microframework, o Flask é adequado para construir aplicações web pequenas e grandes. O Flask tem sido usado em sistemas de produção por grandes empresas como Twilio, Pinterest, Lyft, LinkedIn e Uber.
O Flask-BDA ajuda você a desenvolver mais rapidamente, fornecendo uma estrutura de aplicativo de frasco pré-existente que permite:
Lidar automaticamente com os aspectos tediosos que retardam o desenvolvimento de software
- Crie e gerencie todas as conexões de banco de dados e consultas complexas.
- Segurança de aplicativos com controle de acesso baseado em usuário e função
- Auditorias automáticas em cada ação
Flask-BDA é uma plataforma de baixo código (o que significa que iremos ajudá-lo escrevendo grande parte do código para você) que fornece as ferramentas para as empresas desenvolverem e implantarem rapidamente aplicativos seguros que rodam em qualquer dispositivo.
Mudamos a forma como o software é construído para que você possa criar e implantar rapidamente aplicativos críticos de qualquer tamanho que evoluem com o seu negócio, economizando tempo e dinheiro.
Os desenvolvedores podem criar e implantar uma gama completa de aplicativos – desde aplicativos de consumo até sistemas corporativos internos críticos – projetados para ajudar os desenvolvedores a fornecer aplicativos seguros com rapidez e eficiência, para que os aplicativos sejam entregues em semanas e até dias.
Flask-BDA fornece desenvolvimento Full-stack de; UI, processos de negócios, lógica personalizada e modelos de dados para criar aplicativos multiplataforma prontos para uso. Fornecendo um scaffold onde você pode adicionar seu próprio código personalizado quando necessário. Sem nenhum lock-in nunca.
Com ambientes de desenvolvimento pré-configurados, reduzimos a dificuldade (e o custo) de chegar ao mercado, proporcionando flexibilidade para escolher onde e como implantar.
Gratuito e amigável ao desenvolvedor, o Flask-BDA é uma ferramenta de desenvolvimento de aplicativos gratuita e disponível com uma licença amigável ao desenvolvedor.
Flask-BDA é totalmente GRATUITO para uso em projetos comerciais e pessoais.
No entanto, o desenvolvimento de software é sempre um exercício dispendioso:
- Você precisará pagar um ou vários desenvolvedores de software, analistas de negócios, designers, gerentes de projeto e outros membros da equipe para construir seu produto.
- Seu produto nunca termina. Um projeto de software sempre precisará de desenvolvimento contínuo.
- Quando você entrega um produto, sua concorrência já está trabalhando em recursos novos e aprimorados, e você precisa ser capaz de se manter à frente ou pelo menos acompanhar, ou os usuários passarão para sua concorrência.
- Assim que começar a usar seu produto, você e sua equipe pensarão em novos recursos que o tornarão ainda melhor e aprimorarão seus processos.
- Manutenção continuada. À medida que os usuários usam o produto, eles encontrarão maneiras de quebrá-lo nas quais você não pensou e que precisam ser consertadas.
| Tamanho do projeto | Custo inicial | Custo contínuo |
|---|---|---|
| Projetos de pequeno porte (2 a 6 semanas de desenvolvimento) | US$ 11.250 | US$ 563 - US$ 1.125 (±10%) / por mês |
| Projetos de médio porte (2 a 4 meses de desenvolvimento) | US$ 33.750 | US$ 1.563 - US$ 3.375 (±10%) / por mês |
| Projetos de grande porte (6 a 18 meses ou mais de desenvolvimento) | US$ 156.250 | US$ 3.375 - US$ 15.625 (±10%) / por mês |
| Tamanho do projeto | Custo inicial | Custo contínuo |
|---|---|---|
| Projetos de pequeno porte (1 a 3 semanas de desenvolvimento) | US$ 3.750 | US$ 188 - US$ 375 (±10%) / por mês |
| Projetos de médio porte (1 a 3 meses de desenvolvimento) | US$ 11.250 | US$ 375 - US$ 1.125 (±10%) / por mês |
| Projetos de grande porte (2 a 6 meses ou mais de desenvolvimento) | US$ 52.084 | US$ 1.125 - US$ 5.208 (±10%) / por mês |
Com o Flask-BDA, você NÃO PERDE NENHUMA flexibilidade do "Desenvolvimento Normal", pois ele usa padrões de desenvolvimento padronizados e tecnologias testadas e comprovadas.
Flask-BDA usa muitas tecnologias de código aberto e aproveita as pilhas de tecnologia existentes para que você possa encontrar facilmente outros desenvolvedores que usam as mesmas tecnologias. Como resultado, você não precisa pagar taxas de licença caras ou custos ambientais, independentemente de quanta receita sua empresa obtiver ou de onde você atua.
Comece com um ambiente de desenvolvimento pré-configurado rápido e fácil em minutos.
Nenhuma configuração complexa necessária. Apenas python (sugerido 3.8.6) é necessário.
Atualize suas configurações: conexões de banco de dados e configurações de aplicativos.
Crie seus próprios módulos e estruturas de dados (modelo de dados) permitindo utilizar diferentes bancos de dados.
Gerado automaticamente totalmente funcional:
- Páginas
AdmineMobileREST APIscom front-end SwaggerGraphQL APIcom front-end GraphiQL facilmente gerenciado por módulo.
Configure páginas de acordo com suas necessidades específicas e compartilhe-as facilmente com sua equipe e clientes.
Escreva seu próprio código personalizado em um módulo isolado, para não afetar outros módulos,
Integre facilmente módulos em diferentes projetos.
Use a mesma base de código para implantar em:
- Área de trabalho
- Rede
- Móvel
Os ambientes incluem:
- Docker
- AWS sem servidor
- Oceano Digital
- Heroku
- Hospedagem compartilhada.
pip esteja instalado (o pip já deve estar instalado porque vem com as versões mais recentes do python), caso não esteja, instale-o aqui: https://pip.pypa.io/en/stable/installing/python -m pip --version
NOTA: Esta documentação pressupõe que você esteja executando
pip3comopip, portanto, todas as instruções são escritas compip. Se você quiser fazerpip3rodar ao chamarpip, a partir do seu tereminal, você pode criar um link simbólico parapip3a partir depip:
pip install --upgrade pipsudo , por exemplo: sudo pip install --upgrade pip nano ~ /.bash_profile
No arquivo, cole o seguinte:
alias pip= ' pip3 '
alias python= ' python3 '
NOTA: Pode ser necessário remover o python 2.7 no MacOS, pois ele está pré-instalado em minhas distribuições, o que foi muito útil para conseguir isso:
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 'e execute o seguinte comando para remover todos os links:
cd /usr/local/bin/
ls -l /usr/local/bin | grep ' ../Library/Frameworks/Python.framework/Versions/2.7 ' | awk ' {print $9} ' | tr -d @ | xargs rmDepois de instalar o Python e
pip, você precisará instalar uma dependência para que as funções de linha de comando do Flask-BDA sejam executadas corretamente:
pip install click
Outras dependências que você pode querer instalar globalmente (mas que devem ser executadas automaticamente ao criar um projeto) incluem:
pip install virtualenv
pip install flaskwebgui
pip install pyinstaller
Para começar a construir seu primeiro projeto com Flask-BDA, siga as etapas simples abaixo para criar seu próprio ambiente de desenvolvimento pré-configurado e funcionando em minutos.
Neste início rápido, criaremos um projeto chamado
"My Awesome Project". No entanto, você pode chamar o projeto do que quiser.
create_project.py necessário e o executará para ajudá-lo a iniciar um projeto"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 necessário e o executará para ajudá-lo a iniciar um projeto"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: Se você não preencheu um nome de projeto válido, você será solicitado a fazê-lo:
- Preencha o nome do seu projeto quando solicitado, por exemplo:
- Certifique-se de colocar aspas no nome do seu projeto para evitar erros, por exemplo:
"My Awesome Project"
Invalid Project Name !
Please enter a valid project name :
"My Awesome Project"Nota: Você notará que isso cria uma pasta no mesmo caminho do arquivo: "create_project_git.py". Esta pasta estará em letras minúsculas e terá removido todos os caracteres especiais e substituído espaços por sublinhados, por exemplo:
my_awesome_project
Nota: Durante o desenvolvimento, você pode querer usar outro branch ou repositório inteiramente. Isso pode ajudar nos testes ou se você se separou do projeto principal do Flask-BDA.
- Você pode especificar o
Owner,RepoeBranchao criar um novo projeto.
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: Ainda a ser testado para todos os tipos de conexão!
As conexões de banco de dados são rápidas e fáceis no Flask-BDA. Você pode ter um ou vários bancos de dados, e diferentes locatários podem ter suas próprias conexões de banco de dados, bem como seu próprio tipo de banco de dados (SQLite, MySQL, SQL Server, PostgreSQL)
Por padrão, o Flask-BDA possui um banco de dados SQLite configurado. Na verdade, isso ocorre porque você não precisa de infraestrutura adicional para configurá-lo e começar a trabalhar, tornando o SQLite uma escolha rápida e fácil.
Para alterar o banco de dados padrão:
flaskbda ), usuário ( flaskbda_user ) e senha ( password )config.pyDATABASE_ENGINE para SQLite e comente no mysql DATABASE_ENGINE .DATABASE_NAME para SQLite e comente no mysql:DATABASE_HOSTDATABASE_PORTDATABASE_USERNAMEDATABASE_PASSWORDDATABASE_NAMESQLALCHEMY_DATABASE_URI para SQLite e comente 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 alterar o banco de dados padrão:
flaskbda ), usuário ( flaskbda_user ) e senha ( password )config.pyimport pyodbc .DATABASE_DRIVER .DATABASE_ENGINE para SQLite e, por exemplo, comente no SQLServer DATABASE_ENGINE .DATABASE_NAME para SQLite e comente no SQLServer:DATABASE_HOSTDATABASE_PORTDATABASE_USERNAMEDATABASE_PASSWORDDATABASE_NAMESQLALCHEMY_DATABASE_URI para SQLite e comente try e except para SQLServer SQLALCHEMY_DATABASE_URI .Nota: se você estiver executando e tentando se conectar ao
SQLEXPRESS. Remova o comentário da variável SQLServerSQLEXPRESS. Isso será tratado notryeexceptpara criar oSQLALCHEMY_DATABASE_URIcorreto
Nota: se você deseja autenticação do Windows. Remova o comentário da variável SQLServer
TRUSTED_CONNECTION. Isso será tratado notryeexceptpara criar oSQLALCHEMY_DATABASE_URIcorreto
##########
# 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'Certifique-se de que sua instância MS-SQL tenha direitos de conexão remota configurados e referência habilitada (aqui)[https://knowledgebase.apexsql.com/configure-remote-access-connect-remote-sql-server-instance-apexsql-tools/ ]:
Certifique-se de que as configurações de "gerenciamento de configuração do servidor SQL" estejam configuradas corretamente
NOTA: Sua instalação exigirá
Client Tools Connectivity, se você não conseguir encontrar "gerenciamento de configuração do servidor SQL", talvez seja necessário modificar sua instalação para incluirClient Tools Connectivity
- se você não conseguir encontrar o "", talvez seja necessário usar a ferramenta "Usar o gerenciamento do computador". para acessá-lo.
- isso parece ser um problema do Windows 10
Multitenancy é uma arquitetura de software na qual uma única instância de software é executada em um servidor e atende vários locatários (clientes). O software multilocatário permite que várias instâncias independentes de um ou vários aplicativos operem em um ambiente compartilhado.
Flask-BDA oferece suporte a multilocação particionada verticalmente. O particionamento vertical significa que cada locatário possui um banco de dados diferente (e uma cadeia de conexão de banco de dados).
Por padrão, o Flask-BDA se conecta a um locatário chamado
default. Isso é feito usando o objetoSQLALCHEMY_BINDS(encontrado emconfig.py), que deve ter os detalhes de conexão específicos necessários para cada locatário. Os detalhes da conexão padrão são combinados em uma string chamadaSQLALCHEMY_DATABASE_URI, que foi criada para permitir uma configuração rápida e fácil de locatário único.
Você pode usar essa mesma estrutura, no entanto, para ter vários locatários, você pode adicioná-los rapidamente ao objeto
SQLALCHEMY_BINDS. Para adicionar um novo inquilino, basta:
SQLALCHEMY_BINDS , com o nome do locatário e os detalhes da string de conexão SQLALCHEMY_BINDS = {
"default" : SQLALCHEMY_DATABASE_URI ,
"client1" : 'sqlite:///databases/sqlite/client1.db' ,
}Agora você pode interagir com um banco de dados de locatário isolado adicionando o argumento
organization=à sua URL, por exemplo:example.com?organization=client1ondeclient1é o nome que você adicionou no objetoSQLALCHEMY_BINDS.
Isso funciona interceptando
@app.before_requestemapp/_init_.pye alterando a ligação do mecanismo de banco de dados usandodb.choose_tenant(g.organization)deapp/mod_tenancy/multi_tenant.pyusando a variável globalg.organizationque obtém definido buscando o argumento da URLorganization. Isso permite que o mesmo código no aplicativo seja usado pelo banco de dados de cada locatário, mantendo os dados separados.
Às vezes você precisa interagir com diferentes bancos de dados em uma única função (especialmente ao integrar sistemas ou ler dados de diferentes fontes).
Por padrão, todos os controladores terão
MultiBindSQLAlchemyimportado.
# import multiple bindings
from app . mod_tenancy . multi_bind import MultiBindSQLAlchemyNa importação há um código comentado destinado a ajudá-lo a implementar rapidamente a vinculação a diferentes bancos de dados em uma única função. Primeiramente, a ligação do banco de dados precisa ser adicionada ao objeto
SQLALCHEMY_BINDS. Consulte os Bancos de Dados Isolados com a mesma funcionalidade para entender melhor como adicionar novos bancos de dados ao objetoSQLALCHEMY_BINDS.
Você pode então criar um novo objeto anexado ao objeto
dbseguindo a estrutura dedb.<binding>por exemplo:db.firstondefirsté o nome ao qual deseja fazer referência à ligação no restante do código. Você pode então atribuir esta variável aoMultiBindSQLAlchemy, por exemplo:db.first = MultiBindSQLAlchemy('first').
Isso agora permite que você chame código personalizado que permitirá acessar a nova ligação do banco de dados, bem como o inquilino principal em uma única função, por exemplo:
db.first.execute(...), onde você pode executar código SQL bruto.
db . first = MultiBindSQLAlchemy ( 'first' )
##################################################
## this will only work for the execute function ##
##################################################
db . first . execute (...)**Nota: ** isso só funcionará para a função
execute, existem algumas técnicas avançadas para ainda usar o SQLAlchemy ORM que podem ser encontradas aqui: SQLAlchemy execute tutorial
Um módulo é um componente independente, facilitando o gerenciamento à medida que o programa cresce. Os módulos no Flask-BDA ajudam você a criar: um modelo de dados, rotas e funções associadas para controlar a lógica e visualizações.
Quando você cria um novo módulo CRUD, todos os elementos da pasta
create_module_templatesão copiados para o diretório app e renomeados para o nome do módulo fornecido, substituindo todos os valoresxyzpelo nome do seu módulo e adicionando informações adicionais do modelo de dados conforme descrito abaixo
<Path To>/<my_awesome_project>/create_module_json.py<Path To>/<my_awesome_project>/ é o caminho para o projeto que você criou 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 : Observação: isso continuará em loop até você digitar e enviar as palavras exatas: "STOP_CREATING_FIELDS".
Isso permite que você crie vários campos para o seu módulo de forma rápida e fácil.
Os campos acima devem mostrar que diferentes tipos de campo interagem e criam vários campos.
Obs: Os relacionamentos serão sempre feitos no
iddo modelo fornecido.Uma ForeignKey é criada no campo, bem como um relacionamento lento entre o campo
idfornecido pelo 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: você também pode gerar um módulo a partir de um arquivo JSON em "app/generated_config/models//models.json", onde está o nome do módulo que você inseriu para fazer isso, abra e execute o arquivo:
<Path To>/<my_awesome_project>/create_module.py* Onde<Path To>/<my_awesome_project>/é o caminho para o projeto que você criou * Preencha as instruções, por exemplo:
cd < Path To > / < my_awesome_project > /
python create_module . py - - module = projectsIsso criará os arquivos e pastas necessários conforme descrito abaixo nas alterações do aplicativo
Arquivos e pastas da pasta
create_module_templatesão criados para o móduloProjectse depois adicionados à pastaappIsso criará visualizações CRUD de administração com scaffold, uma API REST (com inserção e atualização em massa), uma API GraphQL e visualizações e lógica voltadas ao público para permitir que você interaja imediatamente com o módulo que você criou.
No painel de administração, você poderá realizar as seguintes ações: Criar, Ler, Atualizar e Excluir ("CRUD") para seu novo módulo.
As visualizações públicas permitem que usuários convidados (usuários não logados) tenham uma visão das informações fornecidas
└── `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
A criação de um novo módulo fornecerá 3 maneiras de interagir com seu novo sistema
Public,Admin,REST APIeGraphQL API.
Para acessá-los, eles exigirão que o aplicativo esteja sendo executado em um ambiente.
A visualização
Publicé uma visualização não autenticada dos dados fornecidos no módulo.
xyz é o nome do módulo):../xyz/public_list As visualizações
Adminsão visualizações autenticadas dos dados fornecidos no módulo.
xyz é o nome do 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 As visualizações
APIsão uma lista de endpoints da API REST, documentação associada e playground de execução.
Flask BDA usa SwaggerUI para apresentar a API REST a um usuário/cliente.
O SwaggerUI permite que qualquer pessoa – seja sua equipe de desenvolvimento ou seus consumidores finais – visualize e interaja com os recursos da API sem ter nenhuma lógica de implementação em vigor. Em vez disso, ele é gerado automaticamente a partir de sua especificação OpenAPI (anteriormente conhecida como Swagger), com documentação visual facilitando a implementação de back-end e o consumo do lado do cliente.
Para acessar o SwaggerUI:
<base_URL>/api/docs para acessar a API REST do SwaggerUI, por exemplo: http://localhost:5000/api/docs .Para acessar a API REST sem 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 As visualizações
graphqlsão visualizações GraphiQL, endpoints de API, documentação associada e playground de execução.
Flask BDA usa grafeno-python e GraphiQL para apresentar a API GraphQL a um usuário/cliente, fornecendo uma API simples, mas extensível, para facilitar a vida dos desenvolvedores.
GraphQL é uma linguagem de consulta de dados que oferece uma alternativa às arquiteturas REST e de serviços da web ad-hoc.
Para acessar o GraphiQL:
<base_URL>/graphql para acessar o GraphiQL, API GraphQL, ex: http://localhost:5000/graphql .Para acessar a API GraphQL sem GraphiQL:
<base_URL>/../graphqlmod_graphql > query > Query > all_xyz../graphqlmod_graphql > mutation > Mutation > createXyz Atualmente, existem 7 ambientes prontos para uso suportados (com planos para mais suporte em breve) com instruções sobre como configurar cada um para Windows / Linux / Mac , e você pode executá-los ao mesmo tempo, se desejar.
Para criar e desenvolver uma aplicação local, estamos usando o virtualenv. Uma ferramenta para criar ambientes python virtuais isolados.
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 exemplo: 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
Alguns serviços de hospedagem compartilhada oferecem a capacidade de executar aplicativos Python em seus servidores. Eu pessoalmente usei A2hosting. O suporte deles tem sido incrível e o preço dos recursos é um dos melhores que já encontrei.
Observação: você não está limitado ao A2 como opção de hospedagem compartilhada. No entanto, foi aqui que testei o Flask-BDA e tive minha experiência em carregar e executar uma opção de hospedagem compartilhada. Se a sua opção de hospedagem compartilhada oferece um conjunto semelhante de recursos, sinta-se à vontade para usá-los.
Para A2, você precisará configurar seu servidor para executar um aplicativo python que pode exigir alguma configuração, por exemplo.
Para fazer seu aplicativo personalizado funcionar:
Nota: Em um ambiente
Linuxo requisitopyodbcnão funcionará por padrão. Por causa disso, e por ser um ambiente compartilhado - você pode não ter direitos para adicionar os requisitos para fazê-lo funcionar, a maneira mais fácil de garantir que a instalação não falhe é comentar esse requisito no servidor.
requirements.txt , pesquise pyodbc e coloque um # com um espaço antes do nome do pacote. # pyodbc==4.0.30
requirements.txtSSH na qual você efetuou login na etapa anterior pip install --upgrade pip
pip install --no-cache-dir -r requirements.txt
Setup Python App novamenteApplication startup file para run_shared_server.pyPara criar e implantar um aplicativo em contêiner, estamos usando o Docker, que ajuda desenvolvedores e equipes de desenvolvimento a criar e enviar aplicativos. Além disso, o Docker é usado para a construção e compartilhamento de aplicativos e microsserviços em contêineres.
Nota: Se você estiver usando o Github e tiver o docker instalado (detalhes sobre como instalar posteriormente na documentação), você obterá uma nova imagem construída toda vez que fizer
pushou fizer umpull_requestno Github, que está configurado no arquivo:docker-image.ymlno entanto, se você quiser fazer isso manualmente, siga as etapas abaixo:
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: Ainda em desenvolvimento
Para criar e implantar um aplicativo sem servidor, estamos usando o Serverless Framework, que permite um desenvolvimento sem atrito sem servidor, permitindo que você crie facilmente aplicativos que são escalonados automaticamente em infraestrutura de nuvem de última geração e baixo custo.
A estrutura Serverless é uma ferramenta de código aberto que fornece fácil desenvolvimento e implantação YAML + CLI para AWS, Azure, Google Cloud, Knative e muito mais.
Nota: Pode ser necessário ajustar as strings padrão do banco de dados antes de del=polying, pois o serverless não suporta "SQLite", pois a função não mantém o estado.
Para atualizar as strings do banco de dados, consulte [Config]
npm update -g serverless
npm update -g serverless
choco install serverless
Nota: Se o pacote não for instalado, pode ser necessário executar o comando como administrador.
pressione a "tecla Windows" digite "cmd", "clique com o botão direito" na palavra "Prompt de comando" e selecione a opção "Executar como administrador" e siga novamente os passos anteriores
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: Ainda em desenvolvimento
Digital Ocean é uma plataforma como serviço (PaaS). Desenvolva, gerencie e dimensione seus aplicativos na plataforma de nuvem completa da DigitalOcean. A Digital Ocean oferece preços simples e previsíveis. Crie e lance com confiança produtos de computação escaláveis na nuvem, bancos de dados totalmente gerenciados, opções de armazenamento altamente disponíveis e escaláveis e muito mais. Com máquinas virtuais com uma boa quantidade de memória ajustada para hospedar e dimensionar aplicativos e bancos de dados, a Digital Ocean oferece soluções simples para problemas complexos.
Para criar e implantar um aplicativo no Heroku a partir do terminal, você precisará:
138.197.67.25NOTA se você não se conectou via SSH deverá receber a
passwordatravés do e-mail com o qual cadastrou a conta, na Digital Ocean.
cd < Path To > / < my_awesome_project > /
scp -r < my_awesome_project > root@ < ip_address > :/
ssh root@ < ip_address >
Onde
<Path To>/<my_awesome_project>/é o caminho para o projeto que você criou e onde<ip_address>são os droplets <ip_address>, por exemplo:138.197.67.25
NOTA: Siga todos os avisos previstos pelo SSH, como permitir o acesso do servidor remoto.
Depois de fazer login, você poderá ver um terminal com:
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
Onde
5000é o número da porta
e<droplet_name>é o nome
cd < Path To > / < my_awesome_project > /
scp -r < my_awesome_project > root@ < ip_address > :/
ssh root@ < ip_address >
Onde
<Path To>/<my_awesome_project>/é o caminho para o projeto que você criou e onde<ip_address>são as gotículas <PP_Address> por exemplo:138.197.67.25
NOTA: Siga todos os avisos previstos pelo SSH, como permitir o acesso do servidor remoto.
Depois de fazer login, você poderá ver um terminal com:
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
Onde
5000é o número da porta
e<droplet_name>é o nome
Nota: Ainda em desenvolvimento
Heroku é uma plataforma como um serviço (PaaS). O Heroku permite que você comece com um compromisso zero, pague à medida que passa sem bloqueio. Desenvolvedores, equipes e empresas de todos os tamanhos podem usar o Heroku para implantar, gerenciar e escalar aplicativos. Esteja você construindo um protótipo simples ou um produto crítico de negócios, a plataforma totalmente gerenciada da Heroku oferece um caminho simples para fornecer aplicativos rapidamente.
Para criar e implantar um aplicativo para Heroku a partir do terminal, você precisará baixar e instalar a CLI Heroku. Para verificar a instalação, você pode verificar a versão Heroku do terminal:
heroku --version
Nota: verifique se você alterou sua conexão com o banco de dados, pois o Heroku não sugere o uso do SQLite, pois os dados podem ser perdidos nos arquivos. A Heroku oferece um banco de dados PostGres gratuito. Veja seus planos e escolha o plano certo para você, pois existem limites nos diferentes planos.
cd < Path To > /my_awesome_project
heroku login
<my_awesome_project-flask-bda-app> , onde <my_awesome_project-flask-bda-app> é o nome que você deu ao seu projeto.heroku create my_awesome_project-flask-bda-app
git push heroku master
<my_awesome_project-flask-bda-app> é o nome que você deu ao seu projeto. cd < Path To > /my_awesome_project
sudo snap install --classic heroku
heroku login
<my_awesome_project-flask-bda-app> , onde <my_awesome_project-flask-bda-app> é o nome que você deu ao seu projeto.heroku create my_awesome_project-flask-bda-app
git push heroku master
<my_awesome_project-flask-bda-app> é o nome que você deu ao seu projeto. cd < Path To > /my_awesome_project
brew tap heroku/brew && brew install heroku
heroku login
<my_awesome_project-flask-bda-app> , onde <my_awesome_project-flask-bda-app> é o nome que você deu ao seu projeto.heroku create my_awesome_project-flask-bda-app
git push heroku master
<my_awesome_project-flask-bda-app> é o nome que você deu ao seu projeto. Para aplicativos móveis nativos, estamos usando o React-nativo. Especificamente, usamos a Expo como uma estrutura e uma plataforma para aplicativos React Universal. É um conjunto de ferramentas e serviços criados em torno de plataformas nativas e nativas que ajudam a desenvolver, criar, implantar e iterar rapidamente em aplicativos iOS, Android e Web da mesma base de código JavaScript/TypeScript.
Temos notificações de push pré-defet, então você não precisa. Isso significa que é mais rápido e mais fácil para você começar e funcionar. Além disso, estamos aproveitando o pacote de notificações de exposição padrão que permite uma implementação e abordagem simplificadas.
As vantagens incluem fluxos de trabalho/processos de construção e teste mais rápidos, testes remotos ao desenvolver com as atualizações do Over the Air (OTA) com alterações visíveis na economia durante o desenvolvimento.
No entanto, existem algumas desvantagens e limitações que a Expo está ciente disso e as descreve muito bem. Sugerimos revisar essas limitações antes de usar nosso método pré-criado.
Crie um projeto que seja executado nativamente em todos os dispositivos de seus usuários.
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
Como o Flask BDA não dita onde você deve hospedar seu site, você precisará informar ao seu aplicativo móvel para onde ir.
No exemplo do QuickStart, criamos um projeto chamado
"My Awesome Project". No entanto, você pode ter chamado o projeto de outra coisa. Isso teria criado uma pasta onde o nome está em minúsculas e retirou todos os caracteres especiais e substituiu espaços por sublinhados, por exemplo:my_awesome_project.
Para o celular, criamos automaticamente uma pasta
"_mobile_app"automaticamente, onde o prefixo da pasta é o nome do seu projeto, por exemplo,my_awesome_project_mobile_app. Isso é para evitar problemas com opackage.jsonde configuraçãoServerlesse permitir que você não implante todo o código para um aplicativo móvel no seu servidor da web.
Se você ainda está em desenvolvimento e/ou ainda não escolheu um provedor de serviços para hospedagem, poderá usar: NGrok para criar um URL temporário de desenvolvimento público que túneis para o seu ambiente local. O NGROK expõe servidores locais atrás de Nats e Firewalls à Internet pública por túneis seguros. Isso permite que você demonstre sites em um URL público e teste aplicativos móveis conectados ao seu back -end em execução localmente sem implantar.
Inicie o servidor de desenvolvimento local seguindo as instruções do ambiente local
Se você não se registrou no NGrok antes:
Se você já se registrou, mas não o instalou:
Quando o terminal NGrok estiver aberto, crie um túnel do servidor local para o NGrok
5000 padrão, substitua o número após http para permitir que o túnel correto seja criado. 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: A versão gratuita mantém este servidor vivo por 2 horas, portanto, pode ser necessário seguir esse processo no futuro e, se você for pressionar esse URL para o seu "repo", poderá não funcionar para a próxima pessoa.
my_awesome_project_mobile_appapp.json e editar a linha 2 "server_base_url": "https://github.com/RyanJulyan/Flask-BDA" substituindo https://github.com/RyanJulyan/Flask-BDA por seu próprio nome do servidor.expo em seu próprio telefone celular pesquisando "Expo" na Apple ou Google Play Store:iOS Vá para: https://apps.apple.com/app/apple-store/id982107779Android vá para: https://play.google.com/store/apps/details?id=host.exp.exponentDepois de instalar o aplicativo no seu telefone, você pode iniciar um servidor de desenvolvimento em sua máquina local.
cd < Path To > /my_awesome_project_mobile_app
expo start
cd < Path To > /my_awesome_project_mobile_app
expo start
Isso abrirá uma página da web com um código QR nele. Isso permitirá que você use o aplicativo Expo se estiver no Android ou use a câmera se estiver no iOS para digitalizar o código e abrir seu aplicativo diretamente no servidor de desenvolvimento.
Nota: Se você deseja que as pessoas não estejam na sua rede possam digitalizar e testar o aplicativo remotamente, pressione o botão da guia
tunnelacima do código QR.
Parte das recomendações é garantir que as imagens sejam otimizadas. Para fazer isso, a Expo recomendou o pacote Expo-Otimize, que pode ajudar na otimização de imagens. Além disso, a otimização de imagens pode melhorar seu aplicativo nativo TTI (ou tempo até a interação), o que significa menos tempo nas telas de respingos e entrega mais rápida sobre conexões de rede ruins.
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 criar e desenvolver um aplicativo de desktop, estamos usando o Flaskwebgui. Uma ferramenta para criar e executar seu aplicativo Web Flask em um invólucro Chrome. Para distribuir o aplicativo de desktop, estamos usando o PyInstaller. O PyInstaller congela (pacotes) Aplicativos Python em executáveis independentes no Windows, GNU/Linux, Mac OS X, FreeBSD, Solaris e AIX.
Cada implantação precisa ser criada na plataforma específica que você deseja executá -la. Criamos scripts que permitirão gerenciar essas implantações colocando as pastas
buildedistnas pastas pai para a respectiva plataforma. Essas pastas serão prefixadas comdesktop_seguido pela plataforma. Isso é feito apenas para permitir que você gerencie a distribuição e a criação de processos para as plataformas específicas e não as substitua ao criar em diferentes plataformas.
Para permitir que a exportação para o desktop funcione corretamente, exigimos algumas alterações de código. Por padrão, o Flask-BDA é destinado ao desenvolvimento da Web e da Web e implementamos um limitador de taxa no site. Infelizmente, você precisa de um servidor para avaliar o limite e, como está exportando o sistema para um aplicativo de desktop, ele não está executando um servidor.
Como tal, você precisa remover todas as referências ao limitador. Estes podem ser encontrados no
app/__init__.py. Para fazer isso, abra o arquivo em um editor de texto e comente as seguintes linhas:
# 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: Se você adicionou um limitador personalizado, pesquise
@limiter.limit, que seria encontrado em seus controladores. Você precisará comentar todas essas referências e as referências de importação, por exemplo:from app import limiter
Isso permitirá que você exporte o aplicativo como um arquivo executável de desktop sem erros.
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 exemplo: 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 exemplo: 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
Isso abrirá uma janela maximizada que será executada como um aplicativo de desktop normal. Isso usará o navegador Chrome instalado localmente para servir o conteúdo.
Por padrão, este aplicativo será servido na porta
7000. No entanto, você pode editar a porta no arquivorun_desktop.pyse isso entrar em conflito com algum aplicativo existente.
Se você incluir pacotes python adicionais em seu projeto, não se esqueça de executar
pip freezedo seu terminal para garantir que você obtenha os pacotes corretos para suas implantações
pip freeze > requirements.txt
NOTA: É sugerido que você instale e congelasse pacotes Python adicionais de um ambiente virtual e não globalmente. Isso mantém seus
requirements.txtPequenos e limitados aos pacotes que você está usando em seu projeto específico.
O Flask BDA usa Swaggerui por padrão para ajudar e apresentar a API a um usuário/cliente.
O Swaggerui permite que qualquer pessoa - seja sua equipe de desenvolvimento ou seus consumidores finais - visualizar e interagir com os recursos da API sem ter nenhuma lógica de implementação em vigor. Em vez disso, é gerado automaticamente a partir da sua especificação OpenAPI (anteriormente conhecida como Swagger), com a documentação visual facilitando a implementação de back-end e o consumo do lado do cliente.
Para acessar o swaggerui:
<base_URL>/api/docs para acessar a API Swaggerui, por exemplo: http://localhost:5000/api/docsMuitos desenvolvedores preferem o Postman a Swaggerui para testar e integrar APIs ao seu código. Ajudamos fornecendo uma exportação de coleta direta para o Postman.
Para importar a coleção no Postman:
Import... (Ctrl+O)Link nas guias<base_URL>/api/postman , por exemplo: http://localhost:5000/api/postman<base_URL>/aswagger.json , por exemplo: http://localhost:5000/swagger.json e importe isso diretamente para o 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> e <path to the downloaded Postman file> são caminhos de arquivo físico em sua máquina local.ContinueImportIsso importará uma coleção Postman, que ficará disponível no lado esquerdo como uma pasta (com subpastas de cada um dos pontos de extremidade que você criou).
Você pode gerar código para muitas faixas e estruturas diferentes usando o Postman. Esses idiomas incluem, mas não estão limitados a:
Permitindo que você integre sua API recém -criada com projetos existentes
Às vezes, você precisa fazer solicitações externas (por exemplo, uma API externa). Você pode abordar isso usando solicitações AJAX, mas às vezes precisa fazer essas solicitações do lado do servidor, por exemplo, se você deseja atualizar as conversões em moeda automaticamente. Quando você deseja acessar as APIs externas através do servidor, não deseja confiar em um usuário ativamente na página da web para enviar o comando. Em vez disso, você deseja que o servidor seja capaz de ativar este comentário. Para conseguir isso, usamos o módulo de solicitações.
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 )Solicitações do AJAX, normalmente uma solicitação HTTP feita por (navegador-client) em JavaScript que usa XML/JSON para solicitar dados e/ou dados de resposta de um sistema interno ou externo. As solicitações de AJAX são feitas usando </> htmx por padrão.
O HTMX é uma biblioteca sem dependência que permite acessar o AJAX, transições CSS, WebSockets e eventos enviados pelo servidor diretamente no HTML, usando atributos para que você possa criar interfaces modernas do usuário com a simplicidade e o poder do hipertexto. Para detalhes sobre como usar o HTMX, consulte os documentos e para obter uma referência completa sobre a funcionalidade, consulte https://htmx.org/reference/
Você pode usar o HTMX para implementar muitos padrões de UX comuns, como pesquisa ativa:
< 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 > Essa entrada chamada Q emitirá uma solicitação para /trigger_delay 500 milissegundos após um evento de chave se a entrada tiver sido alterada e inserir os resultados na div com os resultados de pesquisa de ID.
Apesar das vantagens da criptografia simétrica, há uma falha nesse método que permite que indivíduos não autorizados acessem as chaves secretas de uma mensagem.
Uma das maneiras mais eficazes de impedir o acesso não autorizado às teclas secretas de uma mensagem é implementar uma função unidirecional como o algoritmo Diffie-Hellman. Este método apenas permite que o remetente e o receptor descriptografem a mensagem.
As funções unidirecionais são normalmente implementadas usando um tipo de algoritmo que lhes permite calcular uma saída para cada entrada recebida. No entanto, esse método não é viável para derivar o resultado exato de uma chave aleatória.
O teste é uma parte vital para garantir que um projeto seja executado com sucesso
Existem 3 aspectos dos testes fornecidos no Flask BDA:
Nota: Para executar manualmente o Python
unittest, verifique se você instalou os ambientes locais
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 executar manualmente o Python
unittest, verifique se você instalou os ambientes locais
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
Execução de arquivo único e configuração
Projeto Flask Starter, que constrói uma estrutura de pastas do projeto com
992px500px@mobile_template , permitindo que as vistas do modelo sejam adaptadas para uma melhor experiência móvel, se necessário.{% if request.MOBILE %}True{% else %}False{% endif %}config.py para acesso rápido e gerenciamento das variáveis ambientais e ambientais e SEO padrãoconfig.py Crie arquivos e pastas de módulo personalizado que se encaixem na estrutura do projeto Flask a partir do arquivo create_module.py com prompts para criar o seguinte:
public_listindexcreatestoreshoweditupdatedestroygetpostgetupdatedeletebefore e after das alterações em um modelo de dados event listeners para:InsertUpdateDeletepublic_listindexcreatestoreshoweditupdatedestroygetpostgetupdatedeletepostupdategetpublic_list.html (elementos da lista)index.html (elementos da lista)create.html (formulário de elemento único)show.html (elemento único)edit.html (formulário de elemento único)api/docs (URL)Suporte ao navegador (última versão principal não morta)
└── `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
Um módulo faz parte de um programa. Os programas são compostos por um ou mais módulos desenvolvidos de forma independente que, quando combinados, criam o programa.
Um módulo é um componente independente, facilitando o gerenciamento à medida que o programa cresce.
Os módulos no Flask-BDA ajudam você a criar: um modelo de dados, rotas e funções associadas para controlar a lógica e as visualizações
Os controladores podem agrupar a lógica de manuseio de solicitações relacionadas em uma única classe. Por exemplo, uma classe UserController pode lidar com todas as solicitações recebidas relacionadas aos usuários, incluindo mostrar, criar, atualizar e excluir usuários.
Crie, leia, atualize e exclua ("Crud")
LINGO é a verificação automatizada do seu código -fonte para erros programáticos e estilísticos. Isso é feito usando uma ferramenta de fiapos (também conhecida como Linter). Uma ferramenta de fiapos é um analisador básico de código estático.
Lint, ou um linhador, é uma ferramenta de análise de código estática usada para sinalizar erros de programação, erros, erros estilísticos e construções suspeitas.
Na programação de computadores, o teste de unidade é um método de teste de software pelo qual unidades individuais de código -fonte - set de um ou mais módulos de programa de computador juntamente com dados de controle associados, procedimentos de uso e procedimentos operacionais - são testados para determinar se eles são adequados para uso .
Uma plataforma de desenvolvimento de baixo código fornece um ambiente de desenvolvimento para criar um software de aplicativo por meio de interfaces e configurações programáticas ou gráficas do usuário, em vez da programação tradicional de computador codificada à mão.
Ficaríamos encantados se você contribuísse com o projeto de uma ou todas essas maneiras:
Veja as informações de licença para Python 3. (Https://docs.python.org/3.8/license.html) e outros acordos legais (https://www.python.org/about/legal/)
Visualize informações de licença para o Docker. (https://www.docker.com/legal/components-licenses) e outros acordos legais (https://www.docker.com/legal)
Como em todas as imagens do Docker, elas provavelmente também contêm outro software que pode estar sob outras licenças (como Bash, etc., a partir da distribuição base, juntamente com quaisquer dependências diretas ou indiretas do software primário que estiver sendo contido).
Algumas informações adicionais de licença que poderiam ser detectadas automaticamente podem ser encontradas no diretório/ diretório do Python/ Python do repositório.
Quanto a qualquer uso de imagem pré-criado, a responsabilidade do usuário da imagem é garantir que qualquer uso dessa imagem esteja em conformidade com quaisquer licenças relevantes para todo o software contido.
Veja as informações da licença para a estrutura sem servidor e outros acordos legais (https://app.serverless.com/legal/terms).
É de responsabilidade do usuário garantir que siga a política de uso aceitável (https://app.serverless.com/legal/aup)
Veja as informações de licença para a estrutura da Expo e outros acordos legais (https://github.com/expo/expo/blob/master/license).
O Flask-BDA é criado e distribuído pela licença Flask-BDA, favorável ao desenvolvedor. A licença Flask-BDA é derivada da popular licença Apache 2.0.
A licença Flask-BDA é o requisito legal para você ou sua empresa usar e distribuir trabalhos de Flask-BDA e derivados, como os aplicativos que você faz com ela. Seu aplicativo ou projeto pode ter uma licença diferente, mas ainda precisa cumprir o original.
Inclusão de aviso de licença e direitos autorais
A licença Flask-BDA exige que você deva incluir o aviso de licença e direitos autorais com todas as cópias do Flask-BDA e em qualquer trabalho derivado criado usando o Flask-BDA. Cabe a você decidir como deseja distribuir a licença e aviso. Abaixo estão alguns exemplos de como isso pode ser feito:
Copyright 2021 Flask-BDA, Ryan Julyan licenciado sob a licença Flask-BDA versão 0.1 (a "licença"); Você não pode usar Flask-BDA exceto em conformidade com a licença. Você pode obter uma cópia da licença, em https://github.com/RyanJulyan/Flask-BDA/blob/main/LICENSE a menos que exigido pela lei aplicável ou acordada por escrito, o software distribuído sob a licença é distribuído em um " Como é "base, sem garantias ou condições de qualquer tipo, expresso ou implícito. Consulte a licença para o idioma específico que rege as permissões e limitações sob a licença.
