tonistorres/jullia_rizza

study framework flask

Link Top de Pesquisa de Markdown Link da Documentação do Flask

Youtube Thi Code PlayList Flask Bootstrap

Estruturando Pastas e Arquivos iniciais de um Projeto MVC com Flask

Youtube Júlia Rizo PlayList Flask

Alembic API de Operações Documentação

O que é Flask? É um micro framework. Pense em um Micro-Framework como uma peça de lego. Inicialmente, um projeto criado com o micro-framework possui apenas o básico para funcionar, (normalmente, sistema de rotas), porém, ao decorrer do projeto, podem haver necessidades para utilização de outros recursos como, conexão de banco de dados, sistemas de templates, envio de email, etc. A partir desta necessidade, novas bibliotecas são “encaixadas” no projeto, como uma estrutura de lego.

Lançado em 2010 e desenvolvido por Armin Ronacher, o Flask é um micro-framework destinado principalmente a pequenas aplicações com requisitos mais simples, como por exemplo, a criação de um site básico.

Dica Importante: Para criar um projeto MVC inicial com Flask, seguimos a dica da tecnóloga Julia Rizzo como descrito no link conforme disposto na parte superior do REDEAME.md, composto com 07(sete) passos que foram escritor em linguagem shell script conforme detalhamento logo abaixo diposto:
PRIMEIRO PASSO: Iremos executar o arquivo 1_criando_ambiente_virtual.sh -> reponsável por configurar e criar o ambiente virtual python do projeto.
SEGUNDO PASSO: Iremos executar o arquivo 2_instalando_git_no_projeto.sh -> reponsável por fazer o controle de versionamento da aplicação de forma local e na núvem (github). TERCEIRO PASSO: Iremos executar o arquivo 3_instalando_flask.sh -> reponsável por fazer a instalação do microframework na pasta do projeto dentro do ambiente virtual setado.

QUARTO PASSO: Iremos executar o arquivo 4_salvando_dependências.sh -> reponsável por salvar todas libs do projeto dentro de uma arquivo txt chamado requeriments.txt.

QUINTO PASSO: Iremos executar o arquivo 5_run_server.sh -> reponsável executar o servidor (localhost) do flask onde iremos desenvolver a aplicação antes de hospedar na núvem.

SEXTO PASSO: Iremos executar o arquivo 6_limpando_port_5000.sh -> reponsável caso a aplicação esteja rodando em portas diferentes podemos stopar e iniciar a aplicação novamente.

SÉTIMO PASSO: Iremos executar o arquivo 7_initiall_aplication_flask.sh -> reponsável por criar a estrutura MVC (grupo de pastas e sub-pastas iniciais do projeto), e criar e escrever arquivos iniciais de configuração do projeto e roda o projeto inicial hellow world.

Vídeo Exemplo Organizando aplicação no modelo MVC

Organizando a aplicação no modelo MVC

• 1º vamos criar a pasta principal a nomearei de app
  

• 2º Dentro da pasta principal app, iremos criar as seguintes sub-pastas:
  

  • models - iremos tercerizar essa camada para orm sqlalchemy;
  • controllers - onde ficará a lógica da aplicação;
  • static - onde ficarão os arquivos estáticos (css) ...
  • tempaltes - onde ficarão os arquivos html.

Observação 1: No flask temos um padrão que toda pasta contendo arquivo html se chamam templates e a pasta que contém arquivos estáticos(css) se chama static

Ilustração:

Observação 2: dentro da pasta principal app criaremos um arquivo com o nome __init__.py utilizamos esse procedimento de criar esse arquivo quando iremos treabalhar com módulos dentro do python. O __init__.py aqui explicitádo está indicando que a pasta app é o módulo principal e que no futuro teremos sub-módulos dentro da pasta app onde cda uma das pastas terão __init__.py com exceção da pasta templates e static

O __init__.py principal que está dentro da pasta app conterá as configurações principais do flask.

Ilustração arquivo __init__.py da pasta app:

from flask import Flask


app = Flask(__name__)

# importando o módulo controllers para o módulo  
# principal de execução
from app.controllers import default

Observação 3: No arquivo run.py ficará a lógica para iniciar a execução da aplicação.

# Neste arquivo ficará a lógica para startar
# a aplicação

from app import app


if __name__ =="__main__":
    app.run()

