Crie um modelo de dados no Flask

Nossas aplicações são muito mais do que simples páginas, por isso devemos criar formas de armazenar os dados em algum sistema de persistência, é aqui que o Bases de dados O que está em jogo para estabelecer a forma como a Base de Dados nos vai ajudar é que os modelos têm de ser criados.
Um modelo dá-nos a estrutura sob a qual funcionará a maior lógica da nossa aplicação, é aqui que damos um sentido às diferentes entidades com que devemos ter para exercer as nossas acções.
Frasco você tem a possibilidade de usar diferentes tipos de Bases de dados apenas usando o ORM SQLAlchemy.
RequisitosPrecisamos de uma instalação funcional de Frasco, e as respectivas permissões para poder instalar mais componentes por meio pip. Se tivermos a possibilidade de trabalhar com Virtualenv é muito mais recomendado, porém não é necessário. Se quisermos extrapolar os exemplos do tutorial, precisaremos de alguns Base de dados O que MySQL caso queiramos trazer a funcionalidade para um ambiente muito mais real, pois nos exercícios que iremos trabalhar sqlite como medida de simplificação e para ser mais prática.
A primeira coisa que faremos é instalar SQLAlchemy, esta etapa é muito simples, só temos que executar o seguinte comando no console habilitado para executar pip:

 pip install flask-sqlalchemy

No final, receberemos uma mensagem de sucesso se tudo tiver corrido corretamente:

Vamos agora colocar SQLAlchemy para funcionar, para isso vamos criar uma pequena aplicação onde veremos como podemos estabelecer uma conexão com uma engine de Banco de Dados. Neste caso, nosso aplicativo será chamado flasko e dentro dela devemos ter a seguinte estrutura.
1- Um arquivo chamado run.py que vai ficar na raiz da aplicação, esse arquivo é o que faz a inicialização básica de todo o nosso ambiente.
2- Uma pasta chamada flasko e dentro dele um arquivo chamado __init__.py que é onde vamos inicializar o uso de frasco e de SQLAlchemy diretamente.
Vamos ver na imagem a seguir como essa estrutura se parece em um projeto:

Assim que soubermos o que devemos ter, teremos o conteúdo de nossos arquivos iniciais. No arquivo run.py devemos ter o seguinte:

 de flasko import appapp.run (debug = True)

Então, em nosso arquivo __init__.py, colocaremos este código:

 from flask import Flaskfrom flask.ext.sqlalchemy import SQLAlchemyapp = Flask (__ name __) app.config ['SQLALCHEMY_DATABASE_URI'] = 'sqlite: //flaskodb.db'db = SQLAlchemy (app)

Este último código é muito fácil de explicar, apenas importamos Frasco, então nós importamos SQLAlchemy, estabelecemos nosso aplicativo para trabalhar com a estrutura e, em seguida, estabelecemos a conexão com nosso Base de dados neste caso sqlite, onde será chamado flaskdb.db e estará no mesmo diretório de nosso aplicativo. Finalmente, atribuímos o objeto SQLAlchemy para uma variável chamada db com o qual trabalharemos mais tarde.
Se iniciarmos nosso aplicativo agora, ele deve iniciar sem erros, a única coisa é que não teremos resultado porque o aplicativo ainda está vazio.
Já que temos a configuração básica de nosso aplicativo agora devemos lançar as bases para criar nosso modelo, para isso teremos que criar uma pasta dentro de nossa pasta que contém o arquivo __init__.py e é aí que geraremos o conteúdo necessário.
Vamos ver como nossa estrutura de pastas é modificada:

Como podemos ver dentro de nossa nova pasta de produto, geramos 3 arquivos, um arquivo __init__.py que deve estar vazio, um arquivo models.py e outro views.py. Com esta estrutura vamos modificar nosso __init__.py a partir da raiz de nosso aplicativo, onde é importante não confundir com __init__.py de produtos.

 from flask import Flaskfrom flask.ext.sqlalchemy import SQLAlchemyapp = Flask (__ name __) app.config ['SQLALCHEMY_DATABASE_URI'] = 'sqlite: ///flaskodb.db'db = SQLAlchemy (app) from import flasko.product ._blueprint. (produto) db.create_all ()