Observação 4: a camada de controllers será conterá os arquivos de lógica da aplicação, como exemplo inicial temos o arquivos (__init__.py) indicando que é um sub-módulo de app dentro do python e temos o arquivo (default.py) com um exemplo de hello word na rota index da aplicação.

from app import app 

@app.route("/")
def index():
    return f" 🤟 Hellow World"

Desenvolvedor Sql Alchemy e Alembic Mike Bayers

Link Blog Mike Bayers

Youtube Júlia Rizo Falsk SQlAlchemy

O que é Flask SqlAlchemy? É um ORM completo, criado com Python para desenvolvedores de aplicativos, que fornece flexibilidade total do SQL, obtendo um conjunto completo de padrões de persistência de nível corporativo bem conhecidos, que são projetados para acesso a banco de dados eficientes e de alto desempenho.
Ele permite que você crie modelos de dados e consultas de uma maneira que se sente como classes e declarações normais do python.

Por que usar o SQL Alchemy?
* Abstrair seu código de SQL;
* Aproveitar declarações e tipos comuns instruções SQL sejam criadas de forma eficiente;
* Evitar ataques comuns, como ataque de sql injection;
* É um banco extensível (trabalha com Oracle, Postgres, Mysql etc.)
* Trabalha em dois modos diferentes (Core e ORM).

Sql Alchemy ORM 9min e 22seg Dunossauro

Características do ORM SQL Alchemy:

* Se parece tradicionalmente com outro ORMs;
* Fornece uma grande camada de abstração do SQL, porém, converte tudo para a camada do core;
* Trata tabelas e dados com a abstração de classes e objetos;
* Pode ser usada com o Core para camadas mais abstratas.

Tabela de tipos:

Instalação:
Já setado no ambiente virtual do módulo python a ser trabalhado, digite o seguinte comando: pip3 install flask-sqlalchemy

SqlAlchemy Core:

Os tipos de dados e as abstrações necessárias para executar a API de operações estão no SQL Alchemy Core. Também podemos dizer que é uma meneira pythonica de representar seus dados sem perder o sotaque do SQL.
Focado diretamente no banco de dados e seu esquema. Proporciona a base para o ORM.

criando nossa primeira tablea com SQL CORE

Modelo do Banco de Dados a ser Trabalhado no Projeto:

DOCUMENTAR DEPOIS A PARITR 23 min : 56 seg

O que é o Alembic?

O Alembic é uma ferramenta de modo texto, ou seja, temos que executar comando a partir de um terminal. Nada de play do editor de código de sua preferência

O Alembic foi inicialmente desenvolvido por Mike Bayers, mesmo criador do SQLAlchemy. Teve sua primeira versão lançada em novembro de 2011. 5 anos após a primeira versão do SQLAlchemy, em 2006.
* Pode trabalhar em toda a camada DDL;
* Fornece scripts de migração de schemas para upgrades e downgrades;
*Suporte a geração de SQL (offline);
* API minimalista.

Instalação: Se preferir execute o script sheel 9_instalando_alembic.sh a partir do terminal executando o comando a baixo explicitado e o script irá instalar o alembic de forma automática:

bash 9_instalando_alembic.sh

Execução:

Entre na pasta do projeto, em nosso caso o diretório(app) e execute o comando abaixo conforme ilustração: O comando abaixo init nos diz que iremos inicializar um sistema de migrações dentro da nossa aplicação

Se preferir entre na pasta app por meio do terminal e execute o script 10_inicio_sistema_migracao.sh conforme explicitado logo abaixo:

cd app 
bash 10_inicio_sistema_migracao.sh

Estrutura Criada no Projeto pelo comandoalembic init migrations

Arquivos Importante Criados Juntos a Estrutura de Pastas:

* alembic.init
O script escrito no alembic.init é uma arquivo criado de forma automática, portanto, genérico que consiste numa configuração para um único banco de Dados.

Conteúdo do script alembic.ini, somente os comandos base (contendo as configuraçẽos principais) para acoplá-lo ao ORM Sql Alchemy

# A generic, single database configuration.
'''
Esse comentário indica que essa é uma configuração genérica, que irá 
funcionar em um único banco de dados.
'''


[alembic]
# path to migration scripts
'''
Em trocados e miudos, o alembic pergunta onde estão os scripts criados para execução do alembic. Em nosso caso 
dentro em app numa sub-pasta por nome migrations
'''
script_location = app/migrations

'''
Alembic pergunta de onde eu preciso partir para encontrar 
o caminho passado em script_location - a resposta é a partir
do diretório raiz ponto ( . ) 
'''
prepend_sys_path = .


version_path_separator = os  

'''
Qual a uri do meu banco de dados
'''
sqlalchemy.url = mysql+pymysql://root:1020@localhost:3306/dbtwitterjulia

Dentro da estrutura de pasta e arquivos criado pelo comando:

alembic init migrations

temos o arquivo env.py que é onde são feitas as configurações das migrações.
Corpo do arquivo env.py contido dentro da pasta migrations de acordo com nosso modelo MVC.

from logging.config import fileConfig

from sqlalchemy import engine_from_config
from sqlalchemy import pool

from alembic import context

config = context.config

if config.config_file_name is not None:
    fileConfig(config.config_file_name)

target_metadata = None

'''
ofline ele gera um sql para usarmos esse código depois em nosso banco de dados

'''


def run_migrations_offline() -> None:
    url = config.get_main_option("sqlalchemy.url")
    context.configure(
        url=url,
        target_metadata=target_metadata,
        literal_binds=True,
        dialect_opts={"paramstyle": "named"},
    )

    with context.begin_transaction():
        context.run_migrations()
'''
Uma migração online que dizer que no momento que eu pedir para rodar a migraçao ele irá rodar essa migração no banco de dados

'''

def run_migrations_online() -> None:

    connectable = engine_from_config(
        config.get_section(config.config_ini_section, {}),
        prefix="sqlalchemy.",
        poolclass=pool.NullPool,
    )

    with connectable.connect() as connection:
        context.configure(
            connection=connection, target_metadata=target_metadata
        )

        with context.begin_transaction():
            context.run_migrations()


if context.is_offline_mode():
    run_migrations_offline()
else:
    run_migrations_online()

Canal Dunossauro Vídeo 34min:21s

Tudo Pronto Criando nossa primeira migração :

- Comando que criar um versionamento na pasta migrations conforme configurações aqui explicitada logo no readme.mb acima.

Corpo do Script (conteúdo do versionamento):

Canal Dunossauro Vídeo 37min Funções upgrade e downgrade

"""primeira

Revision ID: 41244e6b200b
Revises: 
Create Date: 2023-11-04 08:51:40.598200

"""
from typing import Sequence, Union

# Api de operações DDL 
from alembic import op


import sqlalchemy as sa


# revision identifiers, used by Alembic.
revision: str = '41244e6b200b'
down_revision: Union[str, None] = None
branch_labels: Union[str, Sequence[str], None] = None
depends_on: Union[str, Sequence[str], None] = None

# (Explicação Youtube em 37 min)[https://www.youtube.com/watch?v=yQtqkq9UkDA&t=14s]

# upgrade -> é a função que aplica a migração, ou seja, como é que essa migração será aplicada de fato.
# Exemplo: Quero criar uma tabela, quero modificar ... 


def upgrade() -> None:
    op.create_table(
        'user',
        sa.Column('id', sa.Integer(),primary_key=True),
        sa.Column('username', sa.String(length=50), nullable=False),
        sa.Column('password', sa.String(length=10),nullable=False),
        sa.Column('name', sa.String(length=60),nullable=False),
        sa.Column('email', sa.Integer(length=100))
        
    )

# downgrade -> quero excluir uma tabela, remover a coluna 
def downgrade() -> None:
    op.drop_table(
        'user'
    )

Canal Dunossauro Vídeo 46min 30seg Aplicando Migrações

Aplicando migração:

No arquivo alembic.ini na pasta raiz iremos fazer configuração da URI do banco de dados que estamos trabalhando.

Executando codigo que startar migração:

Explicação do comando alembic upgrade head 48min 55seg

# head -> Executa todas as migrações relacionadas a função upgrade
alembic upgrade head

Desfazendo a migração comando:

# Executa todas a migrações relacionada a função donwgrade 
alembic downgrade base

Vê o Histórico comando:

# histórico da execução das migrações
alembic history

Executando SQL Personalizado com Alembic

Para esse exemplo estudar esse link

relacionamento de tabelas com sql gerar as migrações de relacionamento

op.execute('create view product_view as select * from product')

Da prosseguimento a partir daqui

Dunossauro 52min