O que fizemos é que após a criação do objeto db importamos as visualizações de nossa nova pasta e registramos um planta, finalmente informamos ao objeto db que ele deve criar todas as tabelas necessárias. Agora devemos modificar nosso arquivo models.py dentro do produto, e colocaremos o seguinte código:

 from flasko import dbclass Product (db.Model): id = db.Column (db.Integer, primary_key = True) name = db.Column (db.String (255)) price = db.Column (db.Float) def __init__ (self, name, price): self.name = name self.price = price def __repr __ (self): return ''% self.id

Aqui basicamente o que fazemos é definir uma classe que carregará como atributos os campos que iremos requerer de nosso produto, também dentro dele existem alguns métodos para a definição e representação de nosso modelo.
Assim que o acima for feito, vamos para o arquivo views.py, neste devemos criar o código que nos permite interagir com nosso modelo para isso devemos escrever o seguinte:

 from flask import request, jsonify, Blueprintfrom flasko import app, dbfrom flasko.product.models import Productproduct = Blueprint ('product', __name __) @ app.route ('/') @ app.route ('/ start') def start (): return "Bem-vindo ao Flasko" @ app.route ('/ product /') def product (id): product = Product.query.get_or_404 (id) return 'Product -% s, $% s'% ( product .name, product.price) @ app.route ('/ products') def products (): products = Product.query.all () res = {} para produto em produtos: res [product.id] = {' name ': product.name,' price ': str (product.price)} return jsonify(res)@app.route (' / create-product ', methods = [' POST ',]) def create_product (): name = request.form.get ('name') price = request.form.get ('price') product = Product (name, price) db.session.add (product) db.session.commit () return 'O produto foi criado com sucesso '

A primeira coisa que notamos é que temos muito mais conteúdo neste arquivo do que no resto de nosso aplicativo e é porque é aqui que toda a vida de nossa visão ocorre, o primeiro caminho é o início de nosso aplicativo e não envolvem qualquer mistério maior.
O segundo e terceiro roteiro são de consulta, onde podemos pesquisar por id do produto e caso não haja nada que retorne uma página 404, também contamos com a funcionalidade de listar todos os produtos disponíveis em nosso Base de dados.
A última rota é aquela que nos permite através do método PUBLICAR a criação de um produto e seu armazenamento subsequente em Base de dados, para isso instanciamos nosso modelo de produto, onde então passamos o referido atributo para o objeto db e com seus métodos adicionar Y comprometer-se nós adicionamos a Base de dados.
Agora o que resta testar nosso aplicativo é adicionar o conteúdo que irá em nosso Banco de Dados, se nos lembrarmos no arquivo views.py criamos uma visão que recebe dados por meio do método PUBLICAR e é o encarregado de fazer as inserções nele. Para adicionar elementos, vamos usar um módulo Pitão chamado solicitações de que nos permite enviar dados via POST, caso não os tenhamos basta instalá-los com o seguinte comando:

 pedidos de instalação pip

Em um console secundário, vamos iniciar nosso aplicativo flasko para que o servidor esteja ativo e seja capaz de enviar as solicitações de Pitão. Em nosso console interativo Pitão ao qual acessamos escrevendo a palavra Pitão, devemos fazer o seguinte:

 request.post ('http://127.0.0.1:5000/ create-product', data = {'name': 'product1', 'price': '50'})

O que fizemos foi enviar um pedido via PUBLICAR a nossa rota que adiciona os elementos ao Banco de Dados, os parâmetros são passados ​​em um dicionário Pitão que é muito semelhante a um objeto JSON.
Isso deve nos dar um código 200 que significa que efetivamente atendemos nossa solicitação, podemos ver isso na imagem a seguir:

Se agora navegarmos para nosso aplicativo na visualização de produtos, veremos como obtemos o que acabamos de inserir por meio do console:

Vemos que temos uma lista em formato JSON com nosso produto que acabamos de adicionar, se agora fizermos uma pesquisa na rota produto / 1 veremos que também o conseguiremos:

Claro que isso está longe de ser algo digno de ser colocado em produção, no entanto, nos ajuda a aprender os fundamentos dos modelos e da persistência de dados dentro Frasco, o mais interessante é que, uma vez que não fizemos investigações SQL direto, se mudarmos a conexão para sqlite para um para MySQL por exemplo, nosso aplicativo continuará funcionando normalmente.
Com isso terminamos este tutorial, já sabemos como criar modelos em FrascoAlém disso, aprendemos a manipular de uma forma básica, mas muito útil, o ORM SQLAlchemy, onde esses componentes são muito importantes quando estamos construindo aplicativos muito maiores, pois eles nos permitirão obter resultados mais complexos com menos trabalho